Plc Programming Basics

From controlling a single motor to managing entire production lines, PLCs offer a robust, adaptable, and efficient solution for automation challenges. As the industry continues its rapid evolution towards Industry 4.0, proficiency in PLC programming empowers professionals to design, implement, and maintain the sophisticated automated systems that define contemporary manufacturing excellence.

What is a PLC? From Relays to Processors

A Programmable Logic Controller (PLC) is an industrial digital computer that has been ruggedized and adapted for the control of manufacturing processes, such as assembly lines, robotic devices, or any activity that requires high reliability control, ease of programming, and process fault diagnosis. Historically, control systems relied on complex arrays of electromechanical relays, timers, and counters to implement control logic. These relay-based systems were cumbersome, difficult to modify, and prone to failures due to moving parts.

The advent of the PLC in the late 1960s revolutionized industrial control. Initially designed to replace relay logic, PLCs offered a solid-state, programmable solution that drastically reduced wiring complexity, simplified troubleshooting, and enabled rapid modifications to control sequences. Unlike general-purpose computers, PLCs are built to withstand harsh industrial environments, featuring robust hardware, noise immunity, and real-time operating capabilities. Their primary function is to monitor inputs from sensors and other field devices, execute a user-defined control program based on these inputs, and then actuate outputs to control motors, valves, lights, and other machinery.

The core advantage of PLCs lies in their reprogrammability and modular design. A single PLC can handle a vast range of control tasks, and its logic can be altered simply by modifying the program, without needing to rewire physical components. This flexibility is paramount in dynamic manufacturing environments where processes frequently evolve or require fine-tuning.

Anatomy of a Programmable Logic Controller System

Central Processing Unit (CPU)

The CPU is the brain of the PLC. It executes the control program, performs logical operations, makes decisions, and manages memory and communications. Modern PLC CPUs are powerful microprocessors capable of high-speed processing, supporting complex algorithms, and handling extensive I/O points. The CPU module often includes memory for storing the program and data, as well as communication ports for programming and interfacing with other devices.

Input/Output (I/O) Modules

I/O modules are the interface between the PLC’s CPU and the real-world field devices. They are broadly categorized into digital (discrete) and analog modules.

• Digital Input Modules: These modules detect the on/off status of discrete sensors such as limit switches, pushbuttons, proximity sensors, and selector switches. They convert varying input voltages into a digital signal that the CPU can process.
• Digital Output Modules: These modules send on/off signals to discrete actuators like motor starters, solenoid valves, indicator lights, and relays. They convert the CPU’s digital signals into appropriate voltage levels to drive these devices.
• Analog Input Modules: These modules convert continuous electrical signals (e.g., 4-20mA, 0-10V) from analog sensors (e.g., temperature sensors, pressure transducers, flow meters) into digital values that the CPU can process.
• Analog Output Modules: These modules convert digital values from the CPU into continuous electrical signals to control analog actuators such as variable frequency drives (VFDs), proportional valves, and chart recorders.

Power Supply Module

The power supply module provides the necessary DC power to the CPU, I/O modules, and sometimes external field devices. It converts incoming AC line voltage (e.g., 120V AC or 240V AC) into the regulated DC voltages (e.g., 24V DC, 5V DC) required by the internal PLC electronics.

Programming Device

A programming device, typically a personal computer running specialized PLC programming software (e.g., Mitsubishi Electric’s GX Works3), is used to write, download, upload, monitor, and troubleshoot the PLC program. This device communicates with the PLC via various protocols such as Ethernet, USB, or serial connections.

Communication Modules

Many PLCs include dedicated communication modules that allow them to interface with other PLCs, Human-Machine Interfaces (HMIs), Supervisory Control and Data Acquisition (SCADA) systems, and enterprise networks. Common industrial communication protocols include Ethernet/IP, PROFINET, Modbus TCP/IP, CC-Link, and OPC UA.

Understanding PLC Programming Languages

The International Electrotechnical Commission (IEC) standard IEC 61131-3 defines five primary programming languages for PLCs, providing a standardized approach across different manufacturers. While all are valuable, Ladder Logic remains the most widely used, especially for beginners learning PLC programming basics.

