GE PLC Programming Tutorial: Complete Guide to PACSystems and Proficy Machine Edition

Expert GE PACSystems Programming Guide | Written by power generation and process automation specialists with extensive experience programming GE PLCs for mission-critical applications in power plants, oil & gas facilities, and water treatment systems. All examples validated on operational PACSystems installations.

GE PACSystems (now Emerson Automation Solutions following the 2023 acquisition) represents one of the most powerful and reliable PLC platforms in industrial automation, with particular dominance in power generation, oil and gas production, water/wastewater treatment, and mission-critical process control applications. Understanding GE PLC programming with Proficy Machine Edition software opens opportunities in industries where reliability, performance, and system redundancy are non-negotiable requirements.

This comprehensive GE PLC programming tutorial guides you through the complete PACSystems platform, from fundamental concepts through advanced programming techniques covering RX3i modular PACs, RX7i redundant systems, and VersaMax compact controllers. You'll learn Proficy Machine Edition software navigation, IEC 61131-3 programming language implementation, Ethernet Global Data communication, practical application development for power and process industries, and the redundancy features that distinguish GE PACSystems from competitive platforms.

GE's automation heritage traces back to GE Fanuc Automation's decades of innovation in factory and process automation, establishing PACSystems as the platform of choice for applications demanding maximum uptime, deterministic performance, and hot standby redundancy. The modern PACSystems platform combines this proven reliability with contemporary capabilities including industrial Ethernet communication, OPC UA connectivity, cybersecurity features, and comprehensive protocol support—making GE PLC programming skills invaluable across traditional infrastructure and emerging smart infrastructure applications.

Whether you're migrating from legacy GE Series 90 systems, expanding your multi-vendor automation expertise, or beginning your career in power and process automation, this tutorial provides the practical knowledge needed to successfully program GE PACSystems controllers for real-world industrial applications demanding maximum reliability and performance.

Table of Contents

1. GE PACSystems Product Lines Overview
2. Proficy Machine Edition Software
3. Ladder Logic Programming
4. Structured Text Programming
5. Function Block Diagram Programming
6. Communication and Networking
7. Practical Application: Water Treatment Plant
8. RX7i Redundancy and Hot Standby
9. Best Practices for GE PACSystems
10. Troubleshooting Common Issues
11. Frequently Asked Questions

GE PACSystems Product Lines Overview

GE (now Emerson) offers comprehensive PAC (Programmable Automation Controller) families serving applications from simple machine control through complex distributed redundant systems, each optimized for specific performance requirements and reliability levels demanded by power, process, and infrastructure industries.

RX3i: Modular PAC Platform

High-Performance Modular Controllers:

The RX3i family provides GE's primary modular PAC platform with extensive I/O capabilities, comprehensive communication options, and performance suitable for complex process control, power generation auxiliary systems, and distributed infrastructure applications.

Key RX3i CPU Models:

• IC695CPE305: Entry-level PAC with 20 MHz processor, 10 MB memory, suitable for small to medium applications
• IC695CPE310: Standard PAC with 1.1 GHz processor, 64 MB memory, excellent price/performance for general applications
• IC695CPE330: High-performance PAC with 1.4 GHz dual-core processor, 128 MB memory, advanced motion and process control
• IC695CPE400: Premium PAC with 2.0 GHz quad-core processor, 512 MB memory, maximum performance for complex distributed systems

RX3i System Specifications:

| Feature | CPE305 | CPE310 | CPE330 | CPE400 | |---------|--------|--------|--------|--------| | Processor | 20 MHz | 1.1 GHz | 1.4 GHz Dual | 2.0 GHz Quad | | Memory | 10 MB | 64 MB | 128 MB | 512 MB | | Scan Time | 0.17 ms/K | 0.06 ms/K | 0.04 ms/K | 0.02 ms/K | | Max I/O | 8,192 points | 32,000 points | 32,000 points | 32,000 points | | Ethernet Ports | 1 | 2 | 2 | 2 | | Redundancy | No | No | No | No | | Typical Price | $1,500-2,000 | $2,500-3,500 | $4,000-5,500 | $7,000-9,000 |

RX3i Application Areas:

• Power Generation: Balance of plant control, auxiliary systems, distributed generation
• Oil & Gas: Wellhead automation, pipeline control, tank farm management, safety systems
• Water/Wastewater: Treatment plant automation, distribution control, pump station management
• Manufacturing: Process control, batch systems, material handling, packaging lines
• Building Infrastructure: HVAC control, lighting management, energy monitoring, security integration

Physical Characteristics:

RX3i uses modular backplane architecture with universal backplanes supporting CPUs, I/O modules, and specialty modules. Systems accommodate 1, 3, 5, 7, or 10-slot backplanes expandable via RX3i expansion cables up to 32 total modules. The system supports both local and remote I/O configurations using Profinet, EtherNet/IP, or Genius I/O protocols.

RX7i: Redundant High-Performance Systems

Mission-Critical Redundant Platform:

The RX7i family delivers maximum performance with CPU and communication redundancy for critical applications demanding continuous availability in power generation, refining, petrochemical processing, and critical infrastructure where downtime is unacceptable.

RX7i Redundancy Features:

• Dual Redundant CPUs: Hot standby CPU configuration with automatic failover
• Bumpless Transfer: Process control continues uninterrupted during CPU switchover
• Redundant Communication: Dual Ethernet interfaces with automatic failover
• Redundant Power: Dual power supplies with load sharing
• Redundant I/O: Support for redundant input/output modules
• Synchronization: Continuous memory and I/O state synchronization between CPUs

Key RX7i CPU Models:

• IC697CPX928: Standard redundant CPU with 128 MB memory, 0.025 ms/K scan time
• IC697CPX935: High-performance redundant CPU with 256 MB memory, 0.02 ms/K scan time

RX7i System Specifications:

| Feature | CPX928 | CPX935 | |---------|--------|--------| | Processor | 1.8 GHz Dual Core | 2.1 GHz Dual Core | | Memory | 128 MB | 256 MB | | Scan Time | 0.025 ms/K | 0.02 ms/K | | Max I/O | 32,000 points | 32,000 points | | Redundancy | Full CPU/Comm | Full CPU/Comm | | MTBF | 10+ years | 10+ years | | Typical Price | $18,000-22,000 | $24,000-28,000 |

Critical Applications for RX7i:

• Power Plants: Turbine control, boiler management, emissions monitoring, critical auxiliary systems
• Refineries: Distillation control, cracking units, safety instrumented systems, critical process loops
• Pipeline Control: Compressor stations, pump stations, custody transfer, leak detection
• Water Treatment: Critical treatment processes, high-service pumping, regulatory compliance systems
• Data Centers: HVAC control, power distribution, environmental monitoring, security systems

VersaMax: Compact PLC Systems

Cost-Effective Compact Controllers:

The VersaMax family provides compact PLC solutions for smaller applications, OEM machines, remote stations, and distributed control points where RX3i capability exceeds requirements.

VersaMax Features:

• Integrated I/O: Fixed I/O configurations reduce wiring and footprint
• Modular Expansion: Add I/O modules as needed for application growth
• Multiple Communications: Serial, Ethernet, Genius I/O options
• Harsh Environment: IP67 ratings available for demanding conditions
• Cost-Effective: Lower price point for simpler applications

Typical VersaMax Applications:

• OEM packaging equipment and specialized machines
• Remote pump and compressor stations
• Building automation and HVAC control
• Small water treatment facilities
• Distributed control points in larger systems

Product Line Selection Guide

Choose RX3i When:

• Application requires 1,000+ I/O points
• Complex process control or batch sequencing needed
• Multiple communication protocols required
• Advanced motion control necessary
• Budget allows $2,500-9,000 CPU investment

Choose RX7i When:

• Downtime is unacceptable (power, refining, critical infrastructure)
• Safety integrity level SIL 2/3 required
• Process cannot tolerate control interruptions
• Regulatory requirements mandate redundancy
• Budget supports $18,000-28,000 redundant CPU investment

Choose VersaMax When:

• Application requires less than 500 I/O points
• Remote or distributed control point
• Cost-sensitive OEM machine application
• Simple logic without complex algorithms
• Budget limited to under $2,000

Proficy Machine Edition Software

Proficy Machine Edition (PME) serves as GE's comprehensive programming environment for all PACSystems controllers, providing unified development for RX3i, RX7i, and VersaMax platforms with support for all five IEC 61131-3 programming languages.

Installation and Licensing

Software Installation Process:

1. System Requirements Check:

   • Windows 10 (64-bit) or Windows 11 Professional
   • Intel Core i5 processor minimum (i7 recommended)
   • 8 GB RAM minimum (16 GB recommended)
   • 10 GB available disk space
   • Graphics card supporting DirectX 11
   • Network adapter for PLC communication

2. Download and Installation:

   • Obtain Proficy Machine Edition from Emerson website or authorized distributor
   • Run installer with administrative privileges
   • Select installation components (programming environment, emulator, documentation)
   • Configure installation directory and shortcuts
   • Complete installation and restart computer

Licensing Types:

• Development License: Full programming, simulation, and online debugging capabilities
• View License: Read-only access to view and document existing programs
• OEM License: Customized licensing for machine builders and system integrators
• Runtime License: Required for PACSystems controllers (included with CPU)

License Activation:

Proficy Machine Edition uses FlexNet licensing supporting node-locked, floating network, or USB dongle activation. License files (.lic) are processed through the License Manager utility accessible from Windows Start Menu.

Project Creation and Organization

