Mitsubishi PLC Programming Tutorial: Complete Guide to FX, Q, and iQ-R Series
Master Mitsubishi PLC programming with this comprehensive tutorial covering FX, Q, iQ-R series, GX Works software, ladder logic, CC-Link networking, and automotive applications.
Mitsubishi PLC programming uses GX Works3 for the current iQ-R, iQ-F, and FX5/FX5U series, and GX Works2 for older Q, L, and FX1/FX2/FX3 series. Legacy FX and A/QnA hardware uses GX Developer, with a free GX Developer-FX edition covering older FX models. Choosing the right software is the first step — the wrong tool simply will not connect to your hardware.
Mitsubishi Electric PLCs dominate industrial automation throughout Asian markets, with over 40% market share in Japan, 30% in China, and substantial presence across Southeast Asian manufacturing facilities. The Mitsubishi PLC platform has become synonymous with reliability, performance, and innovation in automotive manufacturing, discrete production, and building automation applications worldwide. Understanding Mitsubishi PLC programming opens career opportunities in the fastest-growing manufacturing regions and provides access to one of the industry's most comprehensive automation ecosystems.
This comprehensive tutorial covers everything from fundamental Mitsubishi PLC programming concepts to advanced applications including FX series compact controllers, Q series modular PLCs, and the cutting-edge iQ-R platform. You'll master GX Works2 and GX Works3 programming environments, learn ladder logic and structured text programming, understand CC-Link industrial networking, and discover best practices from real-world automotive and manufacturing applications.
Whether you're transitioning from other PLC platforms, beginning your automation career, or expanding existing Mitsubishi expertise, this guide provides the technical depth and practical knowledge required to develop professional-grade control systems. By the end of this tutorial, you'll understand Mitsubishi's complete product portfolio, confidently program across multiple platform families, and leverage advanced features including high-speed positioning, network communication, and integrated safety systems.
Table of Contents
- Mitsubishi PLC Product Lines
- GX Works3 vs GX Works2 vs GX Developer: Which Software for Which PLC
- How to Download and Install GX Works3
- GX Works Programming Software
- Mitsubishi Device Addressing: X/Y Octal vs iQ-R Hex
- Your First Program in GX Works3
- Mitsubishi PLC Simulator: Test Without Hardware
- Ladder Logic Programming on Mitsubishi PLCs
- Structured Text and Function Blocks
- Communication and Networking
- Practical Application Example
- Best Practices
- Troubleshooting Common Issues
- Frequently Asked Questions
GX Works3 vs GX Works2 vs GX Developer: Which Software for Which PLC
The single most common stumbling block for engineers new to Mitsubishi is opening the wrong software for their hardware. GX Works3, GX Works2, and GX Developer are not interchangeable — each targets a different hardware generation and their project files are not compatible with each other.
If you are comparing Mitsubishi against other brands, see our Mitsubishi vs Allen-Bradley PLC comparison for a side-by-side look at software ecosystems and total cost.
Software-to-Series Decision Table
| PLC Series / Model | Correct Software | Notes |
|---|---|---|
| iQ-R (R04, R08, R16, R32, R120) | GX Works3 | Current flagship — GX Works3 only |
| iQ-F / FX5U / FX5 | GX Works3 | Native, recommended for all new projects |
| iQ-F / FX5U (legacy projects) | GX Works2 | Works, but GX Works3 preferred going forward |
| Q series (Q03UD, Q06UDH, etc.) | GX Works2 | Q series not supported in GX Works3 |
| L series | GX Works2 | Same generation as Q series |
| FX3U / FX3G / FX3UC | GX Works2 | Legacy compact series; widely installed |
| FX1N / FX2N | GX Works2 or GX Developer | Older models; GX Works2 covers most needs |
| Legacy FX (FX0, FX, FX2C, FX-A) | GX Developer-FX | Free download for these older FX models only |
| A series / QnA series | GX Developer | Old modular platforms; GX Developer-FX does not cover A/QnA |
Key rules to remember:
- GX Works3 = iQ-R, iQ-F, FX5/FX5U (new generation)
- GX Works2 = Q, L, FX3 and below (previous generation)
- GX Developer = only for legacy A/QnA/old FX hardware; the FX variant is available free for older FX models
- You cannot open a GX Works3 project in GX Works2 or vice versa
- Migrating from Q series to iQ-R requires a full program redesign, not a file import
FX5U nuance: The FX5U belongs to the iQ-F line and can be programmed in either GX Works2 or GX Works3. For any new FX5U project, use GX Works3 — it provides the native instruction set, better simulation, and is the supported path forward. GX Works2 support for FX5U exists primarily to support engineers already familiar with GX Works2 workflows.
Not sure which hardware you have? For a complete rundown of free and paid options across all brands, see our free PLC programming software guide.
How to Download and Install GX Works3
GX Works3 is a paid, licensed product sold through Mitsubishi Electric authorized distributors. There is no standalone free version of GX Works3 — pricing varies by edition and region. If you need to program legacy FX hardware and want a free option, GX Developer-FX (for old FX series only) is available as a free download from Mitsubishi's FA site.
Where to Get GX Works3
- Visit the Mitsubishi Electric FA Global site: www.mitsubishielectric.com/fa/worldwide and navigate to your regional FA portal (e.g., www.mitsubishielectric.co.uk/fa for EMEA, us.mitsubishielectric.com/fa for North America).
- Search for "GX Works3" under the Software section, or contact your local Mitsubishi Electric distributor directly.
- Purchase the appropriate license edition for your application (standard, advanced, or with motion extensions).
- After purchase you will receive a license key or USB dongle (hardware key) depending on the edition.
GX Works3 is paid/licensed, varies by edition. Do not rely on third-party download sites — only obtain software from official Mitsubishi channels to avoid corrupted installers or unlicensed copies.
GX Works3 System Requirements
| Requirement | Minimum | Recommended |
|---|---|---|
| OS | Windows 10 (64-bit) | Windows 11 (64-bit) |
| Processor | Intel Core i3 | Intel Core i5 or higher |
| RAM | 4 GB | 8 GB or more |
| Disk space | 8 GB free | 20 GB (for libraries and projects) |
| Display | 1024 x 768 | 1920 x 1080 |
| Ports | USB (licensing dongle) | USB + Ethernet |
Installation Steps
- Run the GX Works3 installer as administrator.
- Follow the on-screen prompts; accept the license agreement.
- Choose installation directory (default is usually fine).
- Insert the USB licensing dongle before launching, or activate via software license key if your edition uses one.
- Install the Mitsubishi USB communication drivers when prompted — these are required for USB cable connections to the PLC.
- Launch GX Works3 and verify the license is recognized under Help > About.
The Free GX Developer-FX Option
If you are working with older FX series hardware (FX0, FX1, FX2, FX2C, early FX3), GX Developer-FX is available as a free download from Mitsubishi's FA website. It covers the original FX instruction set and is suitable for maintaining legacy machines. It does not support FX3U/FX5U or any Q/iQ-R hardware.
Mitsubishi Device Addressing: X/Y Octal vs iQ-R Hex
Mitsubishi device addressing trips up engineers who come from Allen-Bradley or Siemens backgrounds. The key difference is that X (input) and Y (output) device numbers are written in octal on FX series, not decimal or hex. Understanding this before you write your first rung will save significant troubleshooting time.
For a full comparison of how Mitsubishi and Allen-Bradley handle I/O addressing and tag databases, see our Mitsubishi vs Allen-Bradley PLC comparison.
The Octal Rule for X and Y Devices
On FX series PLCs (FX3U, FX5U, iQ-F), input and output addresses are octal — meaning the digits 8 and 9 never appear in an X or Y address. After X7 comes X10 (not X8). After X17 comes X20. The sequence runs: X0, X1, X2, X3, X4, X5, X6, X7, X10, X11, X12, X13, X14, X15, X16, X17, X20 ...
Why this matters in practice: A 32-point FX5U CPU has inputs X0–X17 and outputs Y0–Y17 built in (16 inputs + 16 outputs). When you add a 16-point expansion module, the next inputs start at X20 — not X18 or X16. Engineers expecting decimal numbering will wire to what they think is input 8 (X8) and find no device exists at that address in GX Works3.
The X8/X9 skip: There are no X8 or X9 devices in FX series hardware. X7 is followed directly by X10. The same applies to Y — Y7 is followed by Y10.
FX Series Address Ranges (Octal)
| Device Type | Symbol | Numbering | Range | Notes |
|---|---|---|---|---|
| Inputs | X | Octal | X0–X377 (FX5U, octal) | Physical input terminals; 8/9 digits skipped |
| Outputs | Y | Octal | Y0–Y377 (FX5U, octal) | Physical output terminals; 8/9 digits skipped |
| Auxiliary relays | M | Decimal | M0–M7999 | Internal bits; M8000–M8511 are special (system) relays |
| Data registers | D | Decimal | D0–D7999 | 16-bit word storage; D8000–D8511 system registers |
| Timers | T | Decimal | T0–T511 | 100ms base; some high-speed variants (1ms, 10ms) |
| Counters | C | Decimal | C0–C255 | C235–C255 are high-speed hardware counters |
iQ-R Series: Larger Hex Ranges
On the iQ-R series the X/Y address range expands significantly to accommodate large I/O counts, and addresses are written in hexadecimal:
| Device Type | Symbol | Numbering | Range |
|---|---|---|---|
| Inputs | X | Hex | X0–X1FFF |
| Outputs | Y | Hex | Y0–Y1FFF |
| Auxiliary relays | M | Decimal | M0–M61439 |
| Data registers | D | Decimal | D0–D8191 (standard); much larger with extended memory |
| Timers | T | Decimal | T0–T2047 |
| Counters | C | Decimal | C0–C1023 |
The hex addressing on iQ-R means X10 in iQ-R notation is decimal 16 — not decimal 10. Engineers jumping between FX and iQ-R projects within the same day need to consciously switch mental models.
Special Relays and Registers to Know
A small set of special M and D devices are essential for any Mitsubishi program:
| Device | Function |
|---|---|
| M8000 | Always ON during RUN (use as a trigger for initialization logic) |
| M8002 | Initial pulse — ON for one scan only at program start |
| M8012 | 100 ms clock pulse |
| M8013 | 1-second clock pulse |
| M8004 | Error detection flag |
| D8000 | Watchdog timer setting |
| D8004 | Error code (read after M8004 trips) |
| D8005 | Step number where error occurred |
| D8013 | Current minute (real-time clock) |
| D8014 | Current hour (real-time clock) |
Your First Program in GX Works3
This walkthrough creates a simple motor start/stop rung on an FX5U, then simulates it without physical hardware. The same steps apply for iQ-R — only the CPU selection differs.
Step 1: Create a New Project
- Launch GX Works3.
- Select Project > New.
- In the New Project dialog:
- Series: MELSEC iQ-F (for FX5U) or MELSEC iQ-R (for R series)
- Type: FX5U-32MT/ES (choose your specific CPU model from the list)
- Language: Ladder
- Click OK. GX Works3 creates a project with a default MAIN program block.
Step 2: Write the Motor Start/Stop Rung
In the MAIN program, enter the following ladder logic. This implements a latched motor start/stop with an emergency stop contact:
// Rung 1 — Motor Start/Stop (latching)
LD X0 // Start pushbutton (NO contact)
OR Y0 // Motor running — seal-in contact
ANI X1 // Stop pushbutton (NC contact wired to terminal)
ANI X2 // Emergency stop (NC contact)
OUT Y0 // Motor contactor output
// Rung 2 — Running indicator lamp
LD Y0 // Motor output energised
OUT Y4 // Green run lamp
I/O assignment for this example:
| Address | Description | Wiring |
|---|---|---|
| X0 | Start pushbutton | NO contact to PLC input |
| X1 | Stop pushbutton | NC contact wired normally closed |
| X2 | Emergency stop | NC safety contact |
| Y0 | Motor contactor | Output to motor starter relay |
| Y4 | Green run lamp | Output to pilot light |
Add device comments in GX Works3 by right-clicking a device address and selecting "Device Comment." Comments appear directly on the ladder rung and in all monitoring views.
Step 3: Configure Device Comments and Labels
Good practice is to create Global Labels for all I/O before writing logic. In GX Works3:
- Open Global Label in the Navigation window.
- Add label entries:
StartButton→ X0 (BOOL),StopButton→ X1 (BOOL),MotorOutput→ Y0 (BOOL). - Use label names in your ladder code instead of raw addresses for readability.
Step 4: Compile and Check for Errors
Select Convert > Convert (F4). GX Works3 compiles the program and reports any syntax errors in the Output window. A clean compile shows "Compile completed."
Step 5: Launch the Built-In Simulator
See the dedicated simulator section below for the complete workflow.
Mitsubishi PLC Simulator: Test Without Hardware
GX Works3 includes a built-in software simulator (sometimes called the "MELSOFT Simulator") that runs a virtual FX5U or iQ-R CPU on your PC. You can execute your program, force I/O devices on and off, and monitor all device values without any physical PLC connected.
For an overview of how GX Works3's simulator compares to free simulators from other vendors, see our free PLC programming software guide.
Starting the Simulator
- With your project open and compiled, go to Debug > Start Simulation.
- GX Works3 launches the virtual CPU and downloads your program to it automatically.
- The CPU status indicator in the toolbar switches to RUN (green).
Interacting with the Simulated Program
Monitor mode: Click the Monitor button (or press Ctrl+F3) to see live device values overlaid on the ladder rungs. Energized contacts and coils are highlighted in blue/green.
Forcing devices: Right-click any contact or coil while in monitor mode and select Device Test. The Device Test dialog lets you:
- Set a bit device ON or OFF (X0 = ON to simulate pressing the start button)
- Write a value to a data register (D100 = 1500 to simulate a temperature reading)
- Use the "Forced Input" panel to toggle multiple inputs rapidly during sequence testing
Watching data registers: Open Debug > Watch to create a watch list of specific devices (D registers, timers, counters). Values update in real time each scan.
What the Simulator Can and Cannot Do
| Capability | Simulator |
|---|---|
| Ladder logic execution | Yes — full program execution |
| Timer and counter operation | Yes |
| Data register read/write | Yes |
| Special relay/register (M8000, D8004, etc.) | Mostly supported |
| Structured Text programs | Yes |
| Function block simulation | Yes |
| Analog I/O modules | Partial — manual value entry only |
| Physical I/O (real sensors/actuators) | No |
| High-speed counter pulse inputs | No — must use real hardware |
| Network/CC-Link communication | Limited — not full network simulation |
| Real-time clock accuracy | Approximate only |
The simulator is the right tool for validating program logic, testing state machine sequences, and catching instruction errors before you reach the shop floor. For timing-critical applications (motion control, high-speed counting) you will still need to validate on real hardware.
Stopping the Simulator
Go to Debug > Stop Simulation. GX Works3 returns to offline edit mode. Your project file is unchanged — the simulator runs a copy in memory.
Mitsubishi PLC Product Lines
Mitsubishi Electric offers comprehensive PLC families addressing applications from simple machine control through complex distributed manufacturing systems. Understanding each product line's capabilities, performance characteristics, and typical applications enables optimal platform selection for specific project requirements.
FX Series: Compact High-Performance Controllers
FX3U/FX3G Series (Legacy Compact PLCs)
The FX3U series represents Mitsubishi's mature compact PLC platform serving millions of installations worldwide. These controllers provide exceptional performance for small to medium machine control applications including packaging machinery, material handling equipment, and dedicated manufacturing cells.
FX3U controllers feature integrated digital I/O (24 to 128 points), expandable analog and specialty modules, high-speed counter inputs (up to 100 kHz), built-in positioning functions for up to 4 servo axes, and comprehensive communication options including Ethernet, CC-Link, and serial protocols. Processing speeds deliver 0.065 microseconds per basic instruction, ensuring responsive control even for demanding applications.
Price ranges for FX3U systems span $300-800 for basic CPUs and $2,000-5,000 for complete systems with expansion modules. This cost-effectiveness makes FX3U ideal for OEM machine builders requiring reliable control at competitive prices.
FX5U Series (Current Generation Compact PLCs)
The FX5U represents Mitsubishi's latest compact controller generation with dramatic performance improvements over FX3U predecessors. These advanced controllers support modular expansion, built-in Ethernet and CC-Link IE Field Basic communication, enhanced motion control capabilities with coordinated multi-axis positioning, and comprehensive security features protecting intellectual property and preventing unauthorized access.
FX5U CPUs execute basic instructions in 0.0098 microseconds—6.6 times faster than FX3U—while providing up to 512 KB program memory and extensive data memory for complex applications. The platform supports up to 384 I/O points through expansion modules, making it suitable for increasingly sophisticated machine control requirements.
Pricing for FX5U systems ranges from $500-1,200 for entry CPUs to $4,000-8,000 for fully expanded systems. The performance and feature upgrades justify the modest premium over FX3U for new projects requiring long-term supportability.
Typical FX Series Applications:
- Packaging machinery and material handling
- Food processing equipment
- Conveyor systems and sorting machines
- Small assembly automation
- Building HVAC and access control
- Water treatment and pump control
Q Series: Modular Mid-Range PLCs
Q Series Platform Overview
The Q series provides modular PLC architecture for medium to large applications requiring extensive I/O capacity, distributed control, and high reliability. The chassis-based design supports flexible system configuration with specialized modules for analog control, high-speed positioning, network communication, and process control.
Q series controllers feature removable memory cassettes enabling program backup and duplication, redundant CPU configurations for mission-critical applications, integrated safety CPU options meeting SIL3/PLe requirements, and comprehensive communication module portfolio supporting virtually all industrial protocols. Processing performance ranges from 0.034 microseconds for Q03UD to 0.0098 microseconds for Q12PRH per basic instruction.
Q Series CPU Selection:
| CPU Model | Program Memory | Processing Speed | Max I/O Points | Typical Price |
|---|---|---|---|---|
| Q03UD | 130 KB | 0.034 μs/inst | 4,096 | $1,200-1,800 |
| Q04UDHCPU | 260 KB | 0.020 μs/inst | 8,192 | $2,000-2,800 |
| Q06UDHCPU | 520 KB | 0.020 μs/inst | 8,192 | $2,800-3,800 |
| Q12DCCPU-V | 500 KB | 0.0098 μs/inst | 8,192 | $3,500-5,000 |
Q Series Applications:
- Automotive assembly lines and robotics
- Process manufacturing and batch control
- Building management systems
- Distributed manufacturing systems
- Motion control with multiple coordinated axes
iQ-R Series: High-Performance Automation Platform
iQ-R Platform Architecture
The iQ-R series represents Mitsubishi's flagship PLC platform delivering exceptional performance, advanced features, and comprehensive integration with motion control, robotics, safety systems, and industrial networking. Launched in 2013, iQ-R has rapidly gained adoption in demanding automotive, electronics, and advanced manufacturing applications requiring maximum throughput and flexibility.
iQ-R controllers feature multi-CPU architecture supporting control CPU, motion CPU, and safety CPU in unified chassis, CC-Link IE Field network providing gigabit Ethernet performance with microsecond cycle times, integrated safety functions certified to SIL3/PLe requirements, and advanced programming capabilities including structured text, function blocks, and IEC 61131-3 compliance.
Processing performance reaches 0.98 nanoseconds per basic instruction on high-end R120 CPUs—100 times faster than previous generation controllers. This performance enables sophisticated applications including vision-guided robotics, high-speed packaging, and real-time production optimization previously requiring specialized controllers.
iQ-R CPU Portfolio:
| CPU Model | Program Memory | Processing Speed | I/O Capacity | Application Focus | Price Range |
|---|---|---|---|---|---|
| R04CPU | 40 KB | 2.9 ns/inst | 2,048 points | Compact systems | $2,000-2,800 |
| R08CPU | 80 KB | 2.9 ns/inst | 4,096 points | Standard control | $2,800-3,800 |
| R16CPU | 160 KB | 2.9 ns/inst | 8,192 points | Advanced control | $3,800-5,200 |
| R32CPU | 320 KB | 1.9 ns/inst | 8,192 points | High performance | $5,200-7,000 |
| R120CPU | 1.2 MB | 0.98 ns/inst | 8,192 points | Maximum performance | $8,000-12,000 |
Motion Control Integration:
iQ-R systems integrate seamlessly with Mitsubishi's MELSERVO servo drive family and SSCNETIII/H high-speed motion networks enabling coordinated control of hundreds of servo axes with microsecond synchronization. Motion CPU modules handle complex kinematics, electronic camming, and robotic coordination while control CPUs focus on sequence control and process management.
iQ-R Applications:
- Automotive body welding and assembly
- High-speed packaging and labeling
- Electronics assembly and testing
- Robotic pick-and-place systems
- Semiconductor manufacturing equipment
iQ-F Series: All-in-One Controllers
iQ-F Platform Positioning
The iQ-F series fills the gap between compact FX5U controllers and modular iQ-R systems, providing all-in-one controller hardware with integrated I/O, built-in motion control, and extensive connectivity. This platform suits applications requiring higher performance than FX series while avoiding the complexity and cost of modular iQ-R architecture.
iQ-F controllers feature built-in Ethernet and CC-Link IE Field Basic communication, integrated motion control for up to 8 servo axes, compact form factor reducing panel space requirements, and simplified programming through GX Works3 development environment. The platform bridges the performance gap while maintaining cost-effectiveness for mid-range applications.
Typical Applications:
- Mid-size packaging machinery
- Material handling systems
- Assembly automation
- Process control equipment
- Machine tool controllers
GX Works Programming Software
Mitsubishi provides comprehensive programming environments supporting the complete PLC product portfolio through GX Works2 for FX and Q series platforms and GX Works3 for the modern iQ-R and iQ-F series controllers.
GX Works2: Programming FX and Q Series
Software Overview and Installation
GX Works2 represents the mature programming environment for FX3U, FX5U, and Q series PLCs with comprehensive features supporting ladder logic, structured text, and function block programming. The software provides integrated simulation, debugging tools, and device monitoring capabilities essential for professional automation development.
Installation Requirements:
- Windows 10 or Windows 11 (64-bit)
- Intel Core i3 or higher processor
- 4GB RAM minimum (8GB recommended)
- 10GB available disk space
- Ethernet port for PLC communication
- USB port for licensing dongle
Download GX Works2 from Mitsubishi's FA Global website (www.mitsubishielectric.com/fa/worldwide), install the software following on-screen prompts, activate licensing through USB dongle or software license, and configure communication drivers for target PLC models.
Creating a New Project in GX Works2
Launch GX Works2 and follow these steps to create your first Mitsubishi PLC project:
- Select "Project" > "New" from the main menu
- Choose PLC series (FX5U or Q series)
- Select specific CPU model from device list
- Specify project name and save location
- Configure project properties including program language and device comment format
Hardware Configuration in GX Works2
Configure PLC hardware and I/O modules through the "Connection Destination" settings:
- Open "Online" > "Connection Destination" from menu
- Select communication interface (USB, Ethernet, serial)
- Configure IP address for Ethernet connections
- Test connection to verify PLC communication
- Read PLC type to auto-configure hardware settings
For module configuration, navigate to "Parameter" > "I/O Assignment" and configure installed I/O modules, special function modules, and communication modules according to actual hardware installation.
Parameter Settings and Device Configuration
Critical parameter settings include:
PLC Parameter Settings:
- Scan mode (constant scan or minimum scan)
- Watchdog timer setting (default 200ms)
- Memory capacity allocation
- Battery alarm settings
- RUN/STOP switch settings
Network Parameters:
- IP address and subnet mask
- Device name for network identification
- Open Settings for port configuration
- Ethernet communication protocol settings
GX Works3: Programming iQ-R and iQ-F Series
Modern Development Environment
GX Works3 represents Mitsubishi's next-generation programming platform designed specifically for iQ-R and iQ-F series controllers. The software provides dramatically improved user interface, enhanced simulation capabilities, multi-CPU project support, and advanced programming features including structured text and comprehensive function block libraries.
Key Advantages of GX Works3:
- Intuitive modern interface with ribbon menu design
- Real-time online program editing during operation
- Comprehensive MELSOFT Navigator integration
- Advanced debugging with multi-variable monitoring
- Integrated motion programming for servo systems
- Cloud connectivity and remote monitoring support
Project Structure in GX Works3
GX Works3 organizes projects hierarchically supporting complex multi-CPU systems:
- System Configuration: Hardware modules, network settings, parameter configuration
- Programs: Ladder logic, structured text, function blocks organized by program blocks
- Global Labels: Shared variables accessible across program blocks
- Libraries: Reusable function blocks and programs
- Device Comments: Documentation and I/O descriptions
Enhanced Simulation Tools
GX Works3 provides sophisticated simulation capabilities enabling thorough offline testing:
Software Simulator Features:
- Complete CPU operation simulation without hardware
- I/O simulation with manual and automated input generation
- Network communication simulation
- Motion axis simulation with position feedback
- Integrated debugging with breakpoints and step execution
Configure simulation mode through "Simulation" > "Start/Stop Simulation" menu, define virtual I/O devices through simulation settings, create I/O simulation panels for interactive testing, and validate program logic before hardware deployment.
Multi-CPU Programming Support
iQ-R systems support multiple CPUs in single chassis for distributed processing. GX Works3 enables:
- Separate program development for each CPU
- Inter-CPU data sharing through device memory
- Synchronized program download to multiple CPUs
- Unified debugging across CPU modules
- Performance monitoring and optimization
Ladder Logic Programming Interface
Both GX Works2 and GX Works3 provide comprehensive ladder logic editors with features including:
Intelligent Input Assistance:
- Auto-complete for device names and instructions
- Real-time syntax checking and error detection
- Graphical instruction selection palettes
- Drag-and-drop programming elements
- Context-sensitive help and instruction documentation
Program Organization:
- Main program (MAIN) for sequential execution
- Subroutines (SUB) for modular code organization
- Interrupt programs (INT) for event-driven processing
- Function blocks (FB) for reusable logic components
- Step ladder (SFC) for sequential state machines
Debugging and Monitoring:
- Online monitoring with real-time device values
- Device batch monitoring for multiple variables
- Entry data monitoring for complex instructions
- Sampling trace for high-speed data logging
- Cross-reference for device usage analysis
Ladder Logic Programming on Mitsubishi PLCs
Mitsubishi ladder logic follows international IEC 61131-3 standards while incorporating manufacturer-specific instructions optimized for performance and ease of use. Understanding the complete instruction set enables efficient program development for diverse applications.
Mitsubishi Ladder Logic Instruction Set
Basic Contact and Coil Instructions
| Instruction | Symbol | Function | Example |
|---|---|---|---|
| LD | Normally Open Contact | Load contact, start new logic line | LD X0 |
| LDI | Normally Closed Contact | Load inverted contact | LDI X1 |
| AND | AND Contact | Serial connection | AND X2 |
| ANI | AND NOT Contact | Serial inverted connection | ANI X3 |
| OR | OR Contact | Parallel connection | OR X4 |
| ORI | OR NOT Contact | Parallel inverted connection | ORI X5 |
| OUT | Output Coil | Energize output or internal relay | OUT Y0 |
| SET/RST | Set/Reset Coil | Latch and unlatch outputs | SET M0, RST M0 |
Application Instructions
Mitsubishi PLCs provide extensive application instruction library:
Data Transfer Instructions:
- MOV - Move word data between devices
- DMOV - Move double-word (32-bit) data
- BMOV - Block move for array transfers
- FMOV - Fill move, copy value to multiple destinations
- XCH - Exchange data between two devices
Arithmetic Instructions:
- ADD/SUB - Addition and subtraction (16-bit)
- DADD/DSUB - Double-word arithmetic (32-bit)
- MUL/DIV - Multiplication and division
- DMUL/DDIV - Double-word multiplication and division
- INC/DEC - Increment and decrement values
Comparison Instructions:
- CMP - Compare two values (equal, greater, less)
- DCMP - Double-word comparison
- ZCP - Zone comparison (value within range)
- DZCP - Double-word zone comparison
Timer Instructions
Mitsubishi PLCs implement three timer types:
T (100ms Timers): General-purpose timers with 100ms resolution
LD X0 // Trigger input
OUT T0 K50 // 100ms timer, 5 second delay (50 x 100ms)
LD T0 // Timer done contact
OUT Y0 // Output energizes after 5 seconds
ST (Retentive Timers): Accumulating timers maintaining value through power cycles
LD X1
OUT ST0 K100 // Retentive timer, 10 second total accumulated time
LD ST0
OUT Y1
STMR (Millisecond Timers): High-resolution timers (1ms, 10ms, 100ms depending on model)
LD X2
OUT T200 K1500 // 1ms timer on FX5U, 1.5 second delay
LD T200
OUT Y2
Counter Instructions
Three counter types serve different applications:
C (Up Counter): General-purpose counting
LD X3
OUT C0 K100 // Count up to 100 pulses
LD C0 // Counter done contact
OUT Y3
LD X4 // Reset input
RST C0 // Reset counter
CTU (High-Speed Up Counter): Hardware-based high-speed counting
// Configuration in parameters for input X0
LD M8000 // Always ON relay
MOV K10000 D0 // Set high-speed counter preset
LD C235 // High-speed counter done
OUT Y4
CTD (Down Counter): Decremental counting applications
LD X5
DMOV K5000 D10 // Load initial count value
LD X6
CTD D10 // Count down
LD X7
OUT Y5
Device Addressing System
For the detailed explanation of octal X/Y addressing and the FX vs iQ-R differences, see the dedicated Mitsubishi Device Addressing section earlier in this guide. The quick-reference summary is below.
Input Devices (X): Physical input terminals. Octal on FX/iQ-F (X0–X7, X10–X17 ... X8 and X9 do not exist). Hex on iQ-R (X0–X1FFF).
Output Devices (Y): Physical output terminals. Same octal/hex convention as X devices.
Internal Relays (M):
- M0–M7999: General purpose auxiliary bits (decimal)
- M8000–M8511: Special relays (system flags — read-only or write by program)
- Latched relays retain state through power cycles
Data Registers (D):
- D0–D7999: General purpose 16-bit registers (decimal)
- D8000–D8511: Special registers (system data, error codes, clock values)
- Access as words (D0) or double-words (D0+D1 combined as a 32-bit value)
Timers (T): Decimal numbering. T0–T199 = 100 ms resolution; T200+ = 10 ms or 1 ms on FX5U depending on parameter settings.
Counters (C): Decimal numbering. C0–C199 = up counters (16-bit); C200–C234 = 32-bit up/down counters; C235–C255 = high-speed hardware counters.
Special Registers Quick Reference:
- M8000: RUN monitor (always ON during operation)
- M8002: Initial pulse (ON for one scan at startup)
- M8012: 100 ms clock pulse
- M8013: 1-second clock pulse
- D8013: Current minute value
- D8014: Current hour value
Complete Programming Example: Automated Assembly Line Control
Application Requirements:
- Conveyor belt with start/stop control
- Product detection sensor at station
- Assembly operation with timed sequence
- Automatic part ejection after assembly
- Emergency stop and safety interlocks
- Production counter and status indication
I/O Assignment:
Inputs:
X0 - Start button
X1 - Stop button
X2 - Emergency stop (NC contact)
X3 - Product detect sensor
X4 - Assembly complete sensor
X5 - Eject position sensor
Outputs:
Y0 - Conveyor motor
Y1 - Assembly actuator
Y2 - Eject cylinder
Y3 - Green status light (running)
Y4 - Red status light (stopped)
Y5 - Alarm buzzer
Internal Relays:
M0 - System running
M1 - Assembly sequence active
M2 - Emergency stop triggered
Timers:
T0 - Assembly operation timer (5 seconds)
T1 - Eject pulse timer (2 seconds)
Counters:
C0 - Production counter
Data Registers:
D0 - Production count storage
Ladder Logic Program:
// Emergency Stop and Safety Logic
LD X2 // Emergency stop NC contact
ANI M2 // Not already in E-stop state
OUT M2 // Set E-stop flag
LD M2 // E-stop active
OUT Y5 // Alarm buzzer
SET M3 // Latch alarm condition
// Start/Stop Control
LD X0 // Start button
ANI X1 // Stop button not pressed
ANI M2 // No emergency stop
SET M0 // System running
LD X1 // Stop button
OR M2 // Or emergency stop
RST M0 // Reset system running
// Conveyor Control
LD M0 // System running
ANI M1 // Not in assembly sequence
OUT Y0 // Conveyor motor running
// Status Indication
LD M0
OUT Y3 // Green light when running
LDI M0
OUT Y4 // Red light when stopped
// Product Detection and Assembly Sequence
LD X3 // Product detected
ANI M1 // Not already assembling
LD M0 // System running
SET M1 // Start assembly sequence
LD M1 // Assembly sequence active
OUT Y0 // Stop conveyor (inverse logic)
OUT Y1 // Activate assembly actuator
OUT T0 K50 // 5-second assembly timer
// Assembly Complete
LD T0 // Timer done
LD X4 // Assembly verified complete
RST M1 // End assembly sequence
SET M4 // Trigger eject sequence
// Part Ejection
LD M4 // Eject sequence triggered
OUT Y2 // Eject cylinder extend
OUT T1 K20 // 2-second eject pulse
LD T1 // Eject complete
RST M4 // Reset eject flag
OUT C0 K1 // Increment production counter
// Production Counter Display
LD M8000 // Always ON
MOV C0 D0 // Move counter to display register
// E-Stop Reset
LD X0 // Start button
LD X1 // AND Stop button (both pressed)
RST M2 // Reset E-stop
RST M3 // Reset alarm latch
Program Features:
- Complete safety interlock system
- Timed assembly sequence control
- Automatic production counting
- Status indication for operators
- Emergency stop with reset procedure
- Modular program structure for easy modification
Structured Text and Function Blocks
Modern Mitsubishi PLCs support structured programming languages enabling complex algorithms, mathematical processing, and modular code development beyond traditional ladder logic capabilities.
Structured Text Programming in GX Works3
ST Language Overview
Structured Text (ST) provides high-level text-based programming similar to Pascal or C languages, enabling efficient implementation of complex control algorithms, mathematical calculations, and data processing that would be cumbersome in ladder logic format.
Basic ST Syntax:
// Variable declarations
VAR
TempSetpoint : INT := 750; // Temperature setpoint (0.1°C)
TempActual : INT; // Current temperature
HeaterOutput : BOOL := FALSE; // Heater control
AlarmHigh : BOOL := FALSE; // High temperature alarm
END_VAR
// Control logic
IF TempActual < TempSetpoint THEN
HeaterOutput := TRUE;
ELSIF TempActual > (TempSetpoint + 50) THEN // 5°C hysteresis
HeaterOutput := FALSE;
END_IF;
// Alarm checking
IF TempActual > 850 THEN // 85°C alarm threshold
AlarmHigh := TRUE;
ELSE
AlarmHigh := FALSE;
END_IF;
ST Advantages for Specific Applications:
- Complex mathematical formulas expressed naturally
- Array and loop processing simplified
- Recipe management and data handling
- String manipulation for communications
- Algorithm development and testing
Creating Function Blocks for Reusable Code
Function Block Concept
Function blocks encapsulate control logic with defined inputs, outputs, and internal variables, creating reusable components that simplify program development and maintenance. Well-designed function blocks enable library development for standardized control functions used across multiple projects.
Example: Temperature Control Function Block
// Function Block Definition: FB_TempController
FUNCTION_BLOCK FB_TempController
VAR_INPUT
Enable : BOOL; // Enable temperature control
Setpoint : INT; // Temperature setpoint
ProcessValue : INT; // Current temperature reading
Kp : REAL := 1.0; // Proportional gain
Ki : REAL := 0.1; // Integral gain
Kd : REAL := 0.05; // Derivative gain
END_VAR
VAR_OUTPUT
ControlOutput : INT; // Control output (0-10000 = 0-100%)
AlarmHigh : BOOL; // High temperature alarm
AlarmLow : BOOL; // Low temperature alarm
END_VAR
VAR
Error : INT; // Current error
LastError : INT; // Previous error
Integral : REAL; // Integral accumulator
Derivative : REAL; // Derivative term
OutputRaw : REAL; // Raw output before limiting
END_VAR
// PID Control Algorithm
IF Enable THEN
// Calculate error
Error := Setpoint - ProcessValue;
// Proportional term
OutputRaw := REAL(Error) * Kp;
// Integral term with anti-windup
IF (ControlOutput > 0) AND (ControlOutput < 10000) THEN
Integral := Integral + (REAL(Error) * Ki);
OutputRaw := OutputRaw + Integral;
END_IF;
// Derivative term
Derivative := REAL(Error - LastError) * Kd;
OutputRaw := OutputRaw + Derivative;
// Output limiting (0-100%)
IF OutputRaw < 0.0 THEN
ControlOutput := 0;
ELSIF OutputRaw > 10000.0 THEN
ControlOutput := 10000;
ELSE
ControlOutput := REAL_TO_INT(OutputRaw);
END_IF;
// Store error for next cycle
LastError := Error;
// Alarm checking
IF ProcessValue > (Setpoint + 100) THEN
AlarmHigh := TRUE;
ELSE
AlarmHigh := FALSE;
END_IF;
IF ProcessValue < (Setpoint - 100) THEN
AlarmLow := TRUE;
ELSE
AlarmLow := FALSE;
END_IF;
ELSE
// Disabled state
ControlOutput := 0;
Integral := 0.0;
LastError := 0;
AlarmHigh := FALSE;
AlarmLow := FALSE;
END_IF;
END_FUNCTION_BLOCK
Using Function Blocks in Programs:
// Declare function block instances
VAR
ReactorTemp : FB_TempController;
OvenTemp : FB_TempController;
END_VAR
// Call function blocks with parameters
ReactorTemp(
Enable := SystemRunning,
Setpoint := 750,
ProcessValue := TempSensor1,
Kp := 1.2,
Ki := 0.15,
Kd := 0.08
);
OvenTemp(
Enable := SystemRunning,
Setpoint := 1200,
ProcessValue := TempSensor2,
Kp := 1.5,
Ki := 0.2,
Kd := 0.1
);
// Use function block outputs
HeaterReactor := ReactorTemp.ControlOutput > 5000;
HeaterOven := OvenTemp.ControlOutput > 5000;
AlarmAny := ReactorTemp.AlarmHigh OR OvenTemp.AlarmHigh;
Data Structures and User-Defined Types
Creating Structured Data Types:
// Recipe data structure
TYPE Recipe
STRUCT
RecipeName : STRING[20];
Temperature : INT;
Pressure : INT;
MixTime : INT;
CureTime : INT;
IngredientA : REAL;
IngredientB : REAL;
IngredientC : REAL;
END_STRUCT;
END_TYPE
// Array of recipes
VAR
Recipes : ARRAY[1..10] OF Recipe;
ActiveRecipe : INT := 1;
END_VAR
// Access recipe data
Setpoint := Recipes[ActiveRecipe].Temperature;
MixTimer := Recipes[ActiveRecipe].MixTime;
Communication and Networking
Mitsubishi PLCs provide comprehensive networking capabilities supporting distributed control, device integration, and enterprise connectivity through proprietary and open industrial protocols.
CC-Link for Distributed I/O
CC-Link Protocol Overview
CC-Link (Control & Communication Link) protocol represents Mitsubishi's primary industrial network standard with dominant market share throughout Asian markets. The protocol family includes classic CC-Link fieldbus, CC-Link IE Field for high-performance Ethernet applications, and CC-Link IE TSN incorporating time-sensitive networking standards.
Classic CC-Link Configuration:
- Install CC-Link master module in PLC (QJ61BT11N for Q series, built-in for iQ-R)
- Configure network parameters including speed, station count, and data allocation
- Add remote I/O modules and intelligent devices to network
- Assign device station numbers (1-64)
- Configure cyclic data exchange for each station
- Test communication and verify device status
Network Parameters:
- Communication speed: 156 kbps to 10 Mbps
- Maximum distance: 1,200m @ 156 kbps, 100m @ 10 Mbps
- Topology: Line/branch configuration
- Stations: Up to 64 devices per network
- Refresh time: 0.88ms to several hundred milliseconds
CC-Link IE Field for High-Speed Networks
CC-Link IE Field Advantages
CC-Link IE Field provides gigabit Ethernet performance with deterministic cycle times down to 31.25 microseconds, enabling demanding motion control and real-time coordination applications. The protocol supports standard Ethernet infrastructure while maintaining industrial-grade reliability and diagnostics.
Configuration in GX Works3:
- Add CC-Link IE Field network to system configuration
- Configure master station (iQ-R CPU or dedicated master module)
- Add slave devices from device library
- Assign IP addresses to all network devices
- Configure cyclic data areas for each slave
- Set network scan timing and QoS parameters
- Download configuration and monitor network status
Performance Capabilities:
- Speed: 1 Gbps Ethernet
- Cycle time: 31.25 μs to several milliseconds
- Stations: Up to 254 devices
- Data capacity: 64,512 bytes cyclic data
- Topology: Star/ring with managed switches
- Redundancy: Automatic failover support
EtherNet/IP Support
Mitsubishi iQ-R series supports EtherNet/IP enabling integration with Allen-Bradley, Omron, and other multi-vendor networks. This capability facilitates brownfield installations, mixed-vendor systems, and customer specification compliance.
EtherNet/IP Configuration:
- Install RJ71EN71 EtherNet/IP module (Q series) or use built-in port (iQ-R)
- Configure adapter/scanner relationships
- Define tag-based data exchange
- Set up I/O assembly objects
- Configure explicit messaging for non-cyclic data
Modbus TCP/RTU Integration
Modbus Communication Setup
Mitsubishi PLCs implement Modbus TCP and Modbus RTU protocols enabling integration with thousands of third-party devices including drives, instruments, and legacy equipment.
Modbus TCP Configuration:
// Program example using FX5U built-in Ethernet
// Open Modbus TCP connection
MODOPEN 1, 0, 192.168.1.100, 502, K0
// Read holding registers from slave device
MODRD 1, K3, K100, D100, K10, K0
// Connection 1, Function 3, Address 100, Store D100, Count 10
// Write holding registers to slave device
MODWR 1, K16, K200, D200, K5, K0
// Connection 1, Function 16, Address 200, Source D200, Count 5
// Close connection when complete
MODCLOSE 1
Industrial IoT and Cloud Connectivity
MQTT Protocol Support
Modern Mitsubishi PLCs support MQTT enabling cloud connectivity, data analytics, and Industry 4.0 applications without intermediate gateways.
MQTT Configuration Example:
// Connect to MQTT broker
MQTT_CONNECT
"broker.hivemq.com", // Broker address
1883, // Port number
"MitsubishiPLC1", // Client ID
K60, // Keep alive (seconds)
D0 // Status code
// Publish production data to cloud
MQTT_PUBLISH
"factory/line1/count", // Topic
D100, // Data register
K1, // QoS level
D1 // Status
Practical Application Example
Multi-Station Production Line with CC-Link IE
This comprehensive example demonstrates integrated system design using iQ-R series PLC, CC-Link IE Field network, servo positioning, HMI integration, and data logging for automotive component assembly.
System Architecture:
Hardware Components:
- iQ-R CPU: R08CPU (main controller)
- Motion CPU: RD77MS16 (16-axis servo control)
- CC-Link IE Field Master: Built-in CPU Ethernet port
- Remote I/O: RJ71GF11-T2 stations (4 stations)
- Servo Drives: MR-J5 series (8 axes)
- HMI: GOT2000 series GT2512 touchscreen
- Vision System: Cognex In-Sight camera (CC-Link IE)
Station Breakdown:
- Loading Station: Part feeding and orientation verification
- Assembly Station 1: Component insertion with force monitoring
- Assembly Station 2: Fastening and torque verification
- Inspection Station: Vision-based quality inspection
- Unloading Station: Part removal and sorting
Program Architecture:
// Main Program Structure
PROGRAM Main
VAR
SystemState : INT := 0; // 0=Stop, 1=Auto, 2=Manual
CurrentStation : INT := 1; // Active station
PartPresent : ARRAY[1..5] OF BOOL;
StationReady : ARRAY[1..5] OF BOOL;
END_VAR
// Station sequence control
CASE SystemState OF
0: // Stop state
AllStationsStop();
1: // Automatic operation
LoadingStationControl();
AssemblyStation1Control();
AssemblyStation2Control();
InspectionStationControl();
UnloadingStationControl();
2: // Manual operation
ManualModeControl();
END_CASE;
// Production data logging
ProductionDataLog();
HMI_Communication();
END_PROGRAM
// Loading Station Function Block
FUNCTION_BLOCK FB_LoadingStation
VAR_INPUT
Enable : BOOL;
PartRequest : BOOL;
END_VAR
VAR_OUTPUT
PartReady : BOOL;
LoadComplete : BOOL;
StationFault : BOOL;
END_VAR
VAR
Step : INT := 0;
FeederTimer : TON;
VerifyTimer : TON;
END_VAR
// Station state machine
CASE Step OF
0: // Wait for part request
IF Enable AND PartRequest THEN
Step := 10;
END_IF;
10: // Activate feeder
FeederActuate := TRUE;
FeederTimer(IN := TRUE, PT := T#2s);
IF FeederTimer.Q THEN
Step := 20;
FeederTimer(IN := FALSE);
END_IF;
20: // Verify part presence
VerifyTimer(IN := TRUE, PT := T#500ms);
IF PartSensor AND VerifyTimer.Q THEN
PartReady := TRUE;
LoadComplete := TRUE;
Step := 30;
ELSIF VerifyTimer.Q THEN
StationFault := TRUE;
Step := 0;
END_IF;
30: // Wait for part pickup
IF NOT PartSensor THEN
PartReady := FALSE;
LoadComplete := FALSE;
Step := 0;
END_IF;
END_CASE;
END_FUNCTION_BLOCK
// Motion control for transfer
PROGRAM MotionControl
VAR
PickPosition : LREAL := 150.0; // mm
PlacePosition : LREAL := 450.0; // mm
TransferVelocity : LREAL := 500.0; // mm/s
Axis1 : FB_Axis; // Servo axis instance
END_VAR
// Configure servo axis
Axis1.Enable := SystemRunning;
Axis1.Acknowledge := AcknowledgeButton;
// Position commands
IF LoadComplete AND NOT TransferBusy THEN
// Move to pick position
MC_MoveAbsolute(
Axis := Axis1,
Execute := TRUE,
Position := PickPosition,
Velocity := TransferVelocity,
Acceleration := 2000.0,
Deceleration := 2000.0
);
END_IF;
// Track motion status and handle errors
IF Axis1.InPosition THEN
GripperClose := TRUE; // Activate gripper
END_IF;
IF Axis1.Error THEN
AlarmMotionFault := TRUE;
LogError(Axis1.ErrorID, "Transfer axis fault");
END_IF;
END_PROGRAM
// HMI data exchange via GOT interface
PROGRAM HMI_Communication
VAR
ProductionCount : DINT;
CycleTime : TIME;
QualityRate : REAL;
AlarmActive : BOOL;
END_VAR
// Update HMI display data
ProductionCount := TotalPartsProduced;
CycleTime := StationCycleTimer.ET;
QualityRate := REAL(GoodParts) / REAL(TotalParts) * 100.0;
// Recipe selection from HMI
IF HMI_RecipeSelect <> ActiveRecipe THEN
LoadRecipe(HMI_RecipeSelect);
ActiveRecipe := HMI_RecipeSelect;
END_IF;
// Alarm acknowledgment
IF HMI_AckButton THEN
ResetAllAlarms();
END_IF;
END_PROGRAM
Key Features Demonstrated:
- Multi-station coordinated control
- Servo motion integration with positioning
- Vision system integration via CC-Link IE
- HMI data exchange and operator interface
- Production data logging and quality tracking
- Modular program structure with function blocks
- Comprehensive error handling and diagnostics
Best Practices
Professional Mitsubishi PLC programming requires disciplined approach to program organization, documentation, testing, and maintenance ensuring long-term system reliability and supportability.
Program Organization and Structure
Modular Programming Approach
Organize programs into logical functional modules:
- Main Program: High-level sequence control and mode management
- Station Programs: Individual station control logic as subroutines or FBs
- Safety Program: Emergency stop, interlocks, and safety functions
- Communication Program: Network messaging and data exchange
- Diagnostics Program: System monitoring and error logging
Use Subroutines Effectively:
// Main program calls subroutines for organization
CALL StationControl // Station sequence control
CALL SafetyMonitoring // Safety system checking
CALL DataLogging // Production data logging
CALL HMI_Update // Operator interface update
Function Block Libraries
Develop Standardized Function Blocks:
Create company-standard function blocks for common operations:
- Motor control with overload protection
- Valve control with position feedback
- Temperature control with PID
- Product tracking and traceability
- Recipe management and storage
- Alarm handling and notification
Library Management:
- Store function blocks in GX Works libraries
- Version control for block updates
- Comprehensive block documentation
- Standardized naming conventions
- Testing and validation procedures
Naming Conventions and Comments
Device Naming Standards:
// Physical I/O descriptive naming
X0 : StartButton_Station1
X1 : StopButton_Station1
X2 : EStopButton_NC
X3 : SafetyGate1_Closed
Y0 : ConveyorMotor_Station1
Y1 : ClampCylinder_Extend
// Internal relay functional naming
M0 : SystemRunning
M1 : AutoMode
M2 : ManualMode
M10 : Station1_Active
M11 : Station1_Complete
M100 : AlarmMajor
M101 : AlarmMinor
// Data register naming
D0 : ProductionCounter
D10 : CycleTimeMs
D20 : RecipeNumber_Active
D100 : TemperatureSetpoint
D101 : TemperatureActual
Comment Standards:
// Network comment at start of each program section
// ===================================
// STATION 1 - LOADING AND VERIFICATION
// Function: Part feeding and orientation check
// Inputs: X0-X7 (sensors, buttons)
// Outputs: Y0-Y3 (feeder, clamp)
// Author: Engineering Team
// Date: 2025-12-10
// ===================================
// Inline comments for complex logic
LD X10 // Part present sensor
AND T0 // Settle timer complete
ANI M20 // Not already processing
SET M21 // Start verification sequence
// Document special register usage
MOV K100 D8201 // Set high-speed counter mode
// Mode 100 = bi-directional counter with reset
Documentation Standards
Comprehensive System Documentation:
- I/O List: Complete input/output assignments with descriptions
- Network Diagram: Communication architecture and device addresses
- Functional Specification: Detailed operation sequence description
- Device Comments: Inline documentation for all devices
- Program Structure: Flowcharts and sequence diagrams
- Parameter Settings: PLC parameters and special configurations
- Revision History: Change log with dates and descriptions
Export Documentation from GX Works:
- Device comment export to CSV/Excel
- Program printouts with comments
- Hardware configuration reports
- Network topology diagrams
- Parameter documentation
Backup and Version Control
Regular Backup Procedures:
- Project Backup: Complete GX Works project files (.gxw)
- PLC Upload: Periodic PLC program uploads to archive
- Parameter Backup: Save all PLC parameters separately
- Documentation Backup: Archive all related documentation
- Offsite Storage: Maintain backups in separate location
Version Control System:
- Use file version numbering (Project_v1.0, Project_v1.1)
- Maintain change logs documenting modifications
- Archive previous versions before making changes
- Test new versions thoroughly before deployment
- Document validation and approval process
Using Simulation for Testing
GX Works3 Simulation Workflow:
- Develop program logic offline
- Create I/O simulation scenarios
- Test normal operating sequences
- Verify error handling and recovery
- Validate safety interlocks
- Performance timing verification
- Document test results and issues
- Refine program based on simulation
Simulation Best Practices:
- Create comprehensive test scenarios
- Include fault conditions and recovery
- Validate all program branches execute
- Test boundary conditions and edge cases
- Verify timer and counter operation
- Check data handling and calculations
Troubleshooting Common Issues
Understanding common Mitsubishi PLC problems and solutions accelerates commissioning and minimizes downtime during system operation.
Connection Problems with GX Works
Issue: Cannot Connect to PLC
Troubleshooting Steps:
- Verify physical connection (USB cable, Ethernet cable)
- Check PLC power and RUN/STOP mode
- Confirm IP address settings match PLC configuration
- Disable Windows firewall or add GX Works exception
- Verify USB driver installation for USB connections
- Test Ethernet connectivity with ping command
- Check PLC network parameter settings
- Try different communication interface (USB vs Ethernet)
Common Solutions:
- USB Connection: Install Mitsubishi USB driver from FA website
- Ethernet Connection: Set PC IP in same subnet as PLC (e.g., PLC: 192.168.3.250, PC: 192.168.3.100)
- Firewall: Add GX Works2/3 to Windows Firewall allowed programs
- Multiple NICs: Disable unused network adapters that may cause routing conflicts
PLC Error Codes and Diagnostics
Reading the CPU LED Indicators
Every Mitsubishi CPU has front-panel LEDs that provide the fastest first diagnosis. LED meanings vary slightly between families, but the general pattern is consistent:
| LED | Normal State | Fault Indication |
|---|---|---|
| RUN (green) | Solid ON in RUN mode | OFF = CPU in STOP or hardware fault |
| ERROR (red) | OFF | Solid ON = major error (CPU halted); Flashing = minor/continuing error |
| BAT (yellow/red) | OFF | ON = battery voltage low; replace battery soon to protect latched data |
| USER / READY | Solid ON (iQ-R) | Depends on CPU model and program |
On iQ-F (FX5U) CPUs, check the ERR LED: solid red indicates a fatal stop error; flashing red indicates a non-fatal error or parameter mismatch that allows continued RUN.
For FX5U battery and USB cable setup, see our Mitsubishi USB SC-09 cable setup guide for connection troubleshooting that overlaps with LED diagnosis steps.
Common Error Codes:
| Error Code | Description | Common Causes | Solutions |
|---|---|---|---|
| 6101 | CPU Module Error | Hardware failure, overheating | Check ventilation, replace CPU if persists |
| 6201 | I/O Bus Error | Communication with I/O modules lost | Check I/O connections, module power, replace faulty module |
| 6310 | Program Error | Syntax error or illegal instruction | Upload program, check diagnostics, correct errors |
| 6600 | Watchdog Timer Error | Scan time exceeds watchdog setting | Optimize program, increase watchdog timer, check for infinite loops |
| 7000 | External Device Error | Communication error with special modules | Verify module installation, check parameters, test module |
Error codes differ between FX (4-digit starting with 6xxx/7xxx) and iQ-R (four-digit hex). Always read the error code from GX Works diagnostics, not just from the LED state.
Using GX Works3 Event/Error History
GX Works3 provides a full event history log that captures every error, warning, and status change with a timestamp. This is significantly more useful than reading raw D register values.
To access it:
- Connect to the PLC online (or use the simulator).
- Go to Diagnostics > System Monitor in GX Works3.
- Click the Error History tab to see timestamped error events.
- Click any entry to see the error code, error details, and the step number where the program was executing when the error occurred.
- Use the CPU Diagnostics view for module-level status on iQ-R systems with multiple CPU or I/O modules.
Reading Error Information via Special Registers:
// Monitor special registers for diagnostics (FX series)
M8004 : Error detected flag (ON when error present)
D8004 : Error code (read this to identify fault type)
D8005 : Step number where error occurred
M8006 : Battery voltage low warning
M8007 : Battery voltage too low (data loss risk)
For legacy FX3U programs, the D8004 / M8004 pattern is the primary diagnostic path. On iQ-R, use the GX Works3 System Monitor instead — it provides richer diagnostic data including network and motion errors that special registers do not cover.
FX3U-specific error history: For older FX3U and FX2N machines still in the field, consult our Mitsubishi FX2N legacy programming guide which covers error codes and diagnostic procedures specific to those platforms.
CC-Link Network Issues
Network Communication Failures
Symptoms:
- Remote stations offline
- Intermittent communication errors
- Data not updating from slaves
Troubleshooting Procedure:
- Check LED indicators on master and slave modules
- Verify cable continuity and shield grounding
- Confirm termination resistors installed correctly
- Check communication speed matches all devices
- Verify station numbers are unique
- Monitor network error counters
- Test with reduced station count
Common Fixes:
- Replace damaged or low-quality cables
- Ensure single-point shield grounding
- Verify termination only at network ends
- Match baud rate on all devices
- Check for electromagnetic interference sources
- Reduce communication speed if errors persist
Parameter Mismatch Errors
Issue: Parameter Mismatch After Download
Cause: Downloaded program parameters don't match PLC hardware configuration
Resolution:
- Upload current PLC program and parameters
- Compare with project parameters in GX Works
- Identify mismatched modules or settings
- Correct hardware configuration in project
- Download complete project including parameters
- Perform PLC reset if required
- Verify operation after download
Prevention:
- Always upload before making changes
- Maintain accurate project documentation
- Use parameter compare function in GX Works
- Document all hardware changes
Upload/Download Problems
Failed Program Download
Common Issues:
- PLC in RUN mode (some operations require STOP)
- Write protection enabled on PLC
- Insufficient PLC memory capacity
- USB/Ethernet connection interrupted
Solutions:
// Check PLC mode
1. Verify PLC is in STOP mode for complete download
2. Use "Remote Operation" to change PLC to STOP from GX Works
3. Disable write protection in PLC parameters
// Memory issues
1. Check program size vs available memory
2. Clear unused program areas
3. Optimize program to reduce size
4. Consider CPU upgrade if consistently over capacity
Frequently Asked Questions
What is the difference between GX Works2 and GX Works3?
GX Works2 and GX Works3 are distinct programming platforms for different Mitsubishi PLC generations. Their project files are incompatible — you cannot open a GX Works3 project in GX Works2 or vice versa.
GX Works2:
- Programs Q series, L series, FX3U/FX3G/FX3UC, FX2N, FX1N, and also FX5U (legacy support)
- Mature software with broad hardware coverage
- Traditional menu-driven interface
- Simulation available but less advanced than GX Works3
GX Works3:
- Programs iQ-R, iQ-F, FX5/FX5U — this is the native, recommended tool for these platforms
- Modern ribbon-menu interface
- Built-in virtual PLC simulator with step execution and forced I/O
- Multi-CPU project support (control CPU + motion CPU in one project)
- Enhanced structured text and function block programming
- Active development with ongoing updates
FX5U: Can be programmed in either GX Works2 or GX Works3. For new FX5U projects, use GX Works3 — it provides the full FX5U instruction set and is the supported path for new development. GX Works2 support for FX5U exists for engineers already working in that environment.
Migration Considerations: GX Works2 projects cannot be directly imported to GX Works3. Migrating from Q series to iQ-R requires a full program redesign and hardware retesting, not a file conversion.
Which Should You Use?
- GX Works2: Existing Q series, L series, FX3 and older FX installations
- GX Works3: All new projects on iQ-R, iQ-F, or FX5U hardware
Which Mitsubishi PLC is best for beginners?
The FX5U series represents the optimal starting point for Mitsubishi PLC beginners due to affordable hardware, comprehensive capabilities, and modern programming environment.
FX5U Advantages for Learning:
- Compact all-in-one hardware reduces complexity
- Built-in Ethernet and CC-Link IE Field Basic
- Full GX Works2 and GX Works3 compatibility
- Extensive online tutorials and documentation
- Lower hardware cost ($500-1,200 for starter kits)
- Direct upgrade path to iQ-R for advanced applications
Learning Resources:
- Mitsubishi FA Academy training courses
- GX Works2 tutorial projects included with software
- Online video tutorials on YouTube
- Mitsubishi technical support and forums
- Third-party training providers
Recommended Starter Kit:
- FX5U-32MT/ES CPU (32 I/O points)
- Programming cable (USB-SC09-FX)
- GX Works2 software
- Basic I/O devices for testing (sensors, lights, buttons)
Alternative for Budget Constraints: FX3U series offers even lower cost ($300-600) with slightly reduced performance but full learning capability for fundamental PLC programming concepts.
What programming languages do Mitsubishi PLCs support?
Mitsubishi PLCs support all five IEC 61131-3 standard programming languages plus manufacturer-specific extensions:
Standard IEC 61131-3 Languages:
- Ladder Diagram (LD/LAD): Most common, relay-logic based graphical programming
- Function Block Diagram (FBD): Graphical programming with reusable blocks
- Structured Text (ST): High-level text-based programming
- Instruction List (IL/STL): Low-level assembly-like programming
- Sequential Function Chart (SFC): State-based sequential programming
Platform Language Support:
| Platform | LAD | FBD | ST | IL | SFC |
|---|---|---|---|---|---|
| FX3U | Yes | Limited | No | Yes | Yes |
| FX5U | Yes | Yes | Yes | Yes | Yes |
| Q Series | Yes | Yes | Limited | Yes | Yes |
| iQ-R Series | Yes | Yes | Yes | Yes | Yes |
Most Widely Used: Ladder Logic dominates Mitsubishi programming with approximately 80% of applications due to electrical familiarity and visual debugging advantages. Structured Text adoption is growing for complex calculations and algorithm implementation in iQ-R systems.
What is the difference between FX and iQ-R series?
FX and iQ-R series serve different application scales with distinct performance characteristics, capabilities, and cost structures.
FX Series (Compact Controllers):
- All-in-one compact hardware
- 16-384 I/O points capacity
- 0.0098 μs per instruction (FX5U)
- Fixed configuration with limited expansion
- $500-5,000 typical system cost
- Small machine and OEM applications
- Single-CPU architecture
- Basic motion control (4-8 axes)
iQ-R Series (High-Performance Modular):
- Modular chassis-based architecture
- Up to 8,192 I/O points per CPU
- 0.98 ns per instruction (R120CPU)
- Extensive module options and scalability
- $5,000-50,000+ typical system cost
- Large-scale distributed control
- Multi-CPU support (control, motion, safety)
- Advanced motion control (hundreds of axes)
Performance Comparison:
- Processing speed: iQ-R is 10-100x faster
- I/O capacity: iQ-R supports 20x more I/O
- Network performance: iQ-R supports CC-Link IE TSN
- Motion control: iQ-R offers advanced kinematics
- Price: iQ-R costs 3-10x more for similar I/O count
Application Guidelines:
- Choose FX Series: Small machines, OEM equipment, building systems, simple processes
- Choose iQ-R Series: Automotive assembly, complex production lines, high-speed motion, multi-zone coordination
Is GX Works software free?
GX Works3 and GX Works2 are paid, licensed products — neither has a free full version. Pricing varies by edition and region; contact your local Mitsubishi Electric authorized distributor for current pricing. Licenses come as a USB dongle (hardware key) or a software activation key depending on the edition.
GX Works3: Paid/licensed, varies by edition. Purchased through Mitsubishi authorized distributors. Covers iQ-R, iQ-F, and FX5/FX5U series.
GX Works2: Paid/licensed, varies by edition. Covers Q, L, and FX series (including FX5U in legacy mode). Still widely deployed across existing installations.
Licensing types typically available:
- Single-user (node-locked) license
- Floating/network license for engineering teams
- Educational licenses for qualifying institutions (contact Mitsubishi FA Academy for details)
- Annual software maintenance agreements that cover version updates and technical support
The only genuinely free Mitsubishi tool:
GX Developer-FX is available as a free download from Mitsubishi's FA website and covers programming for older FX series hardware (FX0, FX1, FX2, FX2C, early FX3 variants). It does not support FX3U, FX5U, Q series, or iQ-R/iQ-F. If you are maintaining legacy FX machinery and want zero cost, this is the legitimate free path.
For a complete comparison of free and paid PLC programming software across all major brands, see our free PLC programming software guide.
How do I connect to a Mitsubishi PLC?
Connecting to Mitsubishi PLCs requires appropriate interface hardware and proper software configuration through GX Works. For detailed cable pinouts, driver installation steps, and common USB recognition issues, see our Mitsubishi USB SC-09 cable setup guide.
USB Connection (Simplest Method):
-
Required Hardware:
- USB programming cable (USB-SC09-FX for FX series, USB-QC30R2 for Q/iQ-R)
- USB drivers installed (included with GX Works software)
-
Connection Procedure:
- Power ON the PLC
- Connect USB cable between PC and PLC programming port
- Windows will detect and install USB driver automatically
- Launch GX Works2 or GX Works3
- Select "Online" > "Connection Destination"
- Choose "USB" as connection type
- Click "Communication Test" to verify
- Click "OK" to establish connection
Ethernet Connection (Most Common for iQ-R):
-
Network Setup:
- Configure PLC IP address in PLC parameters (e.g., 192.168.3.250)
- Set PC IP in same subnet (e.g., 192.168.3.100, subnet 255.255.255.0)
- Connect Ethernet cable between PC and PLC Ethernet port
- Verify connection with ping test in Command Prompt
-
GX Works Configuration:
- Open "Online" > "Connection Destination"
- Select "Ethernet" as connection type
- Enter PLC IP address
- Select "MELSOFT" connection type
- Click "Communication Test"
- Troubleshoot if test fails (firewall, IP address, cable)
Serial Connection (Legacy Systems):
- RS-232C cable (SC-09 for FX, QC30R2 for Q series)
- Configure COM port, baud rate (9600 typical), data bits (7 or 8)
- Less common for modern installations
Network Discovery (iQ-R with GX Works3):
- Use "Auto-Detect" function to scan network for PLCs
- Discovers all Mitsubishi PLCs on subnet automatically
- Simplifies configuration for new installations
What is CC-Link protocol?
CC-Link (Control & Communication Link) is Mitsubishi Electric's open industrial network protocol enabling communication between PLCs, I/O, drives, sensors, and other automation devices with deterministic performance and extensive device support.
CC-Link Protocol Family:
Classic CC-Link (Fieldbus):
- RS-485 physical layer
- 156 kbps to 10 Mbps communication speed
- Up to 64 stations per network
- 1,200m maximum distance @ 156 kbps
- Mature technology with massive installed base
CC-Link IE Field Basic:
- 100 Mbps Ethernet connectivity
- Standard RJ45 connectors and Cat5e cable
- Lower cost migration to Ethernet
- Up to 64 stations
- Simplified network configuration
CC-Link IE Field:
- 1 Gbps high-performance Ethernet
- 31.25 μs minimum cycle time
- Up to 254 stations
- 64,512 bytes cyclic data capacity
- Motion control and real-time applications
CC-Link IE TSN:
- Time-Sensitive Networking integration
- IT/OT network convergence
- Deterministic with concurrent IT traffic
- Industry 4.0 ready architecture
Key Advantages:
- Dominant in Asian markets (30% market share in China)
- Open specification with multi-vendor support
- Comprehensive device profiles and certification
- Excellent diagnostics and troubleshooting
- Seamless Mitsubishi PLC integration
Learn More: For comprehensive CC-Link implementation guidance, see our complete CC-Link protocol tutorial covering network configuration, wiring, programming, and troubleshooting.
Can Mitsubishi PLCs communicate with other brands?
Yes, Mitsubishi PLCs support multiple open industrial protocols enabling integration with Allen-Bradley, Siemens, Schneider Electric, and thousands of third-party devices.
Supported Industrial Protocols:
EtherNet/IP:
- Native support on iQ-R series
- Integration with Rockwell Automation (Allen-Bradley)
- CIP (Common Industrial Protocol) compatibility
- Scanner and adapter modes
Modbus TCP/IP:
- Built-in on FX5U, Q series, iQ-R
- Most widely supported industrial protocol
- Easy integration with instruments and drives
- Master and slave functionality
Modbus RTU (Serial):
- Serial RS-232/RS-485 communication
- Legacy device integration
- Widely supported across manufacturers
PROFINET:
- Available through gateway modules
- Integration with Siemens systems
- IO-Device and IO-Controller modes
OPC UA:
- Modern Industry 4.0 protocol
- Secure data exchange with IT systems
- Cloud and edge computing connectivity
Multi-Vendor Integration Examples:
// Modbus TCP to read Allen-Bradley drive parameters
MODRD 1, K3, K1000, D100, K10, K0
// Connection 1, Function 3, Address 1000, Destination D100, Count 10
// EtherNet/IP explicit messaging to Rockwell PLC
EIPRD "192.168.1.50", "TagName", D200, K5
// Read 5 words from AB PLC tag into D200-D204
Integration Considerations:
- Data type conversion may be required
- Communication cycle times vary by protocol
- Configuration complexity depends on protocol
- Test thoroughly with actual devices
- Consult device manufacturer documentation
Recommended Approach: For critical multi-vendor integration, consider protocol gateway devices providing robust translation, extensive diagnostics, and simplified configuration between dissimilar systems.
What industries use Mitsubishi PLCs?
Mitsubishi PLCs serve diverse industries worldwide with particularly strong presence in automotive manufacturing, electronics production, and Asian markets.
Automotive Manufacturing (40% of Mitsubishi PLC applications):
- Body welding and assembly lines
- Paint system automation
- Powertrain manufacturing
- Final assembly and testing
- Material handling and logistics
Japanese and Asian automotive manufacturers including Toyota, Honda, Nissan, Hyundai, and their supply chains extensively deploy Mitsubishi automation. European and North American automotive facilities increasingly adopt Mitsubishi for new lines.
Electronics and Semiconductor (25%):
- Circuit board assembly
- Component insertion and soldering
- Testing and inspection systems
- Clean room automation
- Wafer handling and processing
Precision, speed, and reliability requirements of electronics manufacturing align perfectly with Mitsubishi PLC capabilities and Japanese engineering excellence.
Packaging and Material Handling (15%):
- High-speed packaging machinery
- Conveyor systems and sorting
- Palletizing and depalletizing
- Warehouse automation
- Distribution center controls
FX5U series dominates OEM packaging machinery due to compact size, integrated motion control, and competitive pricing.
Building Automation (10%):
- HVAC control systems
- Lighting and access control
- Elevator and escalator controls
- Energy management systems
- Security integration
Reliability and long product lifecycle make Mitsubishi ideal for building systems requiring 20+ year operational life.
Food and Beverage (5%):
- Processing automation
- Bottling and canning lines
- Quality inspection systems
- Recipe management
- Batch control
Process Industries (5%):
- Water and wastewater treatment
- Chemical processing
- Pharmaceutical manufacturing
- Batch reactors
- Utilities
Regional Distribution:
- Asia Pacific: 60% of Mitsubishi PLC installations
- Europe: 20%
- Americas: 15%
- Other regions: 5%
How do I get started with Mitsubishi PLC programming?
Starting Mitsubishi PLC programming requires structured learning approach combining theoretical knowledge with hands-on practice.
Step 1: Acquire Hardware and Software (Weeks 1-2)
Minimum Starter Equipment:
- FX5U starter kit with 32 I/O points ($800-1,200)
- USB programming cable ($50-100)
- GX Works2 software trial or license ($0-3,500)
- Basic I/O devices: switches, sensors, pilot lights ($50-150)
- Total investment: $900-5,000 depending on software licensing
Alternative Budget Option:
- Use GX Works2 simulation mode for initial learning ($0)
- Purchase used FX3U hardware ($200-400)
- Progress to new hardware after mastering fundamentals
Step 2: Fundamental Training (Weeks 3-6)
Recommended Learning Path:
-
Week 3-4: Software Familiarization
- Install GX Works2 and explore interface
- Create first project and configure virtual PLC
- Learn ladder logic editor basics
- Practice with tutorial examples included with software
-
Week 5-6: Basic Programming Concepts
- Study basic instructions (LD, AND, OR, OUT)
- Learn timer and counter programming
- Practice with simple traffic light example
- Implement basic motor control sequences
Free Learning Resources:
- Mitsubishi FA Academy online courses
- YouTube tutorials for Mitsubishi PLC programming
- Mitsubishi technical manuals (download from FA website)
- Online forums and user communities
Step 3: Hands-On Practice Projects (Weeks 7-12)
Beginner Projects:
- Traffic Light Controller: Timers and sequential control
- Conveyor Belt Control: Start/stop with safety interlocks
- Tank Level Control: Analog input processing and pump control
- Sorting System: Sensors, counters, and conditional logic
Intermediate Projects: 5. Temperature Control: PID algorithm implementation 6. Multi-Station Production Line: Coordinated sequence control 7. HMI Integration: GOT touchscreen programming 8. Network Communication: CC-Link or Modbus implementation
Step 4: Formal Training (Optional but Recommended)
Mitsubishi FA Academy Courses:
- "FX5 Basic Programming" (3 days, $1,500-2,000)
- "iQ-R Advanced Programming" (5 days, $2,500-3,500)
- Hands-on training with expert instructors
- Certification upon completion
Third-Party Training Options:
- Local technical colleges and trade schools
- Online platforms (Udemy, Coursera, LinkedIn Learning)
- Industrial automation training companies
- In-house corporate training programs
Step 5: Practical Experience (Ongoing)
Career Development Paths:
- Entry-level controls technician positions
- OEM machine builder programming roles
- System integrator project engineering
- Plant maintenance and support positions
- Independent consulting after gaining experience
Skill Development Timeline:
- Basic competency: 3-4 months with regular practice
- Professional proficiency: 12-18 months with project experience
- Advanced expertise: 3-5 years with diverse applications
- Master level: 7-10+ years with multiple platforms
Success Tips:
- Practice regularly, even 30 minutes daily builds skills
- Join online communities for support and advice
- Study existing programs to learn patterns
- Document your learning and projects
- Don't hesitate to experiment and make mistakes
- Focus on understanding WHY programs work, not just copying code
Ready to Master Mitsubishi PLC Programming?
Mitsubishi Electric's comprehensive PLC portfolio provides solutions for applications from simple machine control through complex automotive assembly lines. Understanding FX series compact controllers, Q series modular platforms, and advanced iQ-R systems positions you for success in the world's fastest-growing manufacturing regions.
Key Takeaways:
- Platform Selection: FX5U for learning and small machines, iQ-R for advanced applications
- Software Proficiency: Master both GX Works2 and GX Works3 environments
- Programming Languages: Ladder logic foundation plus structured text for complex applications
- Networking: Understand CC-Link protocol family for distributed control
- Best Practices: Follow structured programming, comprehensive documentation, thorough testing
Next Steps:
- Download GX Works2 trial and explore simulation capabilities
- Review example programs and study programming patterns
- Consider FX5U starter kit for hands-on learning
- Explore formal training through Mitsubishi FA Academy
- Join Mitsubishi PLC user communities and forums
Continue Your Learning:
For deeper expertise in related automation technologies, explore these comprehensive guides:
- Siemens vs Allen-Bradley PLC Comparison - Compare Mitsubishi against global competitors
- CC-Link Protocol Tutorial - Master Mitsubishi's industrial networking
- Ladder Logic Programming Mastery - Advanced ladder logic techniques
- PLC Programming Best Practices - Professional development standards
- TIA Portal Programming Tutorial - Learn Siemens platform for comparison
Mitsubishi PLC programming skills open career opportunities throughout Asia, automotive manufacturing worldwide, and OEM machine building industries. The combination of exceptional hardware performance, comprehensive software tools, and robust industrial networking positions Mitsubishi as a strategic platform for both current applications and future Industry 4.0 evolution.
Start your Mitsubishi PLC programming journey today and join the global community of automation professionals leveraging these powerful, reliable control systems to drive manufacturing excellence in 2026 and beyond.