1. Ladder Diagram (LD) / Ladder Logic

Ladder Logic is by far the most popular and historically significant PLC programming language. It graphically resembles the electrical relay control circuits it was designed to replace, making it intuitive for electricians and control technicians. A ladder diagram consists of two vertical rails representing power (left) and ground (right), with horizontal “rungs” between them. Each rung represents a logical operation.

• Contacts: Represent input conditions (e.g., pushbuttons, limit switches). They can be “Normally Open” (NO), meaning they are open (no current flows) until activated, or “Normally Closed” (NC), meaning they are closed (current flows) until activated.
• Coils: Represent output devices (e.g., motor starters, lights, solenoids). If the logic path to a coil is true (power flows through the rung), the coil is energized, activating the associated output.
• Timers and Counters: Special instructions that allow for time-based operations and counting events.

Example Ladder Logic Rung:

A simple rung for a motor start/stop control:

[–| |———-|/|———-( )–]
    Start_PB    Stop_PB    Motor_Run

This rung shows that if the “Start_PB” (Start Pushbutton) is pressed (making the NO contact close) AND the “Stop_PB” (Stop Pushbutton) is not pressed (making the NC contact stay closed), then the “Motor_Run” coil will be energized.

2. Structured Text (ST)

Structured Text is a high-level, text-based language that resembles Pascal or C. It is particularly powerful for complex calculations, data manipulation, loops, and conditional statements that would be cumbersome to implement in Ladder Logic. It’s often preferred by programmers with a software development background.

Example Structured Text:

IF Start_PB THEN
        Motor_Run := TRUE;
    END_IF;

    IF Stop_PB THEN
        Motor_Run := FALSE;
    END_IF;

3. Function Block Diagram (FBD)

FBD is a graphical language that uses pre-defined function blocks (e.g., AND, OR, timers, counters, PID controllers) to represent control logic. Inputs and outputs are connected by lines, making it easy to visualize data flow. It’s often used for continuous control processes and complex algorithms.

4. Instruction List (IL)

Instruction List is a low-level, text-based language similar to assembly language. It uses mnemonics to represent operations and operands. While powerful for experienced programmers, its lack of graphical representation makes it less intuitive for debugging complex programs. It is less common in modern PLC programming, often superseded by Structured Text for text-based tasks.

5. Sequential Function Chart (SFC)

SFC is a graphical language used for designing sequential control processes. It organizes a program into steps, transitions, and actions. Steps represent stable states of a process, transitions define the conditions for moving between steps, and actions are executed within steps. SFC is excellent for managing complex sequences, batch processes, and fault recovery.

The Foundational Concepts of PLC Programming

To write effective PLC programs, a solid grasp of several core concepts is indispensable. These concepts form the bedrock of PLC programming basics.

Inputs and Outputs (I/O)

As discussed, inputs are signals from the real world that the PLC reads (e.g., button presses, sensor readings), and outputs are signals the PLC sends to control devices (e.g., turning on a motor, opening a valve). Properly assigning and addressing I/O points is the first step in any PLC project.

Memory Addressing and Data Types

PLCs allocate specific memory areas for storing input status, output status, program instructions, and data. Each memory location has a unique address. Data within these locations can take various forms:

• Bit: The smallest unit of data, representing a binary 0 or 1 (e.g., true/false, on/off). Used for discrete I/O and internal flags.
• Byte: A group of 8 bits.
• Word: A group of 16 bits.
• Double Word: A group of 32 bits.
• Data Types: Modern PLCs support various data types beyond just bits, including integers (INT, DINT), floating-point numbers (REAL), strings (STRING), and custom structures. Choosing the correct data type is crucial for efficient memory usage and accurate calculations.

Timers

Timers are critical for controlling processes based on time. Common types include:

• Timer ON-Delay (TON): Delays turning an output ON for a specified duration after its input condition becomes true.
• Timer OFF-Delay (TOF): Delays turning an output OFF for a specified duration after its input condition becomes false.
• Retentive Timer ON (RTO): Similar to TON, but its accumulated time value is retained even if the input condition becomes false or power is lost. It resumes timing from where it left off when the input becomes true again.