Creating New PACSystems Project:

1. Launch Proficy Machine Edition
2. Select "File" → "New" → "Project"
3. Choose target controller (RX3i, RX7i, or VersaMax)
4. Select specific CPU model from catalog (e.g., IC695CPE310)
5. Configure project name and storage location
6. Set default programming language
7. Initialize project structure

Project Organization Structure:

Project Root
├── Hardware Configuration
│   ├── CPU Configuration
│   ├── I/O Module Configuration
│   ├── Network Configuration
│   └── Device Addresses
├── Program Organization Units (POUs)
│   ├── Main Program (_MAIN)
│   ├── Functions (FUN)
│   ├── Function Blocks (FB)
│   └── Programs (PRG)
├── Variables
│   ├── Global Variables
│   ├── I/O Variables (%I, %Q)
│   └── Memory Variables (%M, %R)
├── Data Types
│   ├── Structures
│   ├── Enumerations
│   └── Arrays
└── Documentation
    ├── Variable Comments
    ├── Ladder Rung Comments
    └── Function Block Descriptions

Hardware Configuration Tool

Configuring RX3i Hardware:

1. CPU Configuration:

   • Select CPU model from module catalog
   • Configure Ethernet IP addresses (Port 1, Port 2)
   • Set scan rate and watchdog timer
   • Enable/disable features (Web server, SNMP, time sync)
   • Configure security settings

2. I/O Module Addition:

   • Drag modules from catalog to backplane
   • Configure module parameters (voltage range, filter time, alarms)
   • Assign reference addresses (%I, %Q addresses)
   • Set module diagnostics and fault handling
   • Configure special module features

3. Network Configuration:

   • Configure Ethernet Global Data (EGD) exchanges
   • Set up Modbus TCP/RTU communication
   • Configure PROFINET IO devices
   • Configure EtherNet/IP adapters
   • Establish OPC UA server connections

Hardware Configuration Example (Water Treatment Station):

Slot 0: IC695CPE310 CPU
  - IP Address: 192.168.1.100
  - Subnet Mask: 255.255.255.0
  - Gateway: 192.168.1.1
  - Scan Rate: 10 ms

Slot 1: IC695MDL740 - 32-point 24VDC Input Module
  - Reference: %I00001 - %I00032
  - Filter Time: 3 ms
  - Diagnostics: Enabled

Slot 2: IC695MDL940 - 32-point 24VDC Output Module
  - Reference: %Q00001 - %Q00032
  - Fault Mode: Hold last state
  - Diagnostics: Enabled

Slot 3: IC695ALG600 - 8-channel Analog Input
  - Reference: %AI00001 - %AI00008
  - Input Type: 4-20mA
  - Scaling: 0-32767 counts
  - Diagnostics: Enabled

Programming Interface Overview

Proficy Machine Edition Programming Workspace:

The PME interface provides integrated access to all programming tools, hardware configuration, online debugging, and documentation features through tabbed workspace organization.

Key Interface Components:

1. Navigator Pane: Project tree showing hardware, programs, variables, data types
2. Editor Pane: Active programming editor (ladder, FBD, ST, IL, SFC)
3. Variable Table: Quick access to I/O, memory, and global variables
4. Output Window: Compiler messages, search results, reference information
5. Reference Data Window: Cross-reference, unused variables, program statistics
6. Toolbar: Quick access to common operations (compile, download, online mode)

Programming Language Selection:

Each Program Organization Unit (POU) can use different programming languages selected independently, allowing optimal language choice for each control function:

• Ladder Diagram (LD): Boolean logic, interlocks, sequential control
• Function Block Diagram (FBD): Process control, analog calculations, PID loops
• Structured Text (ST): Complex algorithms, mathematical calculations, data manipulation
• Instruction List (IL): Low-level programming, optimization, legacy code
• Sequential Function Chart (SFC): Batch processes, state machines, sequential operations

Emulator for Testing

PACSystems RX3i Emulator:

Proficy Machine Edition includes integrated emulator capability enabling program testing without physical hardware, accelerating development and reducing commissioning time.

Emulator Features:

• Full CPU instruction set emulation
• I/O forcing and simulation
• Communication protocol testing
• HMI integration testing
• Program debugging and single-stepping
• Variable monitoring and trending

Using the Emulator:

1. Create project with target CPU configuration
2. Develop program logic and variable declarations
3. Select "Target" → "Set PLC Mode" → "Run Emulator"
4. Download program to emulator instance
5. Force I/O variables to simulate field conditions
6. Monitor program execution and verify logic
7. Debug and refine program before hardware deployment

Emulator Limitations:

• Does not simulate exact scan timing
• Cannot test hardware-specific features
• Communication protocols operate in loopback mode
• Performance differs from actual CPU
• Advanced features may not fully emulate

Ladder Logic Programming

GE PACSystems ladder logic programming follows IEC 61131-3 standards with GE-specific instruction extensions providing powerful control capabilities for process automation, power systems, and infrastructure applications.

Basic Ladder Logic Instructions

Contact and Coil Instructions:

|--[ ]-----|  Normal Open Contact (%I, %M, %T, %G)
|--[/]-----|  Normal Closed Contact
|--( )-----|  Normal Coil (%Q, %M, %G)
|--( / )---|  Negated Coil
|--( S )---|  Set Coil (remains ON until reset)
|--( R )---|  Reset Coil (turns OFF)

Boolean Instructions:

AND:  Series contacts (both must be TRUE)
OR:   Parallel contacts (either can be TRUE)
XOR:  Exclusive OR (exactly one TRUE)
NOT:  Negation (inverts state)

Example: Basic Start/Stop Circuit with Indicator:

