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
```