Counters

Counters are used to count events or occurrences. They typically have an input to increment/decrement and a reset input.

• Count Up (CTU): Increments its count value each time its input condition transitions from false to true.
• Count Down (CTD): Decrements its count value each time its input condition transitions from false to true.

Internal Relays/Flags/Memory Bits

These are virtual relays or bits within the PLC’s memory that do not directly correspond to physical inputs or outputs. They are used to store intermediate logic results, create internal conditions, or serve as temporary flags within the program. They are essential for creating complex logical sequences that require memory of past events or conditions.

The PLC Scan Cycle

PLCs operate on a continuous scan cycle, which is the sequential execution of the program. Understanding the scan cycle is crucial for predicting program behavior and troubleshooting. A typical scan cycle involves three main phases:

1. Input Scan: The PLC reads the current status of all its physical input devices and updates its internal input memory table.
2. Program Execution: The CPU executes the user program rung by rung, using the input status from the input memory table and the current status of internal memory bits. As it processes the logic, it updates an internal output memory table.
3. Output Scan: The PLC writes the status of its internal output memory table to the physical output devices.

This cycle repeats continuously, typically hundreds or thousands of times per second. The scan time (the time it takes to complete one full cycle) is a critical performance parameter, especially in high-speed applications.

Practical Steps: Developing Your First PLC Program (A Motor Control Example)

Let’s walk through a practical example of creating a basic PLC program to control a motor using start and stop pushbuttons, along with an indicator light. This demonstrates fundamental PLC programming basics using Ladder Logic.

Problem Definition

We need to control a motor such that:

1. A momentary “Start” pushbutton turns the motor ON.
2. A momentary “Stop” pushbutton turns the motor OFF.
3. Once started, the motor remains ON until the “Stop” button is pressed.
4. An indicator light should illuminate when the motor is running.
5. A separate “Motor Overload” input will immediately stop the motor if activated.

1. Identify Inputs and Outputs (I/O Assignment)

First, we define our physical connections and assign symbolic addresses:

• Inputs:
  • Start Pushbutton (NO): I0.0 (e.g., Mitsubishi X0) – Symbolic Tag: Start_PB
  • Stop Pushbutton (NC): I0.1 (e.g., Mitsubishi X1) – Symbolic Tag: Stop_PB
  • Motor Overload (NC): I0.2 (e.g., Mitsubishi X2) – Symbolic Tag: Motor_OL
• Outputs:
  • Motor Contactor: Q0.0 (e.g., Mitsubishi Y0) – Symbolic Tag: Motor_Contactor
  • Motor Running Light: Q0.1 (e.g., Mitsubishi Y1) – Symbolic Tag: Run_Light

2. Develop the Ladder Logic

We’ll create several rungs to achieve the desired control.

Rung 1: Motor Start/Stop Logic (Latching Circuit)

This rung implements the core start/stop functionality with a latching mechanism (seal-in circuit) to keep the motor running after the start button is released.

--------------------------------------------------------------------------------------
|               Start_PB        Stop_PB       Motor_OL              Motor_Contactor |
|-----| |----------|/|-----------|/|-------------+---------------------( )---------|
|     |                                           |                                  |
|     |                                           | Motor_Contactor                  |
|     |                                           |---| |----------------------------|
--------------------------------------------------------------------------------------

Explanation:

• Start_PB (NO contact): When pressed, it allows power to flow.
• Stop_PB (NC contact): Normally closed, allowing power to flow. When pressed, it opens, breaking the circuit.
• Motor_OL (NC contact): Normally closed, allowing power to flow. When an overload occurs, it opens, breaking the circuit.
• Motor_Contactor (Output coil): Energizes the motor.
• Motor_Contactor (NO contact, parallel to Start_PB): This is the “latch” or “seal-in” contact. Once Motor_Contactor is energized, this contact closes, providing an alternative path for power around the Start_PB. This keeps the motor running even after Start_PB is released, until Stop_PB or Motor_OL opens.

Rung 2: Motor Running Indicator Light