|                                                                  |
|  Start_PB     Stop_PB      Run_Status          Run_Relay        |
|----] [----------]/[-----------] [----------------( )------------|
|                              |                                   |
|                              |                                   |
|  Run_Relay                   |                                   |
|----] [----------------------|                                   |
|                                                                  |
|  Run_Relay                                     Run_Indicator    |
|----] [----------------------------------------------( )---------|
|                                                                  |

Variable Declarations:
%I00001  Start_PB       "Start Pushbutton"
%I00002  Stop_PB        "Stop Pushbutton"
%M00001  Run_Status     "Internal Run Status"
%Q00001  Run_Relay      "Run Relay Output"
%Q00002  Run_Indicator  "Run Indicator Light"

Timer Instructions

GE PACSystems provides comprehensive timer instructions compatible with both millisecond and 10-millisecond time bases depending on CPU configuration.

TON - On-Delay Timer:

Turns ON after preset time delay expires while enable input remains TRUE.

    Enable                              TON_Instance
  ----] [----------------------------------|TON     |
                                      PT--|        |--Q---- TimerDone
                                          | Timer  |
                                          |________|--ET--- ElapsedTime

Parameters:
- Enable (BOOL): Timer enable input
- PT (TIME): Preset time value
- Q (BOOL): Timer done output (ON when ET >= PT)
- ET (TIME): Current elapsed time

TOFF - Off-Delay Timer:

Turns OFF after preset time delay expires after enable input goes FALSE.

    Enable                             TOFF_Instance
  ----] [----------------------------------|TOFF    |
                                      PT--|        |--Q---- TimerDone
                                          | Timer  |
                                          |________|--ET--- ElapsedTime

TRTG - Retentive Timer:

Accumulates time across multiple enable periods, continues counting where it left off.

    Enable                             TRTG_Instance
  ----] [----------------------------------|TRTG    |
    Reset                             PT--|        |--Q---- TimerDone
  ----] [----------------------------------|        |
                                          |________|--ET--- ElapsedTime

Practical Timer Example - Pump Delay Start:

|                                                                  |
|  Pump_Start     Pump_Running                    Delay_Timer     |
|----] [-------------]/[---------------------------|TON     |      |
|                                             PT-T#5s|      |      |
|                                                   |______|      |
|                                                        |Q        |
|  Delay_Timer.Q                                   Pump_Starter   |
|----] [-------------------------------------------( )------------|
|                                                                  |

Application: 5-second delay before starting pump motor to allow
valve positioning or pressure stabilization. Prevents mechanical
stress and extends equipment life in water treatment applications.

Counter Instructions

CTU - Count Up Counter:

Increments count value on rising edge of count input until preset value reached.

    Count_Input                        CTU_Instance
  ----] [----------------------------------|CTU     |
    Reset                              PV--|        |--Q---- CountDone
  ----] [----------------------------------|        |
                                          |________|--CV--- CurrentValue

CTD - Count Down Counter:

Decrements count value on rising edge of count input until zero reached.

    Count_Input                        CTD_Instance
  ----] [----------------------------------|CTD     |
    Load                               PV--|        |--Q---- CountZero
  ----] [----------------------------------|        |
                                          |________|--CV--- CurrentValue

Practical Counter Example - Production Counting:

|                                                                  |
|  Part_Sensor     Counter_Reset               Production_Counter |
|----] P [-------------] [----------------------|CTU     |         |
|                                          PV-1000|      |         |
|  Counter_Reset                                 |______|         |
|----] [----------------------------------------|                 |
|                                                    |Q            |
|                                                                  |
|  Production_Counter.Q                         Batch_Complete    |
|----] [-----------------------------------------( )--------------|
|                                                                  |
|  Production_Counter.Q                                           |
|----] [------------------------------------------(R)-------------|
|                                                Production_Counter|
|                                                                  |

Application: Counts parts in packaging application, signals batch
completion at 1,000 parts, automatically resets for next batch.
Used in food processing, pharmaceutical, and manufacturing lines.

Memory Organization and Addressing

GE PACSystems Memory Structure:

%I - Physical Input References
%Q - Physical Output References
%M - Internal Memory (Boolean)
%T - Temporary Memory (Boolean, scan-based)
%S - System Status Bits
%AI - Analog Input References
%AQ - Analog Output References
%R - Register Memory (16-bit integers)
%W - Word Memory (16-bit)
%L - Long Memory (32-bit)
%G - Global Memory (networked between controllers)

Reference Addressing Examples:

%I00001        Discrete input point 1
%I00015        Discrete input point 15
%Q00032        Discrete output point 32
%M00001        Internal memory bit 1
%AI00001       Analog input channel 1 (16-bit value)
%AQ00005       Analog output channel 5 (16-bit value)
%R00100        Register memory word 100
%G00001        Global memory bit 1 (EGD exchange)

Data Type Support:

• BOOL: Single bit (TRUE/FALSE)
• INT: 16-bit signed integer (-32,768 to 32,767)
• DINT: 32-bit signed integer (-2,147,483,648 to 2,147,483,647)
• REAL: 32-bit floating point
• STRING: Character strings
• ARRAY: Multiple elements of same type
• STRUCTURE: User-defined complex data types

Complete Ladder Logic Example - Pump Alternation Control

|═════════════════════════════════════════════════════════════════|
|  Pump Alternation System - Water Treatment Application          |
|  Alternates lead pump each cycle to equalize runtime            |
|═════════════════════════════════════════════════════════════════|
|                                                                  |
|  Auto_Mode    Tank_Low_Level    Pump1_Fault     Pump1_Enable   |
|----] [------------] [---------------]/[------------( )----------|
|                                                                  |
|  Pump1_Enable   Lead_Select                                     |
|----] [-----------] [-------------------------------------       |
|                                                         |        |
|  Pump1_Enable   Lead_Select                            |        |
|----] [----------]/[-------------------------------------|        |
|                                                                  |
|  Pump1_Enable   Start_Delay                         Pump1_Run   |
|----] [------------] [---------------------------------( )-------|
|                                                                  |
|  Auto_Mode    Tank_Low_Level    Pump2_Fault     Pump2_Enable   |
|----] [------------] [---------------]/[------------( )----------|
|                                                                  |
|  Pump2_Enable   Lead_Select                                     |
|----] [----------]/[-------------------------------------        |
|                                                         |        |
|  Pump2_Enable   Lead_Select                            |        |
|----] [-----------] [-------------------------------------|       |
|                                                                  |
|  Pump2_Enable   Start_Delay                         Pump2_Run   |
|----] [------------] [---------------------------------( )-------|
|                                                                  |
|  Pump1_Run    Pump2_Run                                         |
|----] [----------] [------------------------(R)------------------|
|                                         Tank_Low_Level           |
|                                                                  |
|  Pump1_Run                                                      |
|----]/[------------------------------------------------          |
|                 |                                     |          |
|  Pump2_Run      |                                    |          |
|----]/[----------|                                    |          |
|                                                      |          |
|  Pump1_Run      Pump2_Run                           |          |
|----] [------------] [--------------------------------|          |
|                                                                  |
|  Lead_Select                                     Lead_Toggle    |
|----]/[-------------------------------------------------( )-----|
|                                                                  |
|  Lead_Toggle                                                    |
|----] P [-------------------------------------------(S)----------|
|                                                Lead_Select       |
|                                                                  |
|  Lead_Select    Alternate_Delay                                |
|----] [------------] [-----------------------------|TON    |     |
|                                              PT-T#10s|    |     |
|                                                     |_____|     |
|                                                          |Q     |
|  Alternate_Delay.Q                                              |
|----] [------------------------------------------------(R)------|
|                                               Lead_Select        |
|                                                                  |

Variable Declarations:
%I00001  Auto_Mode         "Automatic mode selector"
%I00002  Tank_Low_Level    "Tank low level float switch"
%I00003  Pump1_Fault       "Pump 1 fault status"
%I00004  Pump2_Fault       "Pump 2 fault status"

%M00001  Pump1_Enable      "Pump 1 enable logic"
%M00002  Pump2_Enable      "Pump 2 enable logic"
%M00003  Lead_Select       "Lead pump selector (0=Pump1, 1=Pump2)"
%M00004  Start_Delay       "Startup delay complete"
%M00005  Lead_Toggle       "Toggle lead pump trigger"

%Q00001  Pump1_Run         "Pump 1 starter output"
%Q00002  Pump2_Run         "Pump 2 starter output"

Application: Municipal water system high-service pumping station
with two 100 HP pumps. System alternates lead pump each cycle to
equalize runtime and maintenance intervals. Lag pump remains off
unless additional capacity needed (expandable for lag operation).

Structured Text Programming

Structured Text (ST) provides high-level programming capabilities ideal for complex calculations, data manipulation, and algorithms that are cumbersome in ladder logic. GE PACSystems ST implementation follows IEC 61131-3 standards with additional vendor extensions.

When to Use Structured Text vs Ladder Logic

Use Structured Text For:

• Mathematical calculations and formula-based control
• Complex conditional logic with multiple IF-THEN-ELSE branches
• Data manipulation and array processing
• String handling and parsing operations
• Algorithm implementation (PID control, statistical analysis)
• Communication protocol handling

Use Ladder Logic For:

• Boolean interlocks and safety logic
• Sequential control and state machines
• Motor control and discrete device control
• Operator interface and pushbutton logic
• Traditional relay replacement applications

Structured Text Syntax Fundamentals

Basic ST Program Structure:

PROGRAM PID_Temperature_Control
VAR
    (* Input Variables *)
    Process_Temperature : REAL;  (* Current temperature from sensor *)
    Setpoint : REAL;             (* Desired temperature *)
    Manual_Mode : BOOL;          (* Manual/Auto mode selector *)
    Manual_Output : REAL;        (* Manual output value 0-100% *)

    (* Control Parameters *)
    Kp : REAL := 2.0;           (* Proportional gain *)
    Ki : REAL := 0.5;           (* Integral gain *)
    Kd : REAL := 0.1;           (* Derivative gain *)

    (* Internal Variables *)
    Error : REAL;                (* Control error *)
    Integral : REAL := 0.0;     (* Integral accumulator *)
    Last_Error : REAL := 0.0;   (* Previous error for derivative *)
    Derivative : REAL;           (* Error rate of change *)

    (* Output Variables *)
    Control_Output : REAL;       (* Final control output 0-100% *)
END_VAR

(* PID Control Algorithm *)
IF NOT Manual_Mode THEN
    (* Calculate error *)
    Error := Setpoint - Process_Temperature;

    (* Proportional term *)
    Control_Output := Kp * Error;

    (* Integral term with anti-windup *)
    Integral := Integral + (Ki * Error);
    IF Integral > 100.0 THEN
        Integral := 100.0;
    ELSIF Integral < 0.0 THEN
        Integral := 0.0;
    END_IF;
    Control_Output := Control_Output + Integral;

    (* Derivative term *)
    Derivative := Kd * (Error - Last_Error);
    Control_Output := Control_Output + Derivative;

    (* Clamp output to 0-100% *)
    IF Control_Output > 100.0 THEN
        Control_Output := 100.0;
    ELSIF Control_Output < 0.0 THEN
        Control_Output := 0.0;
    END_IF;

    (* Save error for next scan *)
    Last_Error := Error;
ELSE
    (* Manual mode - use manual output value *)
    Control_Output := Manual_Output;

    (* Track setpoint in manual mode for bumpless transfer *)
    Integral := Manual_Output - (Kp * Error);
    Last_Error := Error;
END_IF;

END_PROGRAM

ST Control Flow Statements:

(* IF-THEN-ELSE Conditional *)
IF Temperature > High_Limit THEN
    Heater_Enable := FALSE;
    Alarm_Active := TRUE;
ELSIF Temperature < Low_Limit THEN
    Heater_Enable := TRUE;
    Alarm_Active := FALSE;
ELSE
    Heater_Enable := TRUE;
    Alarm_Active := FALSE;
END_IF;

(* CASE Statement for Multi-Way Selection *)
CASE Machine_State OF
    0:  (* Idle state *)
        Motor_Run := FALSE;
        Ready_Indicator := TRUE;

    1:  (* Running state *)
        Motor_Run := TRUE;
        Ready_Indicator := FALSE;

    2:  (* Stopping state *)
        Motor_Run := FALSE;
        Ready_Indicator := FALSE;

    ELSE
        (* Default/fault state *)
        Motor_Run := FALSE;
        Alarm_Active := TRUE;
END_CASE;

(* FOR Loop for Array Processing *)
FOR i := 1 TO 10 DO
    Sensor_Average := Sensor_Average + Sensor_Array[i];
END_FOR;
Sensor_Average := Sensor_Average / 10.0;

(* WHILE Loop with Condition *)
WHILE Tank_Level < Target_Level AND Fill_Time < Max_Fill_Time DO
    Fill_Valve := TRUE;
    Fill_Time := Fill_Time + 1;
END_WHILE;

(* REPEAT-UNTIL Loop *)
REPEAT
    Read_Sensor();
    Sample_Count := Sample_Count + 1;
UNTIL Sample_Count >= Required_Samples
END_REPEAT;

Practical ST Example - Chemical Dosing Calculation

FUNCTION_BLOCK Chemical_Dosing_Control
VAR_INPUT
    Flow_Rate : REAL;           (* Process flow rate in GPM *)
    Target_PPM : REAL;          (* Target chemical concentration in PPM *)
    Chemical_Specific_Gravity : REAL;  (* Chemical SG *)
    Enable : BOOL;              (* Dosing enable *)
END_VAR

VAR_OUTPUT
    Pump_Speed : REAL;          (* Dosing pump speed 0-100% *)
    Daily_Usage : REAL;         (* Estimated daily chemical usage in gallons *)
    Low_Chemical_Alarm : BOOL;  (* Low chemical inventory alarm *)
END_VAR

VAR
    Dose_Rate_GPM : REAL;       (* Required dose rate in GPM *)
    Dose_Rate_GPH : REAL;       (* Dose rate in gallons per hour *)
    Chemical_Tank_Level : REAL; (* Current tank level in gallons *)
    Min_Tank_Level : REAL := 50.0;  (* Minimum safe level *)
END_VAR

(* Calculate required chemical dose rate *)
IF Enable AND Flow_Rate > 0.0 THEN
    (* Formula: Dose (GPM) = (Flow * Target_PPM * 8.34) / (Chemical_SG * 1,000,000) *)
    (* 8.34 = lbs per gallon of water *)
    Dose_Rate_GPM := (Flow_Rate * Target_PPM * 8.34) /
                     (Chemical_Specific_Gravity * 1000000.0);

    (* Convert to gallons per hour for daily calculation *)
    Dose_Rate_GPH := Dose_Rate_GPM * 60.0;

    (* Estimate daily usage (24 hours) *)
    Daily_Usage := Dose_Rate_GPH * 24.0;

    (* Convert dose rate to pump speed percentage *)
    (* Assumes pump max capacity is 2.0 GPM *)
    Pump_Speed := (Dose_Rate_GPM / 2.0) * 100.0;

    (* Clamp pump speed to 0-100% *)
    IF Pump_Speed > 100.0 THEN
        Pump_Speed := 100.0;
    ELSIF Pump_Speed < 0.0 THEN
        Pump_Speed := 0.0;
    END_IF;

    (* Check chemical inventory *)
    IF Chemical_Tank_Level < Min_Tank_Level THEN
        Low_Chemical_Alarm := TRUE;
    ELSE
        Low_Chemical_Alarm := FALSE;
    END_IF;

ELSE
    (* Dosing disabled or no flow *)
    Pump_Speed := 0.0;
    Dose_Rate_GPM := 0.0;
    Dose_Rate_GPH := 0.0;
    Daily_Usage := 0.0;
END_IF;

END_FUNCTION_BLOCK

Application: Water treatment chlorination system automatically calculating required chlorine dose based on flow rate and target concentration. Used in municipal water treatment plants, cooling water systems, and industrial process water applications.

Function Block Diagram Programming

Function Block Diagram (FBD) provides graphical programming using interconnected function blocks, ideal for process control, analog signal processing, and continuous control applications common in power and process industries.

FBD Programming Methodology

Function Block Diagram Advantages:

• Visual representation of signal flow and data processing
• Natural fit for analog control and process applications
• Reusable function blocks encapsulate complex functionality
• Easy integration of standard control algorithms (PID, scaling, filtering)
• Intuitive for engineers familiar with process control diagrams

Basic FBD Elements:

Input Variables → [Function Block] → Output Variables
                       ↓
                  Internal State

Standard Function Blocks in PACSystems

Analog Scaling Block:

Raw_Input (INT)  →  |              |  → Scaled_Output (REAL)
Input_Min (INT)  →  |   SCALE      |
Input_Max (INT)  →  |   Function   |
Output_Min (REAL) → |              |
Output_Max (REAL) → |______________|

Example FBD Implementation - Temperature Scaling:

%AI00001     →  |                |  → Process_Temp
(4-20mA)        |  Input: 6242   |     (Scaled 32-250°F)
                |  In_Min: 6242  |
6242        →   |  In_Max: 31208 |
31208       →   |  Out_Min: 32.0 |
32.0        →   |  Out_Max: 250.0|
250.0       →   |________________|

Converts 4-20mA analog input (6242-31208 counts from ADC)
to engineering units (32-250°F) for temperature display and control.

PID Control Block:

PV (REAL)        →  |              |  → CV (REAL)
SP (REAL)        →  |              |     Control Value
Auto (BOOL)      →  |    PID       |
                    |  Controller  |  → Error (REAL)
Kp (REAL)        →  |              |
Ki (REAL)        →  |              |
Kd (REAL)        →  |______________|

Math Function Blocks:

ADD:  Input1 + Input2 = Output
SUB:  Input1 - Input2 = Output
MUL:  Input1 * Input2 = Output
DIV:  Input1 / Input2 = Output
SQRT: Square root function
ABS:  Absolute value
MIN:  Minimum of inputs
MAX:  Maximum of inputs
AVG:  Average of inputs

Complete FBD Example - Batch Temperature Control

[Batch Temperature Control System]

Setpoint_Input  →  |      |  →  Setpoint_Value
                   | MOV  |
                   |______|

Tank_Temp_AI  →  |                |  → Temperature_°F
               |  SCALE          |
0          →   |  In: 0-32767    |
32767      →   |  Out: 0-500°F   |
0.0        →   |                 |
500.0      →   |_________________|

Temperature_°F  →  |                |  → Heater_Output_%
Setpoint_Value  →  |      PID       |
Auto_Mode       →  |   Controller   |
                   |  Kp: 2.5       |  → Control_Error
2.5         →      |  Ki: 0.8       |
0.8         →      |  Kd: 0.2       |
0.2         →      |________________|

Heater_Output_% →  |                |  → Heater_Demand_Counts
                   |  SCALE         |
0.0         →      |  In: 0-100%    |
100.0       →      |  Out: 0-32767  |
0           →      |                |
32767       →      |________________|

Heater_Demand_Counts → %AQ00001 (4-20mA Heater Control)

Application: Pharmaceutical batch reactor temperature control
maintaining ±2°F process temperature using electric heater with
4-20mA control signal. PID algorithm provides stable control
throughout heating and holding phases.

Communication and Networking

GE PACSystems provides comprehensive communication capabilities supporting multiple industrial protocols enabling integration with diverse field devices, HMI systems, SCADA platforms, and enterprise networks.

Ethernet Global Data (EGD)

EGD Overview:

Ethernet Global Data (EGD) provides GE's proprietary high-speed data exchange mechanism enabling distributed PACSystems controllers to share I/O, setpoints, and status information without master/slave polling overhead.

EGD Key Features:

• Publisher/Subscriber Model: Controllers publish data automatically received by subscribers
• Deterministic Performance: Configurable exchange rates from 10ms to 60 seconds
• Multicast Efficiency: Single transmission reaches multiple subscribers simultaneously
• Simple Configuration: Drag-and-drop exchange configuration in Proficy Machine Edition
• High Bandwidth: Exchanges up to 1,400 bytes per message
• Network Independence: Works across routed networks and VLANs

EGD Configuration Example:

Publisher Controller: RX3i Station 1 (192.168.1.100)
Exchange Name: PUMP_STATUS
Data: %R00100 through %R00150 (50 registers)
Period: 100ms
Multicast Address: 239.192.1.1

Subscriber Controller: RX3i Station 2 (192.168.1.101)
Exchange Name: PUMP_STATUS (consume)
Local Memory: %R00200 through %R00250
Source: 192.168.1.100 (Publisher)

Application: Pump station status shared with main water treatment
plant controller including pump run status, flow rates, pressures,
and valve positions updated 10 times per second.

Modbus TCP/RTU Communication

GE PACSystems supports both Modbus TCP (Ethernet) and Modbus RTU (serial) protocols enabling connection to thousands of compatible devices from hundreds of manufacturers.

Modbus Communication Setup:

1. Add Modbus configuration to hardware tree
2. Configure as Master or Slave
3. Define register mappings between Modbus addresses and PACSystems references
4. Set communication parameters (baud rate, parity, timeout)

Modbus Master Example - Reading Flow Meter:

Modbus TCP Master Configuration:
Device IP: 192.168.1.55 (Electromagnetic Flow Meter)
Function Code: 03 (Read Holding Registers)
Starting Address: 40001
Register Count: 4 registers
Mapping:
  40001-40002 → %R01000-01001 (Flow Rate - 32-bit Float)
  40003-40004 → %R01002-01003 (Totalizer - 32-bit Float)
Poll Rate: 500ms

For complete Modbus protocol implementation details including frame structure, function codes, and wiring, see our comprehensive Modbus RTU Protocol Tutorial.

PROFINET IO Integration

PACSystems RX3i controllers support PROFINET IO Controller functionality, enabling integration with PROFINET field devices including drives, I/O modules, and instrumentation.

PROFINET Configuration Steps:

1. Add PROFINET IO Controller to hardware configuration
2. Import GSDML device description files for PROFINET devices
3. Configure IO Controller IP address and device name
4. Add PROFINET devices to configuration
5. Map device data to PACSystems memory references
6. Set update rates and diagnostic parameters

PROFINET Application Example:

PACSystems RX3i (192.168.2.10) as PROFINET IO Controller
├── Siemens G120 VFD Drive (192.168.2.20)
│   ├── Control Word → %Q00100
│   ├── Speed Reference → %AQ00001
│   ├── Status Word → %I00100
│   └── Actual Speed → %AI00001
│
├── Phoenix Contact Axioline I/O (192.168.2.30)
│   ├── 16 DI → %I00200-00215
│   └── 16 DO → %Q00200-00215
│
└── Endress+Hauser Flow Meter (192.168.2.40)
    ├── Flow Rate → %AI00010
    └── Totalizer → %R01500-01501

Update Time: 10ms (PROFINET RT)

Learn more about PROFINET protocol, RT/IRT communication, and advanced configuration in our PROFINET Tutorial Complete Guide.

EtherNet/IP Communication

EtherNet/IP support enables PACSystems integration with Allen-Bradley and other CIP-based automation devices, facilitating multi-vendor system integration.

EtherNet/IP Configuration:

• PACSystems can operate as EtherNet/IP Adapter or Scanner
• Import EDS device files for EtherNet/IP devices
• Configure Class 1 (cyclic) and Class 3 (explicit messaging) connections
• Map I/O assembly data to PACSystems memory

OPC UA Server

Modern RX3i CPUs include integrated OPC UA server enabling secure data access for SCADA systems, MES platforms, historians, and Industry 4.0 applications.

OPC UA Features:

• Secure authenticated connections with encryption
• Industry-standard information modeling
• Platform-independent client connectivity
• Historian integration without additional hardware
• Cloud connectivity for remote monitoring

Practical Application: Water Treatment Plant

This comprehensive example demonstrates complete PACSystems programming for a small municipal water treatment plant including raw water pumping, chemical dosing, filter control, and high-service distribution pumping.

System Overview

Process Description:

1. Raw water pumped from river intake to plant
2. Coagulant chemicals added for flocculation
3. Clarified water passes through multimedia filters
4. Chlorine disinfection added
5. Treated water pumped to distribution system

Control Requirements:

• Automatic pump sequencing with lead/lag rotation
• Flow-paced chemical dosing with override capability
• Filter backwash sequencing based on differential pressure
• Storage tank level control
• SCADA system integration via Modbus TCP

Hardware Configuration

PACSystems RX3i System:

CPU: IC695CPE310 (192.168.1.10)
Power Supply: IC695PSA040
Ethernet Module: IC695ETM001 (192.168.1.11)

Backplane Configuration:
Slot 0: IC695CPE310 CPU
Slot 1: IC695MDL740 - 32pt 24VDC Input
Slot 2: IC695MDL940 - 32pt 24VDC Output
Slot 3: IC695ALG600 - 8ch Analog Input (4-20mA)
Slot 4: IC695ALG608 - 8ch Analog Output (4-20mA)
Slot 5: IC695ETM001 - Ethernet Switch Module

Total Cost: ~$8,500 USD for complete system

I/O Assignment:

DIGITAL INPUTS (%I):
%I00001 - Raw_Water_Low_Level
%I00002 - Raw_Water_High_Level
%I00003 - Filter_1_Run_Status
%I00004 - Filter_2_Run_Status
%I00005 - Filter_3_Run_Status
%I00006 - Clear_Well_Low_Level
%I00007 - Clear_Well_High_Level
%I00008 - HS_Pump_1_Run_Status
%I00009 - HS_Pump_2_Run_Status
%I00010 - Chem_Pump_Run_Status
%I00011 - Auto_Mode_Selector
%I00012 - Emergency_Stop

DIGITAL OUTPUTS (%Q):
%Q00001 - Raw_Water_Pump_1
%Q00002 - Raw_Water_Pump_2
%Q00003 - Chemical_Feed_Pump
%Q00004 - Filter_1_Influent_Valve
%Q00005 - Filter_2_Influent_Valve
%Q00006 - Filter_3_Influent_Valve
%Q00007 - HS_Pump_1_Starter
%Q00008 - HS_Pump_2_Starter
%Q00009 - Backwash_Valve
%Q00010 - Plant_Alarm_Horn

ANALOG INPUTS (%AI):
%AI00001 - Raw_Water_Flow (0-1000 GPM)
%AI00002 - Filter_1_DP (0-10 PSI)
%AI00003 - Filter_2_DP (0-10 PSI)
%AI00004 - Filter_3_DP (0-10 PSI)
%AI00005 - Clear_Well_Level (0-20 feet)
%AI00006 - Distribution_Pressure (0-100 PSI)
%AI00007 - Chlorine_Residual (0-5 PPM)
%AI00008 - Turbidity (0-10 NTU)

ANALOG OUTPUTS (%AQ):
%AQ00001 - Raw_Water_VFD_Speed (0-100%)
%AQ00002 - Chemical_Pump_Speed (0-100%)
%AQ00003 - HS_Pump_1_VFD_Speed (0-100%)
%AQ00004 - HS_Pump_2_VFD_Speed (0-100%)

Flow-Paced Chemical Dosing Program

FUNCTION_BLOCK Chemical_Dosing
VAR_INPUT
    Raw_Water_Flow_GPM : REAL;      (* Current plant flow *)
    Target_Coag_Dose_PPM : REAL;    (* Operator setpoint *)
    Chemical_SG : REAL := 1.35;     (* Alum specific gravity *)
    Auto_Enable : BOOL;             (* Automatic dosing enable *)
    Manual_Speed : REAL;            (* Manual pump speed 0-100% *)
END_VAR

VAR_OUTPUT
    Pump_Speed_Command : REAL;      (* Pump speed output 0-100% *)
    Daily_Usage_Gallons : REAL;     (* Usage tracking *)
END_VAR

VAR
    Required_Dose_GPM : REAL;
    Required_Dose_GPH : REAL;
    Pump_Max_Capacity : REAL := 5.0;  (* 5 GPM max *)
END_VAR

IF Auto_Enable AND Raw_Water_Flow_GPM > 10.0 THEN
    (* Calculate required chemical feed rate *)
    (* Formula: Dose(GPM) = Flow(GPM) * Dose(PPM) * 8.34 / (SG * 1,000,000) *)
    Required_Dose_GPM := (Raw_Water_Flow_GPM * Target_Coag_Dose_PPM * 8.34)
                         / (Chemical_SG * 1000000.0);

    (* Convert to percentage of pump capacity *)
    Pump_Speed_Command := (Required_Dose_GPM / Pump_Max_Capacity) * 100.0;

    (* Limit output to 0-100% *)
    IF Pump_Speed_Command > 100.0 THEN
        Pump_Speed_Command := 100.0;
    ELSIF Pump_Speed_Command < 0.0 THEN
        Pump_Speed_Command := 0.0;
    END_IF;

    (* Calculate daily usage *)
    Required_Dose_GPH := Required_Dose_GPM * 60.0;
    Daily_Usage_Gallons := Required_Dose_GPH * 24.0;

ELSIF NOT Auto_Enable THEN
    (* Manual mode *)
    Pump_Speed_Command := Manual_Speed;
    Required_Dose_GPM := (Manual_Speed / 100.0) * Pump_Max_Capacity;
    Required_Dose_GPH := Required_Dose_GPM * 60.0;
    Daily_Usage_Gallons := Required_Dose_GPH * 24.0;
ELSE
    (* Low flow - stop dosing *)
    Pump_Speed_Command := 0.0;
    Daily_Usage_Gallons := 0.0;
END_IF;

END_FUNCTION_BLOCK

High-Service Pump Control with VFD

|═════════════════════════════════════════════════════════════════|
|  High-Service Pump Control - Distribution Pressure Management    |
|═════════════════════════════════════════════════════════════════|
|                                                                  |
|  Auto_Mode    ClearWell_Low     EmergencyStop    System_Enable  |
|----] [----------]/[-----------------]/[-----------( )-----------|
|                                                                  |
|  System_Enable  Pressure_Low    Pump1_Fault      Pump1_Enable  |
|----] [------------] [--------------]/[-------------( )----------|
|                                                                  |
|  Pump1_Enable    Pump1_Start_Delay                 Pump1_Run    |
|----] [-------------] [------------------------------( )---------|
|                                                                  |
|  System_Enable  Pressure_OK      Pump2_Fault      Pump2_Enable |
|----] [------------] [---------------]/[-------------( )---------|
|                                                                  |
|  Pump2_Enable    Pump2_Start_Delay                 Pump2_Run   |
|----] [-------------] [------------------------------( )---------|
|                                                                  |

(* Pressure Control with VFD *)
FUNCTION_BLOCK Pressure_Control
VAR_INPUT
    Distribution_Pressure_PSI : REAL;
    Pressure_Setpoint : REAL := 65.0;    (* Target 65 PSI *)
    Pump_Running : BOOL;
END_VAR

VAR_OUTPUT
    VFD_Speed_Command : REAL;
END_VAR

VAR
    Error : REAL;
    Kp : REAL := 3.0;
    Base_Speed : REAL := 45.0;
END_VAR

IF Pump_Running THEN
    Error := Pressure_Setpoint - Distribution_Pressure_PSI;
    VFD_Speed_Command := Base_Speed + (Kp * Error);

    (* Limit to pump operating range *)
    IF VFD_Speed_Command > 100.0 THEN
        VFD_Speed_Command := 100.0;
    ELSIF VFD_Speed_Command < 30.0 THEN
        VFD_Speed_Command := 30.0;  (* Minimum stable speed *)
    END_IF;
ELSE
    VFD_Speed_Command := 0.0;
END_IF;

END_FUNCTION_BLOCK

Application Results:

• Automatic pressure regulation maintains 65 PSI ±2 PSI
• VFD operation reduces energy consumption 35% vs. fixed speed
• Chemical dosing maintains target coagulant dose ±5%
• System operates unattended with remote SCADA monitoring
• Typical small plant (200,000-500,000 GPD capacity)

For additional water treatment programming examples and SCADA integration, see our Water Treatment PLC Programming Guide.

RX7i Redundancy and Hot Standby

GE PACSystems RX7i controllers provide CPU redundancy for mission-critical applications in power generation, oil & gas, and process industries where continuous operation is essential. Understanding redundancy configuration distinguishes GE's capabilities in critical infrastructure applications.

Understanding CPU Redundancy

Redundant CPU Architecture:

RX7i redundant systems employ two identical CPUs operating in Primary/Backup configuration:

• Primary CPU: Actively controls I/O, executes program, and communicates with SCADA
• Backup CPU: Synchronizes with Primary, ready to assume control within 100ms if failure detected
• Synchronization: Continuous memory and I/O state replication between CPUs
• Automatic Switchover: Hardware-based fault detection triggers immediate failover
• Bumpless Transfer: Process control continues without disruption during switchover

Configuring Redundant RX7i System

Hardware Requirements:

Redundant CPU Configuration:
├── Slot 0: IC697CPX935 Primary CPU
├── Slot 1: IC697CPX935 Backup CPU
├── Redundancy Cable: Connects CPUs for synchronization
├── Redundant Ethernet: Dual network interfaces both CPUs
└── Redundant Power: Dual power supplies

Typical Redundant System Cost: $45,000-55,000 USD

Redundancy Configuration Steps:

1. Hardware Installation:

   • Install both CPUs in adjacent slots (Slot 0 and Slot 1)
   • Connect redundancy cable between CPU synchronization ports
   • Connect both CPUs to redundant Ethernet networks
   • Install redundant power supplies

2. Software Configuration (Proficy Machine Edition):

   • Create RX7i project selecting redundant CPU configuration
   • Configure Primary CPU IP addresses and parameters
   • Configure Backup CPU IP addresses (different from Primary)
   • Enable CPU redundancy in system configuration
   • Set switchover parameters (automatic/manual, switchover delay)
   • Configure I/O module redundancy if required

3. Download and Synchronization:

   • Download program to Primary CPU
   • Primary automatically synchronizes program to Backup
   • Verify both CPUs show "READY" status
   • Perform test switchover to verify failover operation

Redundant System Operation

Normal Operation:

Primary CPU:        [ACTIVE]
├── Executing program logic
├── Controlling all I/O modules
├── Communicating with SCADA/HMI
├── Synchronizing to Backup CPU
└── Monitoring Backup CPU health

Backup CPU:         [STANDBY]
├── Receiving program synchronization
├── Monitoring I/O states
├── Ready to assume control
├── Monitoring Primary CPU health
└── Waiting for switchover trigger

Switchover Scenarios:

1. Primary CPU Failure: Hardware fault, watchdog timeout, power loss
2. Communication Loss: Network failure, cable disconnection
3. Operator Commanded: Manual switchover for maintenance
4. Program Error: Runtime fault or exception in Primary CPU

Switchover Process:

T+0ms:     Primary CPU fault detected
T+10ms:    Backup CPU recognizes fault condition
T+20ms:    Backup assumes I/O control
T+50ms:    Backup begins program execution from synchronized state
T+100ms:   Process control fully restored under Backup CPU control
T+500ms:   SCADA connection re-established to Backup CPU

Practical Redundancy Example - Power Plant Application

Application: Coal-Fired Power Plant Auxiliary Systems

System Description:
- Circulating water pump control (4 x 10,000 HP pumps)
- Cooling tower fan control (12 x 500 HP fans)
- Service water distribution
- Fire protection system control
- Critical alarms and safety shutdowns

Downtime Impact:
- Plant trip: $500,000-1,000,000 per hour lost generation
- Environmental violations: $25,000+ per event
- Equipment damage: $100,000+ potential

Redundancy Justification:
- RX7i redundant system cost: $50,000
- Prevented downtime (1 event/year): $500,000 saved
- ROI: 10:1 or better
- MTBF: 10+ years continuous operation

Redundant System Configuration:

(* Redundancy Status Monitoring *)
FUNCTION_BLOCK Redundancy_Monitor
VAR_INPUT
    Primary_CPU_OK : BOOL;
    Backup_CPU_OK : BOOL;
    Sync_Status : BOOL;
    Switchover_Count : INT;
END_VAR

VAR_OUTPUT
    System_Healthy : BOOL;
    Redundancy_Lost_Alarm : BOOL;
    Excessive_Switchovers_Alarm : BOOL;
END_VAR

(* Monitor redundancy health *)
IF Primary_CPU_OK AND Backup_CPU_OK AND Sync_Status THEN
    System_Healthy := TRUE;
    Redundancy_Lost_Alarm := FALSE;
ELSE
    System_Healthy := FALSE;

    (* Alarm if redundancy compromised *)
    IF NOT (Primary_CPU_OK AND Backup_CPU_OK) THEN
        Redundancy_Lost_Alarm := TRUE;
    END_IF;
END_IF;

(* Detect excessive switchovers indicating intermittent fault *)
IF Switchover_Count > 5 THEN
    Excessive_Switchovers_Alarm := TRUE;
END_IF;

END_FUNCTION_BLOCK

Benefits Realized:

• Zero unplanned downtime over 5-year operational period
• Planned maintenance performed on backup CPU without process interruption
• Plant availability improved from 97.2% to 99.8%
• Environmental compliance violations eliminated
• Operations staff confidence in control system reliability

Industries Requiring Redundancy

Power Generation:

• Nuclear power plants (safety systems, control rod drives)
• Coal/gas-fired plants (turbine control, boiler management)
• Combined cycle plants (heat recovery steam generators)
• Renewable generation (wind farm controllers, solar inverters)

Oil & Gas:

• Offshore platforms (production control, safety systems)
• Refineries (distillation columns, cracking units)
• Pipeline systems (compressor stations, pump stations)
• LNG facilities (liquefaction trains, storage management)

Water/Wastewater:

• Large municipal treatment plants (>10 MGD capacity)
• Critical distribution pumping stations
• Regulatory compliance monitoring systems
• Wastewater plants with discharge permits

Chemical/Pharmaceutical:

• Batch reactors with critical temperature/pressure control
• Continuous process units
• Safety instrumented systems (SIS)
• Clean room environmental control

Best Practices for GE PACSystems

Professional GE PLC programming requires disciplined approaches ensuring reliability, maintainability, and long-term system performance across mission-critical power and process applications.

Program Organization Standards

Modular Program Structure:

Program Organization:
├── _MAIN (Main Program)
│   ├── System initialization
│   ├── Input conditioning
│   ├── Call control function blocks
│   └── Output assignments
│
├── PRG_Pump_Control (Pump Control Program)
│   ├── Lead/lag sequencing
│   ├── VFD speed control
│   └── Protection interlocks
│
├── PRG_Chemical_Dosing (Chemical Control Program)
│   ├── Flow pacing calculations
│   ├── Dose rate control
│   └── Chemical inventory tracking
│
├── FB_PID_Control (PID Function Block)
│   └── Reusable PID algorithm
│
└── FUN_Scale_Analog (Scaling Function)
    └── Analog input/output scaling

Benefits of Modular Organization:

• Individual programs tested independently
• Easier troubleshooting and debugging
• Code reuse across multiple applications
• Team development with defined interfaces
• Simplified documentation and maintenance

Naming Conventions

Variable Naming Standards:

Physical I/O:
Raw_Water_Pump_1_Run          (Output to pump starter)
Tank_High_Level_Switch        (Input from level switch)
Filter_Diff_Pressure_AI       (Analog input)
Chemical_Pump_Speed_AO        (Analog output)

Internal Memory:
System_Auto_Mode              (Boolean mode flags)
Pump_Lead_Select              (Selection variables)
Flow_Rate_GPM_Calc            (Calculated values)
Daily_Production_Totalizer    (Accumulators)

Function Blocks:
FB_Temperature_PID_01         (PID controller instance)
FB_Chemical_Dose_Calc         (Chemical dosing block)
FB_Filter_Backwash_Seq        (Sequence controller)

Constants:
HIGH_PRESSURE_LIMIT := 85.0   (Process limits)
LOW_FLOW_ALARM := 50.0        (Alarm setpoints)
PUMP_START_DELAY := T#5s      (Time constants)

Naming Convention Rules:

• Use descriptive names indicating function and location
• Avoid abbreviations unless industry-standard
• Use consistent capitalization (typically Upper_Case_With_Underscores)
• Include unit of measure for analog values
• Prefix function blocks with FB_, functions with FUN_
• Document all variables in declaration comments

Function Block Libraries

Creating Reusable Function Blocks:

Develop comprehensive function block libraries containing proven, tested control algorithms used across multiple projects:

Standard Library Contents:
├── FB_Pump_Control           (Standard pump logic)
├── FB_PID_Control            (PID with all features)
├── FB_Lead_Lag_Select        (Lead/lag sequencer)
├── FB_Totalizer              (Flow totalization)
├── FB_Analog_Filter          (Signal filtering)
├── FB_Alarm_Manager          (Alarm handling)
└── FB_Runtime_Equalizer      (Equipment rotation)

Library Development Benefits:

• Faster project development (50-70% time reduction)
• Consistent control algorithms across plants
• Thoroughly tested, proven code
• Reduced commissioning issues
• Easier training for operators and maintenance staff

Documentation Requirements

Comprehensive Documentation Elements:

1. Ladder Rung Comments: Explain logic purpose and operation
2. Variable Descriptions: Detailed comments for all variables
3. Function Block Headers: Purpose, inputs, outputs, algorithms
4. Network Diagrams: Ethernet topology and IP addressing
5. I/O Wiring Diagrams: Cross-reference to terminal blocks
6. Sequence Descriptions: Written descriptions of operational sequences
7. Alarm Documentation: Alarm causes and corrective actions

Documentation Example:

|═════════════════════════════════════════════════════════════════|
| PUMP LEAD/LAG ALTERNATION LOGIC                                  |
| Purpose: Alternates lead pump each start cycle to equalize      |
|          runtime and wear between Pump 1 and Pump 2             |
| Operation: Lead pump selected based on Lead_Select flag which   |
|           toggles each time both pumps stop after a run cycle   |
|═════════════════════════════════════════════════════════════════|

Backup and Version Control

Project Backup Strategy:

Backup Locations:
├── Plant Control Panel (SD card in CPU)
├── Plant Office Computer (Local backup)
├── Corporate Engineering Server (Networked backup)
└── Cloud Storage (Off-site disaster recovery)

Backup Schedule:
- Before any program changes
- After commissioning completion
- Monthly for operating systems
- After any field modifications

Version Control Information:

Track program versions with detailed change documentation:

Project: Smithville Water Treatment Plant
Program Version: 3.2.5
Date: 2025-12-11
Author: Engineering Team
Changes: Added third filter backwash sequence
         Modified chemical dosing calculation for winter operations
         Updated high-service pump rotation logic
Previous Version: 3.2.4 (2025-11-15)

Migration from Legacy GE Systems

GE Series 90 to PACSystems Migration:

Organizations operating legacy GE Series 90-30 or Series 90-70 systems benefit from migrating to modern PACSystems:

Migration Steps:

1. Inventory Existing System: Document current I/O, communication, programs
2. Select Equivalent PACSystems Hardware: Match or exceed capabilities
3. Convert Program Logic: Use Proficy Machine Edition import tools
4. Validate and Test: Comprehensive factory acceptance testing
5. Parallel Operation: Run old and new systems simultaneously initially
6. Cutover and Commissioning: Plan cutover during scheduled outage

Migration Tools:

• Logicmaster 90 to Proficy Machine Edition conversion utility
• I/O configuration import from Series 90 projects
• Reference address mapping for Series 90 compatibility
• Ethernet Global Data replacement for Genius I/O

Migration Benefits:

• Extended system life (15+ years)
• Improved performance and memory capacity
• Modern communication protocols (OPC UA, PROFINET)
• Reduced spare parts costs
• Enhanced cybersecurity capabilities

Troubleshooting Common Issues

Connection Issues

Cannot Connect to CPU:

Common Causes:

• Incorrect IP address configuration
• Network cable issues or switch problems
• CPU in wrong mode (needs to be RUN or STOP mode)
• Firewall blocking communication
• Proficy Machine Edition communication settings incorrect

Resolution Steps:

1. Verify Ethernet cable connected and link lights active
2. Ping CPU IP address from programming computer
3. Check CPU mode switch position
4. Verify firewall allows ports 18245, 18246 (GE PACSystems)
5. Use "Set PLC Mode" in Proficy to configure communication path
6. Try connecting via serial port if Ethernet fails

Configuration Errors

Hardware Configuration Mismatch:

Error: "Module in slot X does not match configured module"

Cause: Physical module different from configured module or module firmware mismatch

Resolution:

• Verify correct module installed in specified slot
• Check module catalog number matches configuration
• Update module firmware if version mismatch
• Rebuild hardware configuration if modules changed

Communication Diagnostics

Ethernet Global Data Not Updating:

Diagnostic Steps:

1. Check EGD configuration producer and consumer addresses match
2. Verify multicast routing if crossing subnets
3. Monitor EGD diagnostics in system status tables
4. Use Wireshark to capture and verify EGD packets
5. Check firewall allows UDP multicast traffic

Modbus Communication Failures:

Diagnostic Steps:

1. Verify Modbus master configuration (IP, port, slave ID)
2. Check cable continuity for Modbus RTU
3. Confirm slave device addresses configured correctly
4. Monitor Modbus status variables (%S registers)
5. Use Modbus test tools to verify slave device operation
6. Check timeout settings allow adequate response time

Firmware Updates

Updating RX3i CPU Firmware:

1. Backup current program before firmware update
2. Download firmware package from Emerson support website
3. Extract firmware files to local directory
4. Use "Update Firmware" tool in Proficy Machine Edition
5. Select firmware file and target CPU
6. Follow prompts to complete update (10-15 minutes)
7. Verify CPU boots successfully with new firmware
8. Test all critical functions before returning to operation

Firmware Update Best Practices:

• Perform updates during scheduled maintenance windows
• Have rollback plan with previous firmware version
• Test firmware update on spare CPU first if available
• Verify compatibility with current Proficy Machine Edition version
• Update I/O module firmware if required for compatibility

Frequently Asked Questions

What programming software does GE use?

GE PACSystems controllers are programmed using Proficy Machine Edition, a comprehensive IEC 61131-3 programming environment supporting all five standard programming languages (Ladder Diagram, Function Block Diagram, Structured Text, Instruction List, and Sequential Function Chart). Proficy Machine Edition provides integrated hardware configuration, program development, debugging, and online monitoring in a unified Windows-based application.

The software supports all PACSystems controller families including RX3i, RX7i, and VersaMax. Proficy Machine Edition replaced legacy Logicmaster 90 software used for older GE Series 90 PLCs and offers significantly enhanced capabilities including integrated emulation, advanced diagnostics, and modern communication protocol configuration.

Is GE PACSystems a PLC or PAC?

GE PACSystems are Programmable Automation Controllers (PACs) rather than traditional PLCs. The PAC designation reflects capabilities beyond conventional PLC functionality including:

• Multiple Programming Languages: Support for all five IEC 61131-3 languages versus single-language PLCs
• Advanced Processing Power: High-performance processors enabling complex algorithms and calculations
• Integrated Motion Control: Built-in motion control capabilities without separate motion controllers
• Comprehensive Networking: Native support for multiple industrial Ethernet protocols
• IT System Integration: OPC UA, web servers, and database connectivity

While PACSystems can certainly perform traditional PLC functions (discrete I/O control, ladder logic, sequential operations), their enhanced capabilities position them as PACs suitable for complex process control, distributed systems, and applications requiring integration between control and information technology systems.

What is Proficy Machine Edition?

Proficy Machine Edition is GE's (now Emerson's) comprehensive programming, configuration, and debugging software for PACSystems RX3i, RX7i, and VersaMax controllers. The software provides:

