how to write repeating logic in gx works

Lussy04

2 min read

·

24-01-2025

1

0

Share

GX Works2, the programming software for Mitsubishi PLCs, offers several ways to handle repetitive logic efficiently. Avoiding redundant code improves readability, reduces programming errors, and makes maintenance easier. This article explores different methods for writing repeating logic in GX Works2, focusing on ladder diagrams.

Understanding Repeating Logic

Before diving into specific methods, let's define what we mean by "repeating logic." This refers to sections of code that perform the same or very similar operations multiple times. Examples include:

• Controlling multiple identical machines or processes: Each machine might require the same sequence of operations (start, run, stop, etc.).
• Managing multiple sensors or actuators: Each sensor might trigger the same response (e.g., activating an alarm).
• Iterating through an array of data: Performing calculations or comparisons on each element of an array.

Methods for Handling Repeating Logic in GX Works2

GX Works2 doesn't have built-in looping structures like "for" or "while" loops found in high-level programming languages. However, several techniques effectively manage repeating logic:

1. Using Subroutines (Function Blocks)

Subroutines (or function blocks) are the most powerful and recommended approach for handling repeating logic. They encapsulate a block of code that can be called multiple times from different parts of your program.

Advantages:

• Modularity: Keeps your main program clean and organized.
• Reusability: The same subroutine can be used multiple times.
• Maintainability: Changes only need to be made in one place.

Example: Imagine controlling four identical pumps. Instead of writing the same start/stop logic four times, create a subroutine that takes the pump number as an input. Then, call this subroutine four times, each time passing a different pump number.

How to create a Subroutine in GX Works2:

1. In your GX Works2 project, go to "Program".
2. Select "Add New Function Block"
3. Define your inputs and outputs, this might be things like "Pump Number" and "Pump Status".
4. Write your logic within this block.
5. Call the Subroutine using the appropriate "CALL" instruction in the main program.

2. Using Jump Instructions (JMP and JME)**

Jump instructions (JMP for jump and JME for jump end) provide a less structured way to handle repetitions. While functional, they can make the program harder to read and debug if overused. This is generally not the preferred method.

Advantages:

• Simple to implement for very short sequences that need to repeat.

Disadvantages:

• Reduces readability and maintainability compared to subroutines.
• Can lead to "spaghetti code" if not used carefully. Difficult to trace the flow of the program.

3. Utilizing Data Tables and Addressing Modes

For repetitive logic involving arrays or data tables, using indirect addressing can be efficient. This allows you to process each element of the array using a single piece of logic. The address is updated on each loop.

Advantages:

• Concise and efficient for array-based operations.

Disadvantages:

• Requires a good understanding of indirect addressing and data structures. Can be more complex to debug.

Choosing the Right Method

The best method depends on the complexity and nature of your repeating logic:

• Subroutines (Function Blocks): The preferred method for most scenarios due to their modularity, reusability, and maintainability.
• Jump Instructions (JMP/JME): Only suitable for small, simple repetitions where readability is not a major concern.
• Data Tables and Indirect Addressing: Best for handling repetitive operations on arrays or data tables.

Remember to always prioritize clear, well-structured code. Well-commented code is essential for maintainability and future debugging. Using the appropriate method for repeating logic in GX Works2 contributes to a more robust and efficient PLC program.