This rung simply turns on the indicator light when the motor is running.

--------------------------------------------------------------------
|               Motor_Contactor                     Run_Light      |
|-----| |-----------------------------------------------( )--------|
--------------------------------------------------------------------

Explanation:

• Motor_Contactor (NO contact): This contact is true (closed) whenever the Motor_Contactor coil from Rung 1 is energized.
• Run_Light (Output coil): This coil is energized, turning on the indicator light, whenever the Motor_Contactor is active.

3. Simulate, Download, and Test

Once the logic is written in the PLC programming software, the next steps involve:

1. Simulation: Use the software’s built-in simulator to test the logic without hardware. Toggle inputs and observe outputs.
2. Download: Connect the programming device to the physical PLC and download the program.
3. Test: With the PLC in RUN mode, physically operate the pushbuttons and observe the motor and light behavior. Verify that the motor stops immediately on “Stop_PB” or “Motor_OL” activation.

This simple example illustrates the fundamental concepts of inputs, outputs, logic gates (implied by series/parallel contacts), and latching, which are foundational to all PLC programming.

Best Practices for Robust PLC Programming

Developing efficient, reliable, and maintainable PLC programs goes beyond understanding the syntax of languages. Adhering to best practices is crucial for long-term success in industrial automation.

• Modular Design: Break down complex programs into smaller, manageable subroutines, functions, or function blocks. This improves readability, simplifies troubleshooting, and promotes code reuse. For instance, a common motor control routine can be encapsulated as a reusable function block.
• Clear Documentation and Comments: Industrial environments are dynamic. Document your code extensively with comments explaining the purpose of rungs, functions, and specific logic sections. Use meaningful tag names for I/O and internal memory bits (e.g., Motor1_Start_PB instead of I0.0). This is invaluable for future maintenance, upgrades, and for other engineers who may need to work with your code.
• Error Handling and Alarming: Implement robust error detection and handling routines. This includes monitoring critical sensor failures, motor overloads, and unexpected process states. Configure alarms to notify operators of issues, providing clear diagnostic messages and potential remedies.
• Safety First: Always integrate safety features at the hardware level (e.g., safety relays, emergency stop circuits independent of the PLC where critical). Use PLC logic to monitor safety devices but understand that PLCs are generally not rated for safety integrity levels (SIL) required for primary safety functions without certified safety PLCs or external safety circuits.
• Structured Programming Principles: Even in Ladder Logic, adhere to structured programming. Avoid “spaghetti code” with excessive jumps (JMP instructions) or poorly organized logic. Sequence operations logically.
• Thorough Testing and Simulation: Never deploy a program without rigorous testing. Utilize simulation tools, and when possible, test with the actual hardware on a test bench before deployment to a live production environment. Test edge cases and failure scenarios.
• Version Control: Implement a system for version control of your PLC programs. This allows you to track changes, revert to previous stable versions, and manage multiple program variations across different machines or updates.
• Standardization: Where possible, standardize programming approaches, tag naming conventions, and code structures across different projects. This reduces learning curves for engineers working on various systems.
• Performance Optimization: While modern PLCs are fast, be mindful of scan time, especially in high-speed applications. Optimize logic where possible, avoid excessive use of floating-point arithmetic if integers suffice, and use efficient data structures.

Mitsubishi’s Role in Modern Industrial Automation

As a global leader in manufacturing and industrial automation, Mitsubishi Electric provides a comprehensive range of Programmable Logic Controllers under its MELSEC series. From compact FX series PLCs suitable for small-scale applications to the powerful iQ-R series designed for complex, high-performance systems and integrated factory automation, Mitsubishi PLCs are renowned for their reliability, advanced functionality, and seamless integration capabilities.

Mitsubishi Electric’s commitment to innovation extends to its programming software, such as GX Works3, which supports all IEC 61131-3 languages and offers advanced features like simulation, diagnostics, and integrated motion control. Understanding PLC programming basics within the Mitsubishi ecosystem provides a powerful skillset, enabling engineers to leverage robust hardware and sophisticated software to drive efficiency and productivity across diverse industrial sectors.