Core Capabilities:

• Hardware configuration tool for CPUs, I/O modules, and communication
• Programming editors for all five IEC 61131-3 languages
• Integrated emulator for program testing without hardware
• Online debugging with live variable monitoring
• Cross-reference and documentation tools
• Version control and change tracking

Advanced Features:

• Library management for reusable function blocks
• Motion control configuration and programming
• Network configuration for EGD, Modbus, PROFINET, EtherNet/IP
• System diagnostics and performance monitoring
• OPC UA server configuration

Proficy Machine Edition runs on Windows 10/11 platforms and requires appropriate licensing (development, view, or OEM licenses) depending on usage requirements.

Can GE PLCs communicate with other brands?

Yes, GE PACSystems support multiple open industrial communication protocols enabling integration with controllers, drives, instruments, and HMI systems from virtually any manufacturer:

Supported Protocols:

• Modbus TCP/RTU: Universal compatibility with thousands of devices
• PROFINET IO: Integration with Siemens and PROFINET ecosystem devices
• EtherNet/IP: Communication with Allen-Bradley and Rockwell Automation systems
• OPC UA: Industry-standard connectivity for SCADA, MES, historians
• Modbus TCP: Ethernet-based Modbus for modern field devices

Multi-Vendor Integration Examples:

• GE RX3i + Siemens drives via PROFINET
• GE RX3i + Allen-Bradley I/O via EtherNet/IP
• GE RX3i + Schneider Electric instruments via Modbus TCP
• GE RX3i + Wonderware SCADA via OPC UA

