Understanding Instruction List for PLC Programming

An Instruction List (IL) is a low-level programming language used in industrial automation, specifically for Programmable Logic Controllers (PLCs) and other industrial control systems. It is one of the five standard languages defined by the IEC 61131-3 standard (the global standard for PLC programming) and is modeled after assembly language—using simple mnemonics (e.g., LD for “Load”, AND for logical AND) to represent operations executed sequentially. IL is particularly useful for small-scale control tasks, troubleshooting, or optimizing performance-critical code.

Core Characteristics of Instruction List

1. Low-Level, Assembly-Like Syntax

IL uses a line-by-line structure where each line consists of:

A mnemonic (operation code, e.g., LD, OR, OUT).
An operand (memory address, constant, or variable, e.g., I0.0, Q0.1, MW10).
Optional comment (for documentation, prefixed by // or ;).

Example line:

LD I0.0       // Load input I0.0 (sensor signal) into the accumulator

2. Accumulator-Based Execution

IL relies on a virtual accumulator (a temporary storage register) to hold intermediate results:

Most operations read from the accumulator, process data, and write back to the accumulator.
The accumulator stores boolean (1/0) values for logic operations or numerical values (integers, floats) for arithmetic operations.

3. Sequential Execution

Instructions are executed in the order they are written (top to bottom), unless conditional jumps (e.g., JMP, JC) are used to alter the flow. This makes IL straightforward for linear control logic but less intuitive for complex branching than graphical languages like Ladder Diagram (LD).

4. Support for Multiple Data Types

IL handles both boolean (discrete) and non-boolean (analog) data:

Boolean: For logic operations (e.g., I0.0 = input sensor, Q0.1 = output relay).
Integer/Float: For arithmetic operations (e.g., MW10 = 16-bit memory word, MD20 = 32-bit floating-point register).
Timers/Counters: For time-based or count-based control (e.g., T1 = on-delay timer, C5 = up-counter).

Key Instructions in IL

IEC 61131-3 defines standard IL mnemonics, grouped by function:

1. Boolean Logic Instructions

Mnemonic	Description	Example
`LD`	Load operand into accumulator (start of logic rung)	`LD I0.0` (Load input I0.0)
`LDN`	Load negated operand (NOT)	`LDN I0.1` (Load NOT I0.1)
`AND`	Logical AND with accumulator	`AND I0.2` (Accumulator = Accumulator AND I0.2)
`ANDN`	Logical AND with negated operand	`ANDN I0.3` (Accumulator = Accumulator AND NOT I0.3)
`OR`	Logical OR with accumulator	`OR I0.4` (Accumulator = Accumulator OR I0.4)
`ORN`	Logical OR with negated operand	`ORN I0.5` (Accumulator = Accumulator OR NOT I0.5)
`XOR`	Logical XOR with accumulator	`XOR I0.6` (Accumulator = Accumulator XOR I0.6)
`NOT`	Invert accumulator value (1→0, 0→1)	`NOT`
`OUT`	Write accumulator value to output operand	`OUT Q0.0` (Set output Q0.0 to accumulator value)

2. Arithmetic Instructions

Mnemonic	Description	Example
`LDI`	Load integer constant into accumulator	`LDI 100` (Load 100 as integer)
`ADD`	Add operand to accumulator	`ADD MW10` (Accumulator = Accumulator + MW10)
`SUB`	Subtract operand from accumulator	`SUB MD20` (Accumulator = Accumulator – MD20)
`MUL`	Multiply accumulator by operand	`MUL 2.5` (Accumulator = Accumulator × 2.5)
`DIV`	Divide accumulator by operand	`DIV MW30` (Accumulator = Accumulator ÷ MW30)
`STI`	Store accumulator (integer) to operand	`STI MW40` (Save accumulator value to MW40)

3. Timer/Counter Instructions

Mnemonic	Description	Example
`TON`	On-delay timer (start timer, output goes high after preset time)	`TON T1, PT=100` (Timer T1, preset 100ms)
`TOF`	Off-delay timer (output stays high for preset time after input goes low)	`TOF T2, PT=500` (Timer T2, preset 500ms)
`CTU`	Up-counter (increment count on input trigger)	`CTU C1, PV=10` (Counter C1, preset 10 counts)
`CTD`	Down-counter (decrement count on input trigger)	`CTD C2, PV=5` (Counter C2, preset 5 counts)

4. Jump Instructions (Flow Control)

Mnemonic	Description	Example
`JMP`	Unconditional jump to label	`JMP LABEL1` (Jump to LABEL1)
`JC`	Jump if accumulator is 1 (conditional)	`JC LABEL2` (Jump to LABEL2 if accumulator = 1)
`JNC`	Jump if accumulator is 0 (conditional)	`JNC LABEL3` (Jump to LABEL3 if accumulator = 0)
`LABEL`	Define a jump target	`LABEL1:` (Label for jump target)

Example IL Program

Below is a simple IL program for a motor control system:

Inputs: I0.0 (Start button), I0.1 (Stop button), I0.2 (Overload sensor).
Output: Q0.0 (Motor relay).
Logic: Start motor when I0.0 is pressed; stop when I0.1 or I0.2 is triggered (latching control).

// Motor Control IL Program
LD I0.0       // Load Start button (I0.0)
OR Q0.0       // Latch: OR with motor output (Q0.0) to keep motor running
ANDN I0.1     // Stop if Stop button (I0.1) is pressed (NOT I0.1)
ANDN I0.2     // Stop if Overload sensor (I0.2) is triggered (NOT I0.2)
OUT Q0.0      // Write result to motor output (Q0.0)

// Optional: Timer to auto-stop motor after 10 seconds
LD Q0.0       // Load motor output status
TON T1, PT=100 // Start on-delay timer T1 (100ms × 100 = 10s)
LD T1         // Load timer T1 output
OUT Q0.1      // Trigger auto-stop indicator (Q0.1)
JNC END       // If timer not expired, jump to END
LD 0          // Load 0 to stop motor
OUT Q0.0      // Turn off motor output
END:          // Label for jump target

Use Cases for Instruction List

1. Small-Scale Control Logic

IL is ideal for simple tasks (e.g., motor start/stop, sensor monitoring) where minimal code is needed and speed is critical.

2. Troubleshooting & Debugging

IL’s line-by-line structure makes it easy to trace execution step-by-step, which is useful for diagnosing issues in complex PLC programs.

3. Performance Optimization

Since IL is low-level, it can be optimized for faster execution (e.g., reducing memory accesses) compared to higher-level languages like Structured Text (ST).

4. Legacy System Support

Many older PLCs (e.g., Siemens S5, Allen-Bradley MicroLogix) use IL or assembly-like languages, so IL is still relevant for maintaining legacy systems.

5. Hybrid Programming

IL is often combined with other IEC 61131-3 languages (e.g., Ladder Diagram for main logic, IL for arithmetic subroutines) to balance readability and performance.

IL vs. Other IEC 61131-3 Languages

Feature	Instruction List (IL)	Ladder Diagram (LD)	Structured Text (ST)
Syntax	Assembly-like, line-by-line	Graphical (rungs, contacts/coils)	Text-based (Pascal-like)
Readability	Low (for complex logic)	High (for electrical engineers)	High (for software engineers)
Performance	High (minimal overhead)	Medium (graphical abstraction)	Medium (compiled to IL)
Best For	Small logic, troubleshooting, optimization	Industrial control (motor, conveyor)	Complex algorithms (PID, math)
Learning Curve	Steep (requires low-level understanding)	Gentle (familiar to electricians)	Moderate (programming experience)

Advantages & Limitations of IL

Advantages

Speed: Minimal execution overhead, ideal for time-critical operations.
Precision: Direct control over memory and registers (useful for hardware-specific tasks).
Compactness: Requires fewer lines of code than graphical languages for simple logic.