Ladder Logic (LD)

Ladder Logic, also known as Relay Ladder Logic (RLL), is the oldest and perhaps most widely recognized PLC programming language. It's designed to mimic the look and feel of traditional electromechanical relay circuits, making it intuitive for electricians and technicians familiar with relay-based control systems.

In Ladder Logic, the program is represented as a series of rungs on a ladder. Each rung represents a logical condition that must be true for the output on that rung to be energized. Contacts (inputs) and coils (outputs) are connected by vertical lines representing power rails. The logic flow is from left to right. The simplicity and visual nature of ladder logic make it great for discrete control applications.

Example Ladder Logic Circuit

Consider a simple circuit where a motor starts when both a Start button and an Overload Reset button are pressed:

--] [----] [----------------------( )--
             Start  Overload Reset           Motor

            --] [------------------------------( )--
             Motor                            Motor (latching)

This ladder logic would translate to: IF Start AND Overload Reset are TRUE, THEN energize the Motor coil. The second rung ensures that the motor remains running even after the start button is released (latching).

Function Block Diagram (FBD)

Function Block Diagram (FBD) is a graphical programming language that represents a program as a network of interconnected function blocks. Each function block performs a specific task, such as mathematical operations, logical comparisons, or signal processing. FBD is particularly well-suited for process control applications and complex algorithms.

Function blocks have inputs and outputs, and they are connected by lines that represent the flow of data. This modular approach promotes code reusability and simplifies the development of complex control systems. FBD is a powerful tool for engineers and programmers who need to implement sophisticated control strategies.

Example Function Block Diagram

A PID control loop implemented using FBD might consist of blocks for Proportional, Integral, and Derivative calculations, as well as blocks for summing the results and applying a limit.

Structured Text (ST)

Structured Text (ST) is a high-level, text-based programming language that resembles Pascal or C. It allows for the creation of complex algorithms and control logic using familiar programming constructs such as loops, conditional statements, and functions. ST is particularly useful for applications requiring complex data manipulation, advanced calculations, or communication protocols.

ST is a powerful and flexible language that enables programmers to create sophisticated control systems. Its text-based format makes it easy to read and maintain, and its support for structured programming techniques promotes code reusability and reduces the risk of errors.

Example Structured Text Code

Here's an example of ST code that calculates the average of an array of values:

PROGRAM AverageCalculation
                VAR
                    InputArray : ARRAY[1..10] OF REAL;
                    Sum : REAL := 0.0;
                    Average : REAL;
                    i : INT;
                END_VAR

                FOR i := 1 TO 10 DO
                    Sum := Sum + InputArray[i];
                END_FOR;

                Average := Sum / 10.0;
            END_PROGRAM

Instruction List (IL)

Instruction List (IL), also known as Assembler Language, is a low-level, text-based programming language that uses mnemonics to represent machine instructions. IL provides direct control over the PLC's hardware, allowing programmers to optimize performance and access specific hardware features. However, IL is more difficult to learn and use than other PLC programming languages, and it requires a deep understanding of the PLC's architecture.

While IL is less commonly used than Ladder Logic, FBD, or ST, it remains a valuable tool for experienced programmers who need to fine-tune their control systems or access specific hardware functionalities.

Example Instruction List Code

LD  %I0.0   // Load input %I0.0
            AND %I0.1   // AND with input %I0.1
            OR  %M0.0   // OR with memory bit %M0.0
            ST  %Q0.0   // Store result in output %Q0.0

Sequential Function Chart (SFC)

Sequential Function Chart (SFC), also known as Grafcet, is a graphical programming language that is used to describe sequential control processes. SFC uses a series of steps and transitions to define the sequence of operations that a PLC should perform. Each step represents a specific state of the system, and each transition represents a condition that must be met for the system to move to the next step.

SFC is particularly well-suited for applications involving complex sequences of operations, such as batch processing, automated assembly lines, and robotics. Its graphical representation makes it easy to understand and maintain, and its modular structure promotes code reusability and simplifies the development of complex control systems.

Comparison of PLC Logic Types