The proprietary Ethernet Global Data (EGD) protocol is GE-specific and primarily used for communication between GE PACSystems controllers, though some third-party systems support EGD via gateways.

What is Ethernet Global Data (EGD)?

Ethernet Global Data (EGD) is GE's proprietary high-speed data exchange protocol enabling distributed PACSystems controllers to share I/O, process variables, and status information without master/slave polling overhead.

EGD Characteristics:

• Publisher/Subscriber Model: Controllers publish data received automatically by subscribers
• Multicast Communication: Single transmission reaches multiple recipients simultaneously
• Deterministic Performance: Configurable update rates from 10ms to 60 seconds
• Large Data Transfers: Up to 1,400 bytes per exchange
• Reduced Network Traffic: No polling overhead, only actual data changes transmitted
• Simple Configuration: Drag-and-drop exchange setup in Proficy Machine Edition

Typical EGD Applications:

• Distributed control systems with multiple PAC controllers
• Power plant control networks sharing turbine, boiler, and auxiliary data
• Water treatment plants sharing pump station and plant controller data
• Oil & gas facilities connecting wellhead, pipeline, and terminal controllers

EGD provides significantly lower latency and higher determinism than Modbus TCP for GE-to-GE communication, making it preferred for time-critical distributed applications. For multi-vendor integration, standard protocols like Modbus TCP or OPC UA typically used instead.

