Field fix / guidePLC / HMI Code & LogicVendor-agnostic (IEC 61131-3)Power Plantindustrial-automation

Turbine Speed Control — PLC Control Template

Shared by TSIMEREZIVO Team · 4 Oct 2026 · 38 views

# Turbine Speed Control — Usage Guide ## Overview This template implements a production-grade steam turbine governor with SPEED, LOAD, and DROOP modes, 2oo3 electronic overspeed protection, mechanical backup overspeed logic, valve deviation supervision, and controlled shutdown handling for non-instantaneous trips. ## When to Use This Template | Scenario | Recommended | |----------|-------------| | Utility steam turbine governor retrofit | Yes | | Industrial back-pressure or condensing turbine | Yes | | Islanded generator with droop sharing | Yes | | High-integrity overspeed permissive layer required | Yes | | Simple VFD-driven prime mover speed loop | No | ## Quick Start 1. Import `tags/tag-list.csv` into the target PLC or DCS tag database. 2. Map all analog and digital I/O addresses to the real turbine governor cabinet. 3. Implement the controller, interlock, diagnostics, and shutdown routines from `logic/pseudocode.md`. 4. Configure alarm priorities and operator responses from `alarms/alarm-matrix.csv`. 5. Validate the manual trip, fire/gas trip, overspeed, vibration, and lube-oil trip paths before admitting steam. ## I/O Requirements | Signal | Type | Suggested Address | Range | |--------|------|-------------------|-------| | Speed pickups 1-3 | 4-20 mA AI | AI:1:0.0-0.2 | 0-4000 RPM | | Generator load | 4-20 mA AI | AI:1:0.3 | 0-120 MW | | Governor valve position | 4-20 mA AI | AI:1:0.4 | 0-100% | | Vibration X/Y | 4-20 mA AI | AI:1:0.5-0.6 | 0-250 um pk-pk | | Lube oil pressure | 4-20 mA AI | AI:1:0.7 | 0-10 bar | | Bearing temperatures | 4-20 mA AI | AI:1:1.0-1.3 | 0-200 C | | Breaker closed | DI | DI:2:0.0 | Dry contact | | Turning gear engaged | DI | DI:2:0.1 | Dry contact | | Manual trip | DI | DI:2:0.2 | Dry contact | | Fire and gas trip | DI | DI:2:0.3 | Dry contact | | Governor valve command | AO | AO:4:0.0 | 4-20 mA | | Aux oil pump / trip outputs | DO | DO:3:0.0-0.2 | Dry contact | ## Commissioning Procedure ### Pre-Start Safety Checks - Confirm all three speed pickups are calibrated and wired with healthy loop currents. - Verify the trip solenoid and throttle trip outputs are de-energized in the ready state and assert correctly in trip testing. - Stroke the governor valve through full travel and verify less than 5% steady-state deviation. - Prove lube oil main and auxiliary pump permissives, including low-pressure auto-start. - Validate fire/gas and manual emergency trip hardwired paths. ### Controller Tuning Sequence 1. Tune SPEED mode first with breaker open and the machine on turning gear or controlled warm-up. 2. Verify bumpless transfer from SPEED to LOAD mode before syncing to the grid. 3. Tune LOAD mode under stable breaker-closed operation. 4. Enable DROOP mode only after parallel operation and load-sharing requirements are confirmed. 5. Record final gains and ramp-rate settings in the plant cause-and-effect register. ### Protective Function Tests - Simulate 101% rated speed and verify overspeed alarm only. - Simulate 103% 2oo3 overspeed and verify immediate turbine trip. - Simulate 110% single-channel overspeed and verify mechanical backup trip action. - Simulate lube pressure below 2.0 bar and verify auxiliary pump auto-start. - Simulate lube pressure below 1.2 bar for 3 seconds and verify trip. - Simulate sustained vibration above 125 um pk-pk and verify controlled shutdown leading to final trip. - Verify trip reset is blocked above 95% rated speed. ## Operating Notes - Keep the scan time at 10 ms or faster to preserve overspeed response assumptions. - Do not bypass vibration protection above 90% rated speed; the template removes the bypass automatically. - Manual reset is intentionally conservative and requires operator acknowledgement after the turbine decelerates below 95% rated speed. - Treat governor valve deviation alarms as incipient actuator failures; the 10% deviation trip is a protection, not a normal operating condition. ## Applicable Standards - IEC 61131-3 — Structured Text implementation discipline - IEC 61508 / IEC 61511 — Functional safety lifecycle and protective logic expectations - API 612 / API 670 — Turbine control and vibration monitoring practices - ISO 20816 — Rotating equipment vibration evaluation ## Troubleshooting | Symptom | Likely Cause | Action | |---------|--------------|--------| | Frequent speed sensor disagreement | Pickup drift or damaged cabling | Check probe gap, shielding, and channel calibration | | Load oscillation after breaker close | Aggressive load PI tuning or sticky governor valve | Reduce PI gain and inspect actuator response | | Repeated governor deviation alarm | Positioner lag, air supply issue, or linkage friction | Repair actuator mechanics before returning to auto | | Lube pressure low alarm after startup | Main oil pump not fully primed or clogged filter | Verify pump discharge pressure and filter differential | | Controlled shutdown initiates on vibration | Rotor imbalance, bearing wear, or resonance | Reduce load and perform vibration analysis before restart | ## Version History | Version | Date | Author | Changes | |---------|------|--------|---------| | 1.0 | 2026-05-09 | TSIMEREZIVO | Completed production template with tags, alarm matrix, and commissioning guide | --- ## Control Logic — Vendor-Agnostic Pseudocode # Turbine Speed Control — Pseudocode ## Overview Complete pseudocode for a turbine governor speed control system implementing SPEED, LOAD, and DROOP operating modes with full safety interlock layer. **Scan Rate:** 10 ms (100 Hz) — required for overspeed protection response time. --- ## 1. Constants & Configuration ``` // ─── TURBINE RATED VALUES ─── CONST SPEED_RATED := 3000.0 // RPM (50 Hz) or 3600.0 (60 Hz) CONST LOAD_RATED := 100.0 // MW — turbine nameplate rating CONST SPEED_MIN := 500.0 // RPM — minimum controllable speed CONST SPEED_MAX := 4000.0 // RPM — transmitter full scale // ─── OVERSPEED PROTECTION SETPOINTS ─── CONST OS_ALARM_PCT := 101.0 // % of rated — first alarm CONST OS_TRIP_PCT := 103.0 // % of rated — electronic trip CONST OS_MECH_PCT := 110.0 // % of rated — mechanical trip CONST US_ALARM_PCT := 95.0 // % of rated — underspeed alarm // ─── GOVERNOR VALVE LIMITS ─── CONST GV_MIN := 0.0 // % — fully closed CONST GV_MAX := 100.0 // % — fully open CONST GV_RAMP_NORMAL := 2.0 // %/sec — normal operation CONST GV_RAMP_STARTUP_W := 1.0 // %/sec — warm startup CONST GV_RAMP_STARTUP_C := 0.5 // %/sec — cold startup CONST GV_RAMP_EMERGENCY := 100.0 // %/sec — trip (unrestricted close) CONST GV_DEVIATION_ALARM := 5.0 // % — command vs position deviation alarm CONST GV_DEVIATION_TRIP := 10.0 // % — deviation trip threshold // ─── VIBRATION LIMITS (μm pk-pk per API 670) ─── CONST VIB_ALARM := 80.0 // μm — Zone B boundary CONST VIB_TRIP := 125.0 // μm — Zone D boundary CONST VIB_TRIP_DELAY := 3.0 // seconds — sustained before trip // ─── LUBE OIL LIMITS ─── CONST LUBE_PRESS_LOW := 2.0 // bar — alarm, start aux pump CONST LUBE_PRESS_LL := 1.2 // bar — trip CONST LUBE_PRESS_DELAY := 3.0 // seconds — trip delay // ─── BEARING TEMPERATURE LIMITS ─── CONST BRG_TEMP_HIGH := 110.0 // °C — alarm + load reduction CONST BRG_TEMP_HH := 125.0 // °C — trip // ─── SPEED CONTROLLER PID DEFAULTS ─── CONST SPD_KP_DEFAULT := 2.0 CONST SPD_KI_DEFAULT := 0.3 CONST SPD_KD_DEFAULT := 0.05 CONST SPD_TD_FILTER := 0.1 // seconds — derivative filter // ─── LOAD CONTROLLER PI DEFAULTS ─── CONST LOAD_KP_DEFAULT := 1.5 CONST LOAD_KI_DEFAULT := 0.2 // ─── DROOP ─── CONST DROOP_DEFAULT := 4.0 // % — typical grid code requirement CONST DROOP_MIN := 2.0 CONST DROOP_MAX := 8.0 // ─── TIMING ─── CONST SCAN_TIME := 0.01 // seconds (10 ms) CONST SPEED_RAMP_WARM := 100.0 // RPM/min CONST SPEED_RAMP_COLD := 50.0 // RPM/min CONST LOAD_RAMP_DEFAULT := 1.0 // MW/min ``` --- ## 2. Input Scaling ``` FUNCTION ScaleInputs() // ─── SPEED FEEDBACK — Magnetic Pickup / Tachometer ─── // Raw signal: 4-20 mA → 0-4500 RPM // 2oo3 voting for SIL 2 overspeed protection speed_raw_1 := ScaleAnalog(AI_SPEED_1, 4.0, 20.0, 0.0, SPEED_MAX) speed_raw_2 := ScaleAnalog(AI_SPEED_2, 4.0, 20.0, 0.0, SPEED_MAX) speed_raw_3 := ScaleAnalog(AI_SPEED_3, 4.0, 20.0, 0.0, SPEED_MAX) // Sensor quality check — flag bad if outside 3.8–20.5 mA (wire break / overrange) speed_1_good := (AI_SPEED_1_RAW >= 3.8) AND (AI_SPEED_1_RAW <= 20.5) speed_2_good := (AI_SPEED_2_RAW >= 3.8) AND (AI_SPEED_2_RAW <= 20.5) speed_3_good := (AI_SPEED_3_RAW >= 3.8) AND (AI_SPEED_3_RAW <= 20.5) // 2oo3 Median select for control good_count := CountTrue(speed_1_good, speed_2_good, speed_3_good) IF good_count >= 2 THEN SPEED_FB := Median(speed_raw_1, speed_raw_2, speed_raw_3) speed_sensor_fault := FALSE ELSE IF good_count == 1 THEN SPEED_FB := SelectGood(speed_raw_1, speed_raw_2, speed_raw_3, speed_1_good, speed_2_good, speed_3_good) speed_sensor_fault := TRUE // Degraded — raise alarm ELSE speed_sensor_fault := TRUE TRIGGER TurbineTrip("All speed sensors failed") RETURN END IF // ─── LOAD FEEDBACK — Generator Power Transducer ─── // Raw signal: 4-20 mA → 0-120 MW LOAD_FB := ScaleAnalog(AI_LOAD, 4.0, 20.0, 0.0, 120.0) load_sensor_good := (AI_LOAD_RAW >= 3.8) AND (AI_LOAD_RAW <= 20.5) // ─── GOVERNOR VALVE POSITION — LVDT Feedback ─── // Raw signal: 4-20 mA → 0-100% GV_POS := ScaleAnalog(AI_GV_POS, 4.0, 20.0, 0.0, 100.0) gv_pos_good := (AI_GV_POS_RAW >= 3.8) AND (AI_GV_POS_RAW <= 20.5) // ─── VIBRATION — Proximity Probes ─── VIB_X := ScaleAnalog(AI_VIB_X, 4.0, 20.0, 0.0, 250.0) VIB_Y := ScaleAnalog(AI_VIB_Y, 4.0, 20.0, 0.0, 250.0) VIB_OVERALL := SQRT(VIB_X^2 + VIB_Y^2) // ─── LUBE OIL PRESSURE ─── LUBE_PRESS := ScaleAnalog(AI_LUBE_PRESS, 4.0, 20.0, 0.0, 10.0) // ─── BEARING TEMPERATURES — Pt100 RTDs ─── BRG_TEMP[1] := ScaleAnalog(AI_BRG_T1, 4.0, 20.0, 0.0, 200.0) BRG_TEMP[2] := ScaleAnalog(AI_BRG_T2, 4.0, 20.0, 0.0, 200.0) BRG_TEMP[3] := ScaleAnalog(AI_BRG_T3, 4.0, 20.0, 0.0, 200.0) BRG_TEMP[4] := ScaleAnalog(AI_BRG_T4, 4.0, 20.0, 0.0, 200.0) BRG_TEMP_MAX := MAX(BRG_TEMP[1], BRG_TEMP[2], BRG_TEMP[3], BRG_TEMP[4]) // ─── DIGITAL INPUTS ─── BREAKER_CLOSED := DI_BREAKER_FB TURNING_GEAR_ENGAGED := DI_TURNING_GEAR MANUAL_TRIP := DI_MANUAL_TRIP FIRE_GAS_TRIP := DI_FIRE_GAS END FUNCTION FUNCTION ScaleAnalog(raw_mA, in_lo, in_hi, out_lo, out_hi) -> REAL RETURN out_lo + (raw_mA - in_lo) / (in_hi - in_lo) * (out_hi - out_lo) END FUNCTION FUNCTION Median(a, b, c) -> REAL IF (a >= b AND a <= c) OR (a <= b AND a >= c) THEN RETURN a IF (b >= a AND b <= c) OR (b <= a AND b >= c) THEN RETURN b RETURN c END FUNCTION ``` --- ## 3. Mode Selection ``` FUNCTION ModeSelection() // ─── MODE ENUMERATION ─── // MODE_SPEED := 1 // MODE_LOAD := 2 // MODE_DROOP := 3 prev_mode := current_mode // ─── AUTOMATIC MODE TRANSFER ON BREAKER ─── // Breaker opens (load rejection) → force SPEED mode immediately IF NOT BREAKER_CLOSED AND prev_breaker_state THEN current_mode := MODE_SPEED load_rejection_active := TRUE LogEvent("LOAD REJECTION — Breaker opened, reverting to SPEED mode") END IF // ─── OPERATOR MODE SELECTION ─── // Only allowed when not in trip state IF NOT trip_active THEN IF operator_request_speed AND BREAKER_CLOSED == FALSE THEN current_mode := MODE_SPEED ELSE IF operator_request_load AND BREAKER_CLOSED THEN current_mode := MODE_LOAD ELSE IF operator_request_droop AND BREAKER_CLOSED THEN current_mode := MODE_DROOP END IF END IF // ─── BUMPLESS TRANSFER ─── // When switching modes, initialise the new controller to match current output IF current_mode != prev_mode THEN CALL BumplessTransfer(prev_mode, current_mode) LogEvent("Mode transfer: " + ModeName(prev_mode) + " → " + ModeName(current_mode)) END IF prev_breaker_state := BREAKER_CLOSED END FUNCTION FUNCTION BumplessTransfer(from_mode, to_mode) // Capture current governor valve command as starting point current_output := GV_CMD_RAMPED IF to_mode == MODE_SPEED THEN // Reset speed PID integrator to match current output spd_pid_integral := current_output - SPD_KP * (SPEED_REF - SPEED_FB) spd_pid_integral := CLAMP(spd_pid_integral, GV_MIN, GV_MAX) ELSE IF to_mode == MODE_LOAD THEN // Reset load PI integrator to match current output load_pi_integral := current_output - LOAD_KP * (LOAD_REF - LOAD_FB) load_pi_integral := CLAMP(load_pi_integral, GV_MIN, GV_MAX) ELSE IF to_mode == MODE_DROOP THEN // Set droop reference from current operating point droop_speed_bias := SPEED_FB - SPEED_RATED spd_pid_integral := current_output - SPD_KP * 0.0 spd_pid_integral := CLAMP(spd_pid_integral, GV_MIN, GV_MAX) END IF END FUNCTION ``` --- ## 4. Speed Controller (PID with Anti-Windup) ``` // ─── PERSISTENT STATE ─── VAR spd_pid_integral := 0.0 // Integrator accumulator VAR spd_pid_prev_error := 0.0 // Previous error for derivative VAR spd_pid_prev_deriv := 0.0 // Filtered derivative (previous) VAR spd_pid_output := 0.0 // Controller output (0-100%) FUNCTION SpeedController() -> REAL // ─── CALCULATE ERROR ─── speed_error := SPEED_REF - SPEED_FB // ─── PROPORTIONAL TERM ─── p_term := SPD_KP * speed_error // ─── INTEGRAL TERM WITH ANTI-WINDUP (Clamping Method) ─── // Only integrate if output is NOT saturated, or if integration // would move output AWAY from saturation output_saturated := (spd_pid_output >= GV_MAX) OR (spd_pid_output <= GV_MIN) integration_would_desaturate := (speed_error > 0.0 AND spd_pid_output <= GV_MIN) OR (speed_error < 0.0 AND spd_pid_output >= GV_MAX) IF (NOT output_saturated) OR integration_would_desaturate THEN spd_pid_integral := spd_pid_integral + SPD_KI * speed_error * SCAN_TIME END IF // Clamp integrator independently for safety spd_pid_integral := CLAMP(spd_pid_integral, GV_MIN, GV_MAX) i_term := spd_pid_integral // ─── DERIVATIVE TERM WITH LOW-PASS FILTER ─── // d/dt of error, filtered to reject high-frequency noise // First-order filter: Td / (Td + dt) * prev + dt / (Td + dt) * new raw_derivative := (speed_error - spd_pid_prev_error) / SCAN_TIME alpha := SPD_TD_FILTER / (SPD_TD_FILTER + SCAN_TIME) filtered_derivative := alpha * spd_pid_prev_deriv + (1.0 - alpha) * raw_derivative d_term := SPD_KD * filtered_derivative // ─── SUM AND CLAMP OUTPUT ─── spd_pid_output := p_term + i_term + d_term spd_pid_output := CLAMP(spd_pid_output, GV_MIN, GV_MAX) // ─── UPDATE HISTORY ─── spd_pid_prev_error := speed_error spd_pid_prev_deriv := filtered_derivative RETURN spd_pid_output END FUNCTION FUNCTION CLAMP(value, lo, hi) -> REAL IF value < lo THEN RETURN lo IF value > hi THEN RETURN hi RETURN value END FUNCTION ``` --- ## 5. Load Controller (PI) ``` VAR load_pi_integral := 0.0 VAR load_pi_output := 0.0 FUNCTION LoadController() -> REAL // ─── VALIDATE SENSOR ─── IF NOT load_sensor_good THEN LogAlarm("Load sensor fault — holding last output") RETURN load_pi_output // Hold last known good output END IF // ─── CALCULATE ERROR ─── load_error := LOAD_REF - LOAD_FB // ─── PROPORTIONAL TERM ─── p_term := LOAD_KP * load_error // ─── INTEGRAL TERM WITH ANTI-WINDUP ─── output_saturated := (load_pi_output >= GV_MAX) OR (load_pi_output <= GV_MIN) integration_helps := (load_error > 0.0 AND load_pi_output <= GV_MIN) OR (load_error < 0.0 AND load_pi_output >= GV_MAX) IF (NOT output_saturated) OR integration_helps THEN load_pi_integral := load_pi_integral + LOAD_KI * load_error * SCAN_TIME END IF load_pi_integral := CLAMP(load_pi_integral, GV_MIN, GV_MAX) // ─── SUM AND CLAMP ─── load_pi_output := p_term + load_pi_integral load_pi_output := CLAMP(load_pi_output, GV_MIN, GV_MAX) RETURN load_pi_output END FUNCTION ``` --- ## 6. Droop Controller ``` FUNCTION DroopController() -> REAL // ─── DROOP SPEED REFERENCE CALCULATION ─── // At rated load, speed reference drops by DROOP_SET% of rated speed // Speed_Ref_Adjusted = Speed_Ref - (Droop% / 100) × (Load / Load_Rated) × Speed_Rated load_fraction := LOAD_FB / LOAD_RATED load_fraction := CLAMP(load_fraction, 0.0, 1.2) // Allow 20% overload sensing droop_offset := (DROOP_SET / 100.0) * load_fraction * SPEED_RATED adjusted_speed_ref := SPEED_REF - droop_offset // ─── USE SPEED PID WITH ADJUSTED REFERENCE ─── // Temporarily override SPEED_REF for the PID saved_ref := SPEED_REF SPEED_REF := adjusted_speed_ref result := SpeedController() SPEED_REF := saved_ref // Restore original reference RETURN result END FUNCTION ``` --- ## 7. Governor Valve Control ``` VAR GV_CMD_RAMPED := 0.0 // Rate-limited command output VAR gv_dev_timer := 0.0 // Deviation alarm timer FUNCTION GovernorValveControl() // ─── SELECT ACTIVE CONTROLLER OUTPUT ─── IF current_mode == MODE_SPEED THEN GV_CMD_RAW := SpeedController() ELSE IF current_mode == MODE_LOAD THEN GV_CMD_RAW := LoadController() ELSE IF current_mode == MODE_DROOP THEN GV_CMD_RAW := DroopController() END IF // ─── OVERRIDE: TRIP CONDITION ─── IF trip_active THEN GV_CMD_RAW := GV_MIN // Slam shut active_ramp_rate := GV_RAMP_EMERGENCY ELSE // ─── SELECT RAMP RATE ─── IF load_rejection_active THEN active_ramp_rate := GV_RAMP_EMERGENCY ELSE IF startup_phase == PHASE_COLD THEN active_ramp_rate := GV_RAMP_STARTUP_C ELSE IF startup_phase == PHASE_WARM THEN active_ramp_rate := GV_RAMP_STARTUP_W ELSE active_ramp_rate := GV_RAMP_NORMAL END IF END IF // ─── APPLY RAMP RATE LIMITER ─── max_change := active_ramp_rate * SCAN_TIME delta := GV_CMD_RAW - GV_CMD_RAMPED IF ABS(delta) <= max_change THEN GV_CMD_RAMPED := GV_CMD_RAW ELSE IF delta > 0 THEN GV_CMD_RAMPED := GV_CMD_RAMPED + max_change ELSE GV_CMD_RAMPED := GV_CMD_RAMPED - max_change END IF GV_CMD_RAMPED := CLAMP(GV_CMD_RAMPED, GV_MIN, GV_MAX) // ─── WRITE TO ANALOG OUTPUT ─── AO_GV_CMD := ScaleToOutput(GV_CMD_RAMPED, 0.0, 100.0, 4.0, 20.0) // ─── POSITION FEEDBACK DEVIATION CHECK ─── CALL CheckValveDeviation() END FUNCTION FUNCTION CheckValveDeviation() deviation := ABS(GV_CMD_RAMPED - GV_POS) IF deviation > GV_DEVIATION_TRIP THEN // Immediate trip — valve not following command TRIGGER TurbineTrip("Governor valve deviation > 10%") ELSE IF deviation > GV_DEVIATION_ALARM THEN gv_dev_timer := gv_dev_timer + SCAN_TIME IF gv_dev_timer >= 5.0 THEN LogAlarm("Governor valve deviation > 5% for 5 seconds") gv_deviation_alarm := TRUE END IF ELSE gv_dev_timer := 0.0 gv_deviation_alarm := FALSE END IF END FUNCTION FUNCTION ScaleToOutput(value, in_lo, in_hi, out_lo, out_hi) -> REAL RETURN out_lo + (value - in_lo) / (in_hi - in_lo) * (out_hi - out_lo) END FUNCTION ``` --- ## 8. Safety Interlocks ``` VAR trip_active := FALSE VAR trip_latched := FALSE VAR trip_cause := "" VAR vib_trip_timer := 0.0 VAR lube_trip_timer := 0.0 VAR aux_pump_started := FALSE FUNCTION SafetyInterlocks() // ═══════════════════════════════════════ // PRIORITY 1: IMMEDIATE TRIP CONDITIONS // ═══════════════════════════════════════ // ─── ELECTRONIC OVERSPEED TRIP (103%) ─── // 2oo3 voting: trip if at least 2 of 3 sensors agree os_trip_setpoint := SPEED_RATED * (OS_TRIP_PCT / 100.0) os_count := 0 IF speed_raw_1 >= os_trip_setpoint THEN os_count := os_count + 1 IF speed_raw_2 >= os_trip_setpoint THEN os_count := os_count + 1 IF speed_raw_3 >= os_trip_setpoint THEN os_count := os_count + 1 IF os_count >= 2 THEN TRIGGER TurbineTrip("Electronic overspeed — 2oo3 vote at 103%") END IF // ─── SINGLE SENSOR OVERSPEED (110%) — Diverse Protection ─── // Any single sensor at 110% triggers trip (defence in depth) os_mech_setpoint := SPEED_RATED * (OS_MECH_PCT / 100.0) IF speed_raw_1 >= os_mech_setpoint OR speed_raw_2 >= os_mech_setpoint OR speed_raw_3 >= os_mech_setpoint THEN TRIGGER TurbineTrip("Mechanical overspeed backup — 110%") END IF // ─── MANUAL EMERGENCY TRIP ─── IF MANUAL_TRIP THEN TRIGGER TurbineTrip("Manual emergency stop activated") END IF // ─── FIRE/GAS TRIP ─── IF FIRE_GAS_TRIP THEN TRIGGER TurbineTrip("Fire/gas detection — external trip") END IF // ═══════════════════════════════════════ // PRIORITY 1: DELAYED TRIP CONDITIONS // ═══════════════════════════════════════ // ─── LUBE OIL PRESSURE LOW-LOW ─── IF LUBE_PRESS < LUBE_PRESS_LL THEN lube_trip_timer := lube_trip_timer + SCAN_TIME IF lube_trip_timer >= LUBE_PRESS_DELAY THEN TRIGGER TurbineTrip("Lube oil pressure LL < 1.2 bar for 3 sec") END IF ELSE lube_trip_timer := 0.0 END IF // ═══════════════════════════════════════ // PRIORITY 2: CONTROLLED SHUTDOWN // ═══════════════════════════════════════ // ─── VIBRATION HIGH-HIGH (Sustained) ─── IF VIB_OVERALL >= VIB_TRIP AND NOT vib_startup_bypass THEN vib_trip_timer := vib_trip_timer + SCAN_TIME IF vib_trip_timer >= VIB_TRIP_DELAY THEN TRIGGER ControlledShutdown("Vibration HH sustained > 3 sec") END IF ELSE vib_trip_timer := 0.0 END IF // ─── BEARING TEMPERATURE HIGH-HIGH ─── IF BRG_TEMP_MAX >= BRG_TEMP_HH THEN TRIGGER ControlledShutdown("Bearing temperature HH > 125°C") END IF // ═══════════════════════════════════════ // PRIORITY 3: LOAD REDUCTION + ALARM // ═══════════════════════════════════════ // ─── VIBRATION HIGH ─── IF VIB_OVERALL >= VIB_ALARM AND NOT vib_startup_bypass THEN LogAlarm("Vibration HIGH > 80 μm pk-pk") vibration_high_alarm := TRUE ELSE vibration_high_alarm := FALSE END IF // ─── BEARING TEMPERATURE HIGH ─── IF BRG_TEMP_MAX >= BRG_TEMP_HIGH THEN LogAlarm("Bearing temperature HIGH > 110°C") brg_temp_high_alarm := TRUE // Auto load reduction: reduce load ref by 10% per scan where alarm active IF current_mode == MODE_LOAD AND LOAD_REF > (LOAD_RATED * 0.3) THEN LOAD_REF := LOAD_REF - (0.5 * SCAN_TIME) // 0.5 MW/sec reduction END IF ELSE brg_temp_high_alarm := FALSE END IF // ─── LUBE OIL PRESSURE LOW ─── IF LUBE_PRESS < LUBE_PRESS_LOW THEN LogAlarm("Lube oil pressure LOW < 2.0 bar") lube_press_low_alarm := TRUE // Start auxiliary oil pump IF NOT aux_pump_started THEN DO_AUX_PUMP := TRUE aux_pump_started := TRUE LogEvent("Auxiliary lube oil pump STARTED") END IF ELSE lube_press_low_alarm := FALSE IF aux_pump_started AND LUBE_PRESS > (LUBE_PRESS_LOW + 0.5) THEN // Hysteresis: stop aux pump only when 0.5 bar above alarm DO_AUX_PUMP := FALSE aux_pump_started := FALSE LogEvent("Auxiliary lube oil pump STOPPED") END IF END IF // ═══════════════════════════════════════ // PRIORITY 4: ALARM ONLY // ═══════════════════════════════════════ // ─── OVERSPEED ALARM (101%) ─── os_alarm_setpoint := SPEED_RATED * (OS_ALARM_PCT / 100.0) IF SPEED_FB >= os_alarm_setpoint THEN LogAlarm("Overspeed alarm — 101% of rated speed") overspeed_alarm := TRUE ELSE overspeed_alarm := FALSE END IF // ─── UNDERSPEED ALARM (95%) — Only when breaker closed ─── us_alarm_setpoint := SPEED_RATED * (US_ALARM_PCT / 100.0) IF SPEED_FB <= us_alarm_setpoint AND BREAKER_CLOSED THEN LogAlarm("Underspeed alarm — 95% of rated speed") underspeed_alarm := TRUE ELSE underspeed_alarm := FALSE END IF // ─── SPEED SENSOR FAULT ─── IF speed_sensor_fault THEN LogAlarm("Speed sensor redundancy degraded — less than 3 good sensors") END IF // ─── VIBRATION STARTUP BYPASS MANAGEMENT ─── IF SPEED_FB >= (SPEED_RATED * 0.9) THEN vib_startup_bypass := FALSE // Remove bypass above 90% speed END IF END FUNCTION FUNCTION TurbineTrip(cause: STRING) IF NOT trip_latched THEN trip_active := TRUE trip_latched := TRUE trip_cause := cause trip_timestamp := NOW() // IMMEDIATE ACTIONS: GV_CMD_RAW := GV_MIN // Close governor valve DO_TRIP_SOLENOID := TRUE // Energise trip solenoid DO_THROTTLE_TRIP := TRUE // Trip throttle valve // Reset all controllers spd_pid_integral := 0.0 load_pi_integral := 0.0 // Force SPEED mode current_mode := MODE_SPEED SPEED_REF := SPEED_RATED // Set ref to rated for restart LogEvent("*** TURBINE TRIP *** Cause: " + cause) LogAlarm("TURBINE TRIP: " + cause) END IF END FUNCTION FUNCTION ControlledShutdown(cause: STRING) // Ramp load to zero over 30 seconds, then trip IF NOT shutdown_active THEN shutdown_active := TRUE shutdown_cause := cause shutdown_timer := 0.0 shutdown_initial_load := LOAD_FB LogEvent("CONTROLLED SHUTDOWN initiated: " + cause) END IF shutdown_timer := shutdown_timer + SCAN_TIME IF shutdown_timer < 30.0 THEN // Linear ramp to zero target_load := shutdown_initial_load * (1.0 - shutdown_timer / 30.0) LOAD_REF := MAX(target_load, 0.0) current_mode := MODE_LOAD ELSE TRIGGER TurbineTrip("Controlled shutdown complete: " + shutdown_cause) shutdown_active := FALSE END IF END FUNCTION FUNCTION TripReset() // MANUAL RESET ONLY — operator must acknowledge // Only allowed when speed < 95% of rated IF operator_trip_reset AND SPEED_FB < (SPEED_RATED * 0.95) THEN trip_active := FALSE trip_latched := FALSE trip_cause := "" DO_TRIP_SOLENOID := FALSE DO_THROTTLE_TRIP := FALSE LogEvent("Trip reset by operator") ELSE IF operator_trip_reset AND SPEED_FB >= (SPEED_RATED * 0.95) THEN LogAlarm("Trip reset rejected — speed still above 95%") END IF END FUNCTION ``` --- ## 9. Diagnostics & Monitoring ``` FUNCTION Diagnostics() // ─── SPEED QUALITY ─── speed_deviation_12 := ABS(speed_raw_1 - speed_raw_2) speed_deviation_13 := ABS(speed_raw_1 - speed_raw_3) speed_deviation_23 := ABS(speed_raw_2 - speed_raw_3) max_speed_deviation := MAX(speed_deviation_12, speed_deviation_13, speed_deviation_23) IF max_speed_deviation > 50.0 THEN // 50 RPM disagreement LogAlarm("Speed sensor disagreement > 50 RPM — check calibration") speed_sensor_disagree := TRUE ELSE speed_sensor_disagree := FALSE END IF // ─── SPEED OSCILLATION DETECTION ─── // Track zero-crossings of speed error over 10-second window IF (speed_error > 0 AND prev_speed_error_sign <= 0) OR (speed_error < 0 AND prev_speed_error_sign >= 0) THEN zero_crossing_count := zero_crossing_count + 1 END IF oscillation_window_timer := oscillation_window_timer + SCAN_TIME IF oscillation_window_timer >= 10.0 THEN IF zero_crossing_count > 20 THEN // > 1 Hz oscillation LogAlarm("Speed oscillation detected — check PID tuning") speed_oscillation_alarm := TRUE ELSE speed_oscillation_alarm := FALSE END IF zero_crossing_count := 0 oscillation_window_timer := 0.0 END IF prev_speed_error_sign := speed_error // ─── PID HEALTH INDICATORS ─── pid_output_pct := spd_pid_output // Already 0-100% pid_integral_pct := (spd_pid_integral / GV_MAX) * 100.0 pid_saturated := (spd_pid_output >= GV_MAX) OR (spd_pid_output <= GV_MIN) // ─── GOVERNOR VALVE HEALTH ─── gv_travel_total := gv_travel_total + ABS(GV_CMD_RAMPED - gv_prev_position) gv_prev_position := GV_CMD_RAMPED // Track cumulative travel for predictive maintenance // ─── RUNTIME COUNTERS ─── IF SPEED_FB > SPEED_MIN THEN turbine_running_hours := turbine_running_hours + (SCAN_TIME / 3600.0) END IF IF BREAKER_CLOSED THEN turbine_loaded_hours := turbine_loaded_hours + (SCAN_TIME / 3600.0) energy_generated_mwh := energy_generated_mwh + (LOAD_FB * SCAN_TIME / 3600.0) END IF // ─── START COUNT ─── IF SPEED_FB > (SPEED_RATED * 0.95) AND NOT was_at_speed THEN start_count := start_count + 1 was_at_speed := TRUE ELSE IF SPEED_FB < SPEED_MIN THEN was_at_speed := FALSE END IF END FUNCTION ``` --- ## 10. Main Execution Loop ``` FUNCTION Main() // ─── INITIALISATION (runs once) ─── SPD_KP := SPD_KP_DEFAULT SPD_KI := SPD_KI_DEFAULT SPD_KD := SPD_KD_DEFAULT LOAD_KP := LOAD_KP_DEFAULT LOAD_KI := LOAD_KI_DEFAULT DROOP_SET := DROOP_DEFAULT current_mode := MODE_SPEED SPEED_REF := SPEED_RATED LOAD_REF := 0.0 trip_active := FALSE trip_latched := FALSE vib_startup_bypass := TRUE // Active until 90% speed startup_phase := PHASE_COLD LogEvent("Turbine Speed Controller initialised — v1.0") // ─── CYCLIC EXECUTION (every SCAN_TIME) ─── LOOP EVERY SCAN_TIME // Step 1: Read and scale all inputs CALL ScaleInputs() // Step 2: Check safety interlocks FIRST (highest priority) CALL SafetyInterlocks() // Step 3: Mode selection logic CALL ModeSelection() // Step 4: Run active controller and position valve CALL GovernorValveControl() // Step 5: Run diagnostics CALL Diagnostics() // Step 6: Update HMI outputs HMI_SPEED_FB := SPEED_FB HMI_LOAD_FB := LOAD_FB HMI_GV_POS := GV_POS HMI_GV_CMD := GV_CMD_RAMPED HMI_MODE := current_mode HMI_TRIP_ACTIVE := trip_active HMI_TRIP_CAUSE := trip_cause HMI_VIB_OVERALL := VIB_OVERALL HMI_LUBE_PRESS := LUBE_PRESS HMI_BRG_TEMP_MAX := BRG_TEMP_MAX HMI_PID_OUTPUT := spd_pid_output HMI_RUNNING_HOURS := turbine_running_hours HMI_ENERGY_MWH := energy_generated_mwh END LOOP END FUNCTION ``` --- ## Tag List ```csv Tag Name,Description,Data Type,Direction,Engineering Unit,Range Min,Range Max,Default Value,Address AI_SPEED_1_RAW,Speed pickup 1 raw input current,REAL,input,mA,0,25,,AI:1:0.0 AI_SPEED_2_RAW,Speed pickup 2 raw input current,REAL,input,mA,0,25,,AI:1:0.1 AI_SPEED_3_RAW,Speed pickup 3 raw input current,REAL,input,mA,0,25,,AI:1:0.2 AI_LOAD_RAW,Generator load transducer raw input current,REAL,input,mA,0,25,,AI:1:0.3 AI_GV_POS_RAW,Governor valve position raw input current,REAL,input,mA,0,25,,AI:1:0.4 AI_VIB_X,Turbine vibration X-axis raw input,REAL,input,um_pkpk,0,250,,AI:1:0.5 AI_VIB_Y,Turbine vibration Y-axis raw input,REAL,input,um_pkpk,0,250,,AI:1:0.6 AI_LUBE_PRESS,Lube oil pressure raw input,REAL,input,bar,0,10,,AI:1:0.7 AI_BRG_T1,Bearing temperature 1 raw input,REAL,input,C,0,200,,AI:1:1.0 AI_BRG_T2,Bearing temperature 2 raw input,REAL,input,C,0,200,,AI:1:1.1 AI_BRG_T3,Bearing temperature 3 raw input,REAL,input,C,0,200,,AI:1:1.2 AI_BRG_T4,Bearing temperature 4 raw input,REAL,input,C,0,200,,AI:1:1.3 DI_BREAKER_FB,Generator breaker closed feedback,BOOL,input,,,,FALSE,DI:2:0.0 DI_TURNING_GEAR,Turning gear engaged feedback,BOOL,input,,,,FALSE,DI:2:0.1 DI_MANUAL_TRIP,Manual emergency trip pushbutton,BOOL,input,,,,FALSE,DI:2:0.2 DI_FIRE_GAS,Fire and gas external trip input,BOOL,input,,,,FALSE,DI:2:0.3 DO_AUX_PUMP,Auxiliary lube oil pump command,BOOL,output,,,,FALSE,DO:3:0.0 DO_TRIP_SOLENOID,Turbine trip solenoid command,BOOL,output,,,,FALSE,DO:3:0.1 DO_THROTTLE_TRIP,Throttle valve trip command,BOOL,output,,,,FALSE,DO:3:0.2 AO_GV_CMD,Governor valve analog command output,REAL,output,%,0,100,0,AO:4:0.0 SPEED_FB,Median-selected turbine speed feedback,REAL,calculated,RPM,0,4000,, LOAD_FB,Generator load feedback,REAL,calculated,MW,0,120,, GV_POS,Governor valve position feedback,REAL,calculated,%,0,100,, VIB_X,Scaled turbine vibration X-axis,REAL,calculated,um_pkpk,0,250,, VIB_Y,Scaled turbine vibration Y-axis,REAL,calculated,um_pkpk,0,250,, VIB_OVERALL,Calculated overall turbine vibration,REAL,calculated,um_pkpk,0,250,, LUBE_PRESS,Scaled lube oil pressure,REAL,calculated,bar,0,10,, BRG_TEMP_MAX,Maximum bearing temperature,REAL,calculated,C,0,200,, SPEED_REF,Operator speed reference,REAL,internal,RPM,500,4000,3000, LOAD_REF,Operator load reference,REAL,internal,MW,0,100,0, DROOP_SET,Droop percentage setpoint,REAL,internal,%,2,8,4, SPD_KP,Speed loop proportional gain,REAL,internal,,0.1,10,2.0, SPD_KI,Speed loop integral gain,REAL,internal,,0,5,0.3, SPD_KD,Speed loop derivative gain,REAL,internal,,0,2,0.05, LOAD_KP,Load loop proportional gain,REAL,internal,,0.1,10,1.5, LOAD_KI,Load loop integral gain,REAL,internal,,0,5,0.2, GV_CMD_RAMPED,Rate-limited governor valve command,REAL,internal,%,0,100,0, CURRENT_MODE,Active governor control mode,INT,internal,,1,3,1, TRIP_ACTIVE,Turbine trip active status,BOOL,calculated,,,,FALSE, TRIP_LATCHED,Turbine trip latched status,BOOL,calculated,,,,FALSE, TRIP_CAUSE,Latched turbine trip cause text,STRING,calculated,,,,, SHUTDOWN_ACTIVE,Controlled shutdown active status,BOOL,calculated,,,,FALSE, SPEED_SENSOR_FAULT,Speed sensor redundancy degraded flag,BOOL,calculated,,,,FALSE, SPEED_SENSOR_DISAGREE,Speed sensor disagreement diagnostic flag,BOOL,calculated,,,,FALSE, SPEED_OSCILLATION_ALARM,Speed loop oscillation diagnostic flag,BOOL,calculated,,,,FALSE, GV_DEVIATION_ALARM,Governor valve deviation alarm status,BOOL,calculated,,,,FALSE, OVERSPEED_ALARM,Overspeed warning alarm status,BOOL,calculated,,,,FALSE, UNDERSPEED_ALARM,Underspeed warning alarm status,BOOL,calculated,,,,FALSE, VIBRATION_HIGH_ALARM,High vibration alarm status,BOOL,calculated,,,,FALSE, BRG_TEMP_HIGH_ALARM,High bearing temperature alarm status,BOOL,calculated,,,,FALSE, LUBE_PRESS_LOW_ALARM,Low lube oil pressure alarm status,BOOL,calculated,,,,FALSE, TURBINE_RUNNING_HOURS,Accumulated turbine running hours,REAL,calculated,h,0,100000,, TURBINE_LOADED_HOURS,Accumulated turbine loaded hours,REAL,calculated,h,0,100000,, ENERGY_GENERATED_MWH,Accumulated generated energy,REAL,calculated,MWh,0,1000000,, START_COUNT,Turbine successful start count,DINT,calculated,,0,100000,0, ``` --- ## Alarm Matrix ```csv Alarm Tag,Condition,Setpoint,Priority,Type,Response,Delay,Auto Acknowledge OVERSPEED_ALARM,SPEED_FB >= 101% of rated speed,101% rated,high,safety,Notify operator; verify governor response; prepare immediate load reduction or shutdown,0s,No UNDERSPEED_ALARM,SPEED_FB <= 95% of rated speed with breaker closed,95% rated,medium,process,Check grid load rejection, fuel/steam supply, and breaker status before restoring load,2s,No SPEED_SENSOR_FAULT,Less than three healthy speed pickups available,N/A,high,diagnostic,Inspect tachometer channels and maintain degraded-operation permit until redundancy restored,0s,No SPEED_SENSOR_DISAGREE,Maximum speed pickup disagreement > 50 RPM,50 RPM,medium,diagnostic,Check calibration mismatch, loose probes, and pickup air-gap before returning to normal operation,5s,Yes SPEED_OSCILLATION_ALARM,More than 20 speed-error zero crossings in 10 seconds,>20 crossings / 10s,medium,diagnostic,Retune governor PID or inspect valve stiction and process instability,10s,Yes GV_DEVIATION_ALARM,ABS(GV_CMD_RAMPED - GV_POS) > 5% for 5 seconds,5% deviation,high,equipment,Check actuator air supply, linkage, and positioner; be ready for protective trip at 10% deviation,5s,No LUBE_PRESS_LOW_ALARM,LUBE_PRESS < 2.0 bar,2.0 bar,high,equipment,Start or verify auxiliary oil pump operation and investigate lube oil system restriction or pump failure,0s,No VIBRATION_HIGH_ALARM,VIB_OVERALL >= 80 um pk-pk,80 um pk-pk,high,equipment,Reduce load, inspect rotor/bearing condition, and remove startup bypass if still active,0s,No BRG_TEMP_HIGH_ALARM,BRG_TEMP_MAX >= 110 C,110 C,high,equipment,Reduce load, confirm oil cooling performance, and inspect bearing lubrication immediately,0s,No TRIP_ACTIVE,Any turbine trip condition latched,N/A,critical,safety,Trip turbine, close governor and throttle valves, investigate latched trip cause before manual reset,0s,No SHUTDOWN_ACTIVE,Controlled shutdown routine active,N/A,high,process,Ramp load to zero over 30 seconds, maintain lubrication, and monitor shutdown completion to final trip,0s,No TRIP_RESET_REJECTED,Operator reset requested while speed remains above 95% rated,95% rated,medium,diagnostic,Hold reset, allow machine to coast down below permissive speed, then repeat reset procedure,0s,Yes ```

More like this

Rate, comment, and get full access

Members can download files, rate contributions, and discuss fixes with the engineers who posted them — free.

Join the library