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.**