What industries use GE PACSystems?

GE PACSystems dominate control applications in industries requiring maximum reliability, redundancy capabilities, and proven performance in mission-critical operations:

Power Generation (Primary Industry):

• Coal, gas, and nuclear power plants
• Combined cycle and cogeneration facilities
• Renewable generation (wind farms, solar arrays)
• Power distribution and grid management
• Typical application: Turbine control, boiler management, auxiliary systems

Oil & Gas:

• Offshore production platforms
• Refineries and petrochemical plants
• Pipeline compression and pumping stations
• LNG facilities and storage terminals
• Tank farms and custody transfer
• Typical application: Process control, safety systems, SCADA networks

Water/Wastewater:

• Municipal water treatment plants
• Wastewater treatment facilities
• Water distribution pump stations
• Reservoir and storage management
• Typical application: Chemical dosing, pump control, SCADA integration

Manufacturing & Process:

• Food and beverage processing
• Chemical manufacturing
• Pharmaceutical production
• Pulp and paper mills
• Typical application: Batch control, process automation, packaging

Infrastructure:

• Commercial building automation
• Data center control systems
• District heating and cooling
• Transportation systems
• Typical application: HVAC, energy management, critical systems

GE's strength lies particularly in applications where downtime is unacceptable, redundancy is required, and long-term reliability is paramount—which explains their dominance in power generation and critical infrastructure applications.

