Field fix / guideDesign DocumentVendor-agnostic (IEC 61131-3)Generic Modulesindustrial-automation

Pressure Reducing Valve (Pilot-Operated) — Control Design

Shared by TSIMEREZIVO Team · 4 Oct 2026 · 66 views

# Generic Module: Pressure Reducing Valve (Pilot-Operated) **Version**: 1.0 **Complexity**: Medium-High **Industries**: Hydraulics, Pneumatics, Chemical Dosing, Instrumentation, Power Generation **Valve Type**: Pilot-operated proportional reducing valve (modulates Main → Pilot spool) **Control**: Closed-loop feedback (downstream pressure sensor) --- ## 📋 Overview Reduce a high-pressure supply to a lower, regulated downstream pressure via a pilot-operated proportional valve. Unlike a **relief valve** (which dumps excess to tank), a reducing valve **modulates the main spool** to limit flow and pressure. **Use When:** - ✅ Need stable reduced pressure (e.g., 350 bar → 100 bar) - ✅ Downstream equipment rated for lower pressure - ✅ Energy efficiency critical (no dump-to-tank loss) - ✅ Smooth, proportional control required - ✅ Pressure oscillation unacceptable (use this, not relief) **Do NOT Use When:** - ❌ High downstream demand beyond valve capacity (use oversized valve or parallel setup) - ❌ Supply pressure fluctuates wildly ±100 bar (add Pre-filter first) - ❌ Pilot supply unavailable (need at least 10 bar pilot for proportional modulation) **Key Difference from Relief Valve:** - **Relief**: Holds pressure at set value, dumps excess flow to tank (energy waste = Qexcess × Ptank) - **Reducing**: Modulates to deliver needed flow at reduced pressure (energy loss = Qout × ΔP from pilot modulation only) --- ## 🎯 Control Philosophy ``` Pressure Reducing Valve (Pilot-Operated Proportional): SUPPLY (350 bar) ──→ [Main Spool] ──→ OUTLET (setpoint: 0-200 bar) ↑↑↑ (Main poppet modulation) ┌── Pilot Pressure │ Proportional ├─→ Pilot Spool Stage Solenoid │ (small 0-10 mA current modulates 5-30 bar pilot) (AO Command) │ └─→ Spring + Feedback (Spool position ∝ Main outlet pressure) Operating Principles: 1. PILOT STAGE (Small signal control): - Solenoid modulates tiny pilot flow (0.5 L/min) - Pilot pressure rises from 0 → 30 bar as solenoid current increases 0 → 10 mA - Proportional accuracy: ±0.1 mA = ±0.3 bar change (VERY sensitive) 2. MAIN STAGE (Power stage): - Pilot pressure acts on pilot piston (small) - Main poppet spring opposition creates equilibrium - Outlet pressure = f(Pilot pressure, Spring preload) - Typical relation: Outlet = (Pilot / Pilot Ratio) + Spring Offset Example: Outlet = (Pilot × 0.2) + 20 bar If Outlet < 20 bar (spring fully open), Pilot = 0 3. PRESSURE BALANCE: - When Outlet < Setpoint: Main spool opens (lower pilot), allow more flow through - When Outlet > Setpoint: Main spool closes (raise pilot), throttle flow - Equilibrium: Outlet regulated to ±2-5% of setpoint ``` **Goal**: Maintain outlet pressure = Setpoint via closed-loop PI feedback on downstream pressure sensor. --- ## 🏗️ Control Logic (Pseudocode) ```pascal PROGRAM Pressure_Reducing_Valve_Control VAR (* ─── COMMAND & MODE ─── *) Pressure_Setpoint_Bar : REAL := 100.0; (* Target reduced pressure *) Manual_Override_Pilot_Cmd : REAL := 0.0; (* 0-10 mA for manual emergency *) Enable_Closed_Loop : BOOL := TRUE; Remote_Mode : BOOL := TRUE; (* ─── FEEDBACK SENSORS ─── *) Supply_Pressure_Bar : REAL; (* High pressure input *) Outlet_Pressure_Bar : REAL; (* Regulated downstream pressure *) Outlet_Flow_LPM : REAL; (* Load flow demand *) Pilot_Pressure_Bar : REAL; (* Pilot stage feedback (optional) *) Valve_Solenoid_Current_mA : REAL; (* Actual pilot current *) (* ─── CONFIGURATION (Valve Datasheet) ─── *) Outlet_Pressure_Max_Bar : REAL := 250.0; (* Valve rating *) Supply_Pressure_Nominal_Bar : REAL := 350.0; Pilot_Current_Max_mA : REAL := 10.0; (* 0-10 mA standard *) Pilot_Pressure_Per_mA : REAL := 3.0; (* 3 bar/mA typical *) Main_Outlet_Ratio : REAL := 0.2; (* Outlet = Pilot × Ratio + Spring Offset *) Main_Spring_Bar : REAL := 20.0; (* Spring opens main at this pressure *) Proportional_Gain_Sensitivity : REAL := 1.0; (* mA sensitivity to pressure error *) Valve_Hysteresis_Bar : REAL := 0.5; (* Deadband to prevent hunting *) (* ─── CLOSED-LOOP PID ─── *) Pressure_Error : REAL; Pressure_Error_Integral : REAL := 0.0; Pressure_Error_Derivative : REAL; Last_Pressure_Error : REAL := 0.0; KP : REAL := 0.05; (* Proportional gain (0.03-0.10) *) KI : REAL := 0.002; (* Integral gain (0.001-0.005) *) KD : REAL := 0.0; (* Derivative gain (often 0 for stability) *) Integral_Limit_Bar : REAL := 5.0; (* Anti-windup: limit accumulated error *) (* ─── PILOT COMMAND ─── *) Pilot_Solenoid_Command_mA : REAL := 0.0; (* ─── FAULT DETECTION ─── *) Outlet_Pressure_High : BOOL := FALSE; (* > Setpoint + 10 bar for > 5 sec *) Outlet_Pressure_Low : BOOL := FALSE; (* < 50% Setpoint for > 3 sec *) Pilot_Saturation : BOOL := FALSE; (* Solenoid at 10 mA but pressure not rising *) Main_Valve_Leakage : BOOL := FALSE; (* Pressure drops without flow *) Pressure_Oscillation : BOOL := FALSE; (* Hunting: pressure ±20 bar in 5 sec *) (* ─── DIAGNOSTICS ─── *) Fault_Code : INT := 0; Fault_Timer_Sec : REAL := 0.0; Outlet_Pressure_History : ARRAY[0..20] OF REAL; (* Last 20 samples for trending *) History_Index : INT := 0; (* ─── STATUS ─── *) Valve_Ready : BOOL := TRUE; Valve_Fault : BOOL := FALSE; Energy_Loss_kW : REAL; (* For reporting *) END_VAR (* ═════════════════════════════════════════════════════════════ *) (* 1. SENSOR INPUT ACQUISITION *) (* ═════════════════════════════════════════════════════════════ *) (* Pressures from 4-20 mA transducers *) Supply_Pressure_Bar := (READ_ANALOG_INPUT(AI_SUPPLY_PRESS) / 4095.0) * 500.0; (* 0-500 bar range *) Outlet_Pressure_Bar := (READ_ANALOG_INPUT(AI_OUTLET_PRESS) / 4095.0) * 250.0; (* 0-250 bar *) Pilot_Pressure_Bar := (READ_ANALOG_INPUT(AI_PILOT_PRESS) / 4095.0) * 50.0; (* 0-50 bar typical *) Outlet_Flow_LPM := (READ_ANALOG_INPUT(AI_FLOW) / 4095.0) * 200.0; (* 0-200 L/min *) (* Solenoid current feedback (if available; else use command value) *) Valve_Solenoid_Current_mA := (READ_ANALOG_INPUT(AI_SOLENOID_CURRENT) / 4095.0) * 12.0; (* ~10 mA rated *) (* ═════════════════════════════════════════════════════════════ *) (* 2. HISTORICAL DATA LOGGING FOR DIAGNOSTICS *) /* ═════════════════════════════════════════════════════════════ *) Outlet_Pressure_History[History_Index] := Outlet_Pressure_Bar; History_Index := (History_Index + 1) MOD 20; (* ═════════════════════════════════════════════════════════════ *) (* 3. PRESSURE ERROR CALCULATION *) /* ═════════════════════════════════════════════════════════════ *) Pressure_Error := Pressure_Setpoint_Bar - Outlet_Pressure_Bar; (* Dead bank to prevent hunting (setpoint ±ε tolerance) *) IF ABS(Pressure_Error) < Valve_Hysteresis_Bar THEN Pressure_Error := 0.0; END_IF; (* Derivative (rate of pressure change) *) Pressure_Error_Derivative := (Pressure_Error - Last_Pressure_Error) / SCAN_TIME_SEC; Last_Pressure_Error := Pressure_Error; (* ═════════════════════════════════════════════════════════════ *) (* 4. CLOSED-LOOP PID ALGORITHM *) /* ═════════════════════════════════════════════════════════════ *) IF Enable_Closed_Loop THEN (* Proportional term *) VAR PID_Proportional := KP * Pressure_Error; (* Integral term (with anti-windup to ±Integral_Limit) *) Pressure_Error_Integral := Pressure_Error_Integral + (KI * Pressure_Error * SCAN_TIME_SEC); Pressure_Error_Integral := CLAMP(Pressure_Error_Integral, -Integral_Limit_Bar, Integral_Limit_Bar); VAR PID_Integral := Pressure_Error_Integral; (* Derivative term (CAUTION: can cause oscillation if KD > 0; usually 0 for PRV) *) VAR PID_Derivative := KD * Pressure_Error_Derivative; (* Total PID output (command in mA) *) VAR PID_Output_mA := PID_Proportional + PID_Integral + PID_Derivative; (* Clamp to solenoid range 0-10 mA *) Pilot_Solenoid_Command_mA := CLAMP(PID_Output_mA, 0.0, Pilot_Current_Max_mA); ELSE (* Manual override mode *) Pilot_Solenoid_Command_mA := Manual_Override_Pilot_Cmd; END_IF; (* ═════════════════════════════════════════════════════════════ *) (* 5. FAULT DETECTION & DIAGNOSTICS *) /* ═════════════════════════════════════════════════════════════ *) (* FAULT 1: Outlet pressure too HIGH (main valve stuck closed, pilot blocked) *) IF Outlet_Pressure_Bar > (Pressure_Setpoint_Bar + 10.0) THEN Fault_Timer_Sec := Fault_Timer_Sec + SCAN_TIME_SEC; IF Fault_Timer_Sec > 5.0 THEN Outlet_Pressure_High := TRUE; Valve_Fault := TRUE; Fault_Code := 1; END_IF; ELSE Fault_Timer_Sec := 0.0; Outlet_Pressure_High := FALSE; END_IF; (* FAULT 2: Outlet pressure too LOW (main valve stuck open, leakage, supply lost) *) IF Outlet_Pressure_Bar < (Pressure_Setpoint_Bar * 0.5) AND Outlet_Flow_LPM > 5.0 THEN Fault_Timer_Sec := Fault_Timer_Sec + SCAN_TIME_SEC; IF Fault_Timer_Sec > 3.0 THEN Outlet_Pressure_Low := TRUE; Valve_Fault := TRUE; Fault_Code := 2; END_IF; ELSE Fault_Timer_Sec := 0.0; Outlet_Pressure_Low := FALSE; END_IF; (* FAULT 3: Pilot saturation (solenoid output 10 mA but pilot pressure not rising proportionally) *) IF Pilot_Solenoid_Command_mA > 9.0 AND Pilot_Pressure_Bar < 20.0 THEN Pilot_Saturation := TRUE; Valve_Fault := TRUE; Fault_Code := 3; ELSE Pilot_Saturation := FALSE; END_IF; (* FAULT 4: Main valve leakage (supply pressure >> outlet, outlet > setpoint, but no flow) *) IF Outlet_Flow_LPM < 1.0 AND Outlet_Pressure_Bar > Pressure_Setpoint_Bar AND Supply_Pressure_Bar > (Outlet_Pressure_Bar + 50.0) THEN Main_Valve_Leakage := TRUE; Valve_Fault := TRUE; Fault_Code := 4; ELSE Main_Valve_Leakage := FALSE; END_IF; (* FAULT 5: Oscillation hunting (pressure swinging ±20 bar in 5 seconds = controller tuning too aggressive) *) VAR Outlet_Min := ARRAY_MIN(Outlet_Pressure_History); VAR Outlet_Max := ARRAY_MAX(Outlet_Pressure_History); IF (Outlet_Max - Outlet_Min) > 20.0 THEN Pressure_Oscillation := TRUE; (* Do NOT fault the hardware; this is a tuning issue. Alert operator to reduce KP *) ELSE Pressure_Oscillation := FALSE; END_IF; (* ═════════════════════════════════════════════════════════════ *) (* 6. ENERGY LOSS CALCULATION (for reporting) *) /* ═════════════════════════════════════════════════════════════ *) VAR Pressure_Drop_Bar := Supply_Pressure_Bar - Outlet_Pressure_Bar; VAR Flow_Adjusted_LPM := Outlet_Flow_LPM; (* Only count actual delivered flow *) (* Power loss = (ΔP in bar) × (Flow in L/min) / 600 *) Energy_Loss_kW := (Pressure_Drop_Bar * Flow_Adjusted_LPM) / 600.0; (* Note: Reducing valve dissipates less power than relief valve would *) (* Relief would dump all unneeded flow: (Supply - Outlet) × (Supply pressure) *) (* This reducing valve only dissipates pilot + throttling losses *) (* ═════════════════════════════════════════════════════════════ *) (* 7. OUTPUT: PILOT SOLENOID COMMAND *) /* ═════════════════════════════════════════════════════════════ *) IF Valve_Fault AND NOT Manual_Override_Pilot_Cmd > 0.0 THEN (* In case of fault, cut solenoid power (valve will despool toward neutral) *) WRITE_ANALOG_OUTPUT(AO_SOLENOID, 0.0); ELSE (* Normal operation: send PI(D) command to solenoid *) WRITE_ANALOG_OUTPUT(AO_SOLENOID, Pilot_Solenoid_Command_mA); END_IF; END_PROGRAM ``` --- ## 🏷️ Tag List | Tag | Type | I/O | Range | Description | |-----|------|-----|-------|-------------| | `PRV_01_SETPOINT` | REAL | Param | 0-250 bar | Target outlet pressure | | `PRV_01_OUTLET_PRESSURE` | REAL | Feedback | 0-250 bar | Actual outlet (regulated) pressure | | `PRV_01_SUPPLY_PRESSURE` | REAL | Feedback | 0-500 bar | Upstream supply pressure | | `PRV_01_PILOT_PRESSURE` | REAL | Feedback | 0-50 bar | Pilot stage internal pressure | | `PRV_01_OUTLET_FLOW` | REAL | Feedback | 0-200 L/min | Downstream flow demand | | `PRV_01_PILOT_SOLENOID_CMD` | REAL | Cmd | 0-10 mA | Proportional solenoid current | | `PRV_01_PILOT_CURRENT_ACT` | REAL | Feedback | 0-10 mA | Actual solenoid current (feedback) | | `PRV_01_ERROR` | REAL | Diagnostic | ±250 bar | Setpoint − Outlet pressure | | `PRV_01_ERROR_INTEGRAL` | REAL | Diagnostic | ±10 bar | Accumulated error for integral term | | `PRV_01_FAULT` | BOOL | Status | - | ANY fault condition | | `PRV_01_FAULT_CODE` | INT | Status | 0-5 | 0=OK, 1=HighPress, 2=LowPress, 3=PilotSat, 4=Leakage, 5=Oscillation | | `PRV_01_ENERGY_LOSS_kW` | REAL | Metric | 0-100 kW | Power dissipated in throttling | | `PRV_01_MANUAL_OVERRIDE` | REAL | Param | 0-10 mA | Manual pilot command (emergency only) | | `PRV_01_ENABLE_CL` | BOOL | Param | - | Enable closed-loop PID | | `PRV_01_KP_GAIN` | REAL | Param | 0.01-0.20 | Proportional gain | | `PRV_01_KI_GAIN` | REAL | Param | 0.001-0.010 | Integral gain | | `PRV_01_KD_GAIN` | REAL | Param | 0.0 | Derivative gain (usually 0) | | `PRV_01_DEADBAND_BAR` | REAL | Param | 0.1-2.0 | Hysteresis to prevent hunting | --- ## 🚨 Alarm & Trip Matrix | Alarm | Condition | Severity | Auto-Reset | |-------|-----------|----------|-----------| | **Outlet Pressure High** | Outlet > Setpoint + 10 bar for >5 sec | Critical | Auto-reset when pressure down | | **Outlet Pressure Low** | Outlet < 50% Setpoint for >3 sec | Warning | Manual (check supply/leakage) | | **Pilot Saturation** | Solenoid at 10 mA but pilot <20 bar | Critical | Manual (solenoid/nozzle blockage) | | **Main Valve Leakage** | No flow but outlet pressure >SP | Critical | Manual (poppet seat debris) | | **Pressure Oscillation** | ±20 bar swing in 5 sec | Diagnostic | Adjust PID gains (reduce KP) | | **Supply Pressure Low** | Supply < Outlet + 50 bar | Warning | Check upstream pump | --- ## 📺 HMI Layout ``` ┌──────────────────────────────────────────────┐ │ PRESSURE REDUCING VALVE #1 │ │ (Pilot-Operated Proportional) │ ├──────────────────────────────────────────────┤ │ │ │ Supply Pressure: 350 bar ═════ OK │ │ [████████████████████░░░░░] │ │ │ │ Outlet Pressure: 98.5 bar ═════ STABLE │ │ [████████░░░░░░░░░░░░░░░░░] │ │ Setpoint: 100 bar (Error: -1.5 bar) │ │ │ │ Outlet Flow: 45.2 L/min ✓ │ │ │ │ Pilot Solenoid: 5.2 mA (normal) ◆──◄ │ │ Pilot Pressure: 15.6 bar ✓ │ │ │ │ ┌────────────────────────────────────┐ │ │ │ Energy Loss: 3.2 kW (dissipated) │ │ │ │ Cost: $8.50/hour at $100/MWh │ │ │ └────────────────────────────────────┘ │ │ │ │ Status: STABLE 🟢 (Running 127 hours) │ │ Last Fault: None │ │ │ │ ┌────────────────────────────────────┐ │ │ │ Tuning (Fine-tune if hunting): │ │ │ │ KP: 0.05 [+] [-] │ │ │ │ KI: 0.002 [+] [-] │ │ │ │ KD: 0.000 │ │ │ └────────────────────────────────────┘ │ │ │ └──────────────────────────────────────────────┘ ``` --- ## 🔧 Configuration Parameters ```json { "outlet_pressure_setpoint_bar": 100.0, "outlet_pressure_max_bar": 250.0, "supply_pressure_nominal_bar": 350.0, "pilot_current_max_ma": 10.0, "pilot_pressure_per_ma": 3.0, "main_outlet_ratio": 0.2, "main_spring_bar": 20.0, "proportional_gain_kp": 0.05, "integral_gain_ki": 0.002, "derivative_gain_kd": 0.0, "integral_limit_bar": 5.0, "valve_hysteresis_deadband_bar": 0.5, "proportional_solenoid_type": "spool_modulating", "valve_cavity": "NG10_4_spool", "max_flow_lpm": 200.0, "response_time_ms": 200, "accuracy_percent": 2.0 } ``` --- ## 📝 Implementation Checklist ### Pre-Installation - [ ] **Datasheet review** (outlet pressure curve vs. pilot pressure, spring preload, hysteresis) - [ ] **Solenoid coil rating** (12V DC vs. 24V DC vs. AC; power draw) - [ ] **Pilot supply** (need at least 10 bar pilot available; internal or external?) - [ ] **Downstream equipment ratings** (ensure 100 bar is safe) - [ ] **Orifice/nozzle sizing** (critical for proportional response time) - [ ] **Current transducer on solenoid** (if feedback desired, check 0-10 mA range) - [ ] **Pressure transducers** (outlet 0-250 bar; pilot 0-50 bar; supply 0-500 bar) ### During Commissioning (4-Day Procedure) **Day 1: Bench Test** 1. Apply 350 bar supply (no load) 2. Energize solenoid with 0 mA → outlet should drop to 20 bar (spring-only opening) 3. Ramp solenoid 0 → 10 mA → outlet should rise smoothly 20 → 100+ bar 4. Record pressure vs. solenoid current curve (verify linearity) 5. Verify no external leaks (apply penetrant dye) **Day 2: Cold Load Test** 1. Connect 50 L/min pump to supply 2. Connect load valve to outlet (meter the flow) 3. Set setpoint 100 bar (solenoid ~5 mA) 4. Gradually increase load flow: 0 → 50 L/min (setpoint should hold ±5 bar) 5. Verify no oscillation hunting 6. Record solenoid current at each flow rate **Day 3: Tuning (if oscillation present)** 1. If pressure oscillates ±20 bar in 5 sec, reduce KP by 50% and re-test 2. If settling time > 10 sec, increase KI slightly 3. Record final tuning parameters **Day 4: Fault Injection & Safety** 1. Simulate pilot solenoid failure (de-energize) → outlet should drop to spring minimum 2. Simulate supply loss → outlet should drop 3. Simulate downstream blockage → pilot should saturate (10 mA) to protect load 4. Verify energy loss is within budget --- ## 📊 Expected Performance | Metric | Target | Achievable | Notes | |--------|--------|-----------|-------| | **Pressure accuracy** | ±3 bar @ SP | ±2-4 bar | Depends on tuning | | **Settling time** | <5 sec | 3-8 sec | Load-dependent | | **Oscillation** | None | ±2-3 bar | If well-tuned | | **Response time** | <500 ms | 200-400 ms | Step response to load change | | **Hysteresis** | <0.5 bar | 0.3-0.7 bar | Proportional valve characteristic | | **Leakage (at max)** | <0.5 L/min | 0.2-0.5 L/min | Poppet seat quality | | **Energy loss** | Minimal ΔP | (ΔP bar × Flow LPM) / 600 | Less than relief equivalent | --- ## 🔄 Advanced Variations ### External Pilot Supply If pilot supply unavailable from main pump, use separate pilot pump (5 L/min, 30 bar pump). Reduces complexity, allows smaller main solenoid. ### Vent Relief (Dump) Add small relief valve on pilot dump line (sets 5 bar backpressure). Improves stability; pilot spool always loaded against springs. ### Cascade Configuration Two reducing valves in series: 350 → 150 bar (first stage) → 100 bar (second stage). Reduces energy loss vs. single ORM trying to drop 350 → 100. ### Load-Check (Pilot-Operated Check) Combine PRV with integral check valve. Prevents downstream backflow (e.g., load on pump brake). ### Manual Adjustment Needle (Spring Preset) Replace solenoid with simple spring adjustment (turn knob). Ideal for simple constant-pressure applications (no proportional solenoid needed). But lose PID feedback capability. --- **Industry-standard pressure reducing valve control for hydraulic & pneumatic systems.**

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