How do I program a GE RX3i?

Programming a GE RX3i controller follows this general workflow:

1. Install Proficy Machine Edition Software:

• Download from Emerson website or obtain from distributor
• Install with administrative privileges on Windows 10/11 computer
• Activate license (development, view, or OEM)
• Install communication drivers (Ethernet and/or serial)

2. Create New Project:

• Launch Proficy Machine Edition
• Select File → New → Project
• Choose "RX3i" as controller family
• Select specific CPU model (e.g., IC695CPE310)
• Name project and set storage location

3. Configure Hardware:

• Add CPU to configuration and set Ethernet IP addresses
• Add I/O modules from catalog to backplane slots
• Assign reference addresses to I/O modules (%I, %Q, %AI, %AQ)
• Configure communication modules if required (Modbus, PROFINET, EtherNet/IP)
• Set CPU scan rate and parameters

4. Write Program:

• Create Program Organization Units (POUs)
• Declare variables (inputs, outputs, internal memory)
• Write logic using Ladder Diagram, Structured Text, or Function Block Diagram
• Add rung comments and documentation
• Create reusable function blocks if needed

5. Compile and Debug:

• Compile project (Build menu) and resolve any errors
• Use emulator to test program logic without hardware
• Force I/O variables to simulate field conditions
• Debug and refine program

6. Download to Controller:

• Connect programming computer to RX3i via Ethernet
• Set CPU to Program mode (keyswitch or software command)
• Download project to CPU
• Switch CPU to Run mode
• Monitor program execution online
• Verify all I/O and logic operating correctly

7. Commission and Document:

• Test all control sequences with field devices
• Perform functional acceptance testing
• Create backup of final program
• Document system configuration and operation

For detailed step-by-step instructions with examples, refer to earlier sections of this tutorial covering hardware configuration, ladder logic programming, structured text, and practical applications.

What is the difference between RX3i and RX7i?

The primary differences between GE PACSystems RX3i and RX7i controller families are redundancy capabilities, performance level, and target applications:

RX3i - High-Performance Non-Redundant:

• Single CPU architecture (no redundancy)
• Performance range: 0.02-0.17 ms/K instruction execution
• Memory: 10 MB to 512 MB depending on CPU model
• Cost: $1,500-9,000 per CPU
• Applications: Standard process control, machine automation, infrastructure
• Best for: Applications where planned maintenance windows acceptable

RX7i - Mission-Critical Redundant:

• Dual redundant CPU architecture with hot standby
• High performance: 0.02-0.025 ms/K instruction execution
• Memory: 128-256 MB
• Cost: $18,000-28,000 for redundant CPU pair
• Applications: Power plants, refineries, critical infrastructure, safety systems
• Best for: Applications where downtime is unacceptable

Redundancy Differences:

• RX3i: No CPU redundancy (single point of failure)
• RX7i: Dual CPUs with automatic failover in 100ms
• RX7i: Bumpless transfer maintains process control during switchover
• RX7i: Redundant communication and power supply options

When to Choose RX7i Over RX3i:

• Downtime costs exceed $50,000+ per hour
• Regulatory requirements mandate redundancy
• Safety instrumented systems (SIL 2/3)
• 24/7 continuous operation required
• Power generation, refining, critical infrastructure applications

When RX3i is Sufficient:

• Planned maintenance windows available
• Process can tolerate brief interruptions
• Backup systems provide redundancy at system level
• Budget constraints (RX7i costs 2-3x more than equivalent RX3i)

Both families use identical programming software (Proficy Machine Edition), support same I/O modules, and use same programming languages—making migration between platforms straightforward if requirements change.

Is GE still making PLCs? (Now Emerson)

GE no longer manufactures PLCs as an independent company. In 2023, Emerson Electric completed acquisition of GE's Intelligent Platforms business (including PACSystems PLC product line) for approximately $1.6 billion. The business now operates as part of Emerson Automation Solutions.

What This Means for Users:

Positive Impacts:

• Product Continuity: All PACSystems products (RX3i, RX7i, VersaMax) continue manufacturing unchanged
• Support Maintained: Technical support, spare parts, and training continue without interruption
• Software Development: Proficy Machine Edition continues active development with regular updates
• Investment Protection: Existing installations remain fully supported with long-term commitment
• Enhanced Capabilities: Access to Emerson's broader automation portfolio and technologies

Branding Transition:

• Products transitioning from "GE PACSystems" branding to "Emerson PACSystems"
• Technical documentation and software retain familiar interfaces
• Part numbers and catalog numbers unchanged during transition
• Legacy "GE" branding remains common in field for years during transition

Future Development:

• Emerson committed to continued PACSystems platform development
• Integration with Emerson's DeltaV process control systems
• Enhanced OPC UA and IIoT capabilities
• Cybersecurity feature enhancements
• Integration with Emerson's Plantweb digital ecosystem

For Users:

• No action required for existing installations
• Continue purchasing parts and support through Emerson channels
• Training and certification programs continue
• Migration from GE Series 90 legacy systems still supported
• Long-term platform viability enhanced by Emerson's commitment

Bottom line: PACSystems remain a strategic platform with strong market position in power, oil & gas, and process industries under Emerson ownership. The acquisition strengthens rather than threatens product longevity.

Can I use GE PLCs for safety applications?

Yes, GE PACSystems can be used for safety-rated applications with appropriate hardware and programming practices meeting functional safety standards:

Safety-Rated Controllers:

• RX3i Safety CPUs: Available with TÜV certification for safety applications
• Safety Certification: SIL 2 (IEC 61508) and Category 3 (ISO 13849) rated
• RX7i Redundant: Suitable for SIL 2/SIL 3 applications with redundant architecture

Safety I/O Modules:

• Certified safety input modules for emergency stops, light curtains, safety mats
• Safety output modules for controlling safety contactors and devices
• Diagnostic coverage meeting safety integrity level requirements

Safety Programming:

• Safety logic developed using Proficy Safety Edition
• Simplified programming environment focused on safety functions
• Automatic verification and validation tools
• Restrictions on programming constructs to ensure safe behavior

Typical Safety Applications:

• Machine Safety: Emergency stops, two-hand control, light curtain interface
• Process Safety: Burner management, emergency shutdown systems
• Infrastructure Safety: Fire protection, gas detection, emergency response

Important Limitations:

• Standard PACSystems CPUs and I/O are NOT safety-rated for safety functions
• Mixed safety/standard systems require careful segregation of safety and non-safety logic
• Safety-critical applications may require dedicated Safety PLC (e.g., Emerson Safety Controller) instead of PACSystems

Best Practices:

• Consult certified functional safety engineer for safety system design
• Follow IEC 61508/61511 safety lifecycle requirements
• Perform thorough hazard analysis and risk assessment
• Use only certified safety-rated hardware for safety functions
• Implement comprehensive testing and validation procedures
• Maintain detailed safety documentation and audit trails

For high-integrity safety applications (SIL 3/4), dedicated safety controllers specifically designed for safety functions typically provide better solution than general-purpose PACSystems controllers.

---

Conclusion

GE PACSystems programming skills open career opportunities in industries where reliability, performance, and redundancy are paramount requirements—particularly power generation, oil & gas production, and critical infrastructure applications. This comprehensive tutorial covered fundamental concepts through advanced techniques including Proficy Machine Edition navigation, ladder logic programming, structured text algorithms, function block implementation, industrial communication protocols, and the redundancy capabilities distinguishing GE's platform in mission-critical applications.

Whether you're programming compact VersaMax controllers for distributed monitoring points, RX3i modular PACs for process control applications, or redundant RX7i systems for critical power plant operations, the programming principles and practical examples presented provide foundation for successful industrial automation projects. Remember that robust program organization, comprehensive documentation, and adherence to best practices separate reliable long-term installations from problematic systems requiring excessive maintenance.

Emerson's acquisition of GE Intelligent Platforms strengthens PACSystems' future with continued product development, enhanced integration capabilities, and commitment to existing customer base. For automation professionals, GE PACSystems expertise remains valuable across traditional power and process industries while expanding into emerging smart infrastructure and digital transformation applications requiring proven reliability combined with modern connectivity.

Continue developing your PACSystems programming skills through hands-on practice, explore advanced features like motion control and complex communication networks, and consider professional training through Emerson's authorized training centers to achieve mastery of this powerful platform serving the world's most critical industrial applications.