Field fix / guideDesign DocumentVendor-agnostic (IEC 61131-3)Water / Wastewaterindustrial-automation
Filter Press & Sludge Dewatering Sequence — Control Design
Shared by TSIMEREZIVO Team · 4 Oct 2026 · 45 views
# Water/Wastewater Template: Filter Press & Sludge Dewatering Sequence
## 1. Overview
**Purpose:**
Operate a plate-frame or belt filter press to dewater municipal wastewater sludge. Thickened sludge (4–6% solids) is pumped into filter press; applied pressure (10–20 bar) forces water out, leaving dry cake (15–25% solids) that requires 75% less hauling cost. Automate the batch cycle: fill → pressurize → hold → cake release.
**Industry Standards:**
- CAES (California Cooperative Irrigation Council) — wastewater treatment design
- ASME BPE (Bioprocessing Equipment) — sanitary design of thickener/press interfaces
- NFPA 79 (Electrical for industrial machinery)
- ASTM D6730 (Centrifuge test for sludge dewaterability)
- EPA Biosolids Use and Disposal (40 CFR Part 503)
**Critical Constraints:**
- **Filter cycle:** 30–60 minutes total (fill 10 min, pressure ramp 5 min, hold 20 min, release 5 min)
- **Pressure ramp:** must reach target pressure gradually (5 min) to prevent platen slippage
- **Cake moisture:** typical target = 18–22% moisture (= 78–82% solids); depends on polymer conditioning
- **Hydraulic pressure:** 10–20 bar typical (must calibrate for each sludge/polymer combo)
- **Plate seal:** every 100+ cycles, plates need cleaning; pressure spikes indicate blockage
- **Polymer demand:** cationic polymer added upstream (0.5–2% by solids) to aggregate particles
- **Filtrate quality:** must not exceed 100 mg/L TSS (turbidity) or goes to secondary treatment (cost)
- **Safety:** high-pressure hydraulics; emergency depressurization required
**Relevant Physics:**
- **Filtration:** $Q = \frac{\Delta P}{μ (m + r_c)}$ (Darcy's law; m = filter media, $r_c$ = cake resistance)
- **Cake resistance:** $r_c = \alpha \times c \times (v - v_{final})$ (accumulates with depth)
- **Capillary pressure:** skin layer develops when pressure too high → sealing → channeling (water finds path, doesn't distribute)
- **Polydispersity:** sludge with both fine clay and coarse sand → fine particles clog faster than coarse
---
## 2. Control Philosophy
**Challenge:**
Each sludge batch is different (seasonal variation, digester condition, polymer dose). What works today (15 bar, 25 min hold) may fail tomorrow (over-pressing → filtrate turbidity >1000 mg/L NTU, or under-pressing → cake moisture >25%). Must:
- Ramp pressure smoothly to avoid shear
- Monitor filtrate clarity (turbidity sensor)
- Extend hold time if too wet
- Reduce final pressure if filtrate cloudy
- Log polymer dose & sludge MLSS for traceability
**Solution: Adaptive Pressure & Time Control with Feedback**
```
STEP 1: FILL PHASE (10 minutes)
Pump thickened sludge in at fixed rate (20 m³/h typical)
Monitor: chamber volume via sight glass or pressure rise
Setpoint: fill to 80% volume, then stop fill valve
STEP 2: PRESSURE RAMP (5 minutes, adaptive)
Target pressure: start at base_pressure (usually 12 bar)
Ramp rate: 3 bar/min (avoid plate shifting)
Monitor: filtrate flow & turbidity; if too cloudy (>500 NTU), reduce final pressure
Warning: if pressure reaches target in <2 min, reduce ramp rate (sludge too thin)
STEP 3: HOLD PHASE (time-adaptive, 15–35 min)
Maintain constant pressure while filtering continues
Monitor: filtrate flow decay (should asymptote to near zero)
Decision: extend hold if flow still >2 L/min (cake not dry enough)
Max hold time: 35 min (else power consumption unjustified)
STEP 4: RELEASE PHASE (5 minutes)
Drop pressure smoothly (1 bar/sec)
Open hydraulic drain
Activate cake discharge (platen separation = ~100 mm)
Monitor: cake falls cleanly; residual filtrate <1 L/min ("dry" state)
Log: cake weight (if scale available), cycle duration, polymer used
```
**Why This Works:**
- Adaptive ramp prevents over-press → turbid filtrate
- Filtrate feedback (turbidity + flow decline) triggers hold extension
- Gentle depressurization minimizes cake fracture
- Traceability: every cycle logged for sludge disposition audits
---
## 3. Control Logic
**Pseudocode: Filter Press Batch Dewatering**
```pascal
{ === FILTER PRESS & SLUDGE DEWATERING CONTROL === }
{ Plate-frame press with adaptive pressure & hold time }
PROCEDURE Filter_Press_Batch_Controller
CONSTANTS
FILL_TIME_MAX_SEC = 600 { 10 min max fill }
FILL_RATE_M3H_TARGET = 20 { m³/h nominal feed }
FILL_VOLUME_SETPOINT_PCT = 80 { % chamber volume }
RAMP_TIME_MIN_SEC = 300 { 5 min ramp }
RAMP_RATE_BAR_SEC = 0.05 { 3 bar/min = 0.05 bar/sec }
BASE_PRESSURE_BAR = 12 { starting target }
MAX_PRESSURE_BAR = 20 { safety limit }
HOLD_TIME_MIN_SEC = 900 { 15 min minimum }
HOLD_TIME_MAX_SEC = 2100 { 35 min maximum }
FILTRATE_FLOW_THRESHOLD_LPM = 2 { if <2 LPM, cake "dry" }
FILTRATE_TURBIDITY_ALARM_NTU = 1000 { bad filtrate }
FILTRATE_TURBIDITY_CAUTION_NTU = 500 { yellow flag }
DEPRESSURIZE_TIME_MIN_SEC = 300 { 5 min depressurize }
DEPRESSURIZE_RATE_BAR_SEC = 0.067 { 4 bar/min = 0.067 bar/sec }
POLYMER_INJECTION_MG_LITER = 1.0 { typical dose }
PRESSURE_OVERRIDE_IF_TURBID = 18 { reduce to 18 bar if turbid }
VARIABLES
{ Cycle state machine }
cycle_state : ENUMERATION { IDLE | FILL | RAMP | HOLD | DEPRESSURIZE | CAKE_DISCHARGE }
cycle_timer_sec : INTEGER
{ Measured inputs }
chamber_pressure_bar : REAL { primary feedback }
filtrate_flow_lpm : REAL { outlet valve }
filtrate_turbidity_ntu : REAL { nephelometric turbidity unit }
chamber_volume_pct : REAL { sight glass or load cell estimate }
feed_flow_m3h : REAL { inlet pump }
sludge_mlss_mgl : REAL { influent concentration }
sludge_polymer_dose_mgl : REAL { polymer added upstream }
{ Pressurization & depressurization }
pump_speed_vfd_hz : REAL { hydraulic pump }
target_pressure_bar : REAL { adaptive setpoint }
pressure_ramp_rate_bar_sec : REAL { adaptive rate }
discharge_valve_cmd : REAL { 0–100% open for depressure }
platen_separation_mm : REAL { cake discharge }
{ Adaptive parameters (learned per batch) }
final_pressure_bar : REAL { what pressure actually worked }
hold_time_actual_sec : INTEGER { how long until filtrate <2 LPM }
{ Diagnostics }
cake_weight_kg : REAL { optional scale at discharge }
cake_moisture_pct : REAL { estimated from filtrate recovery }
filtrate_total_liters : REAL { cumulative during hold }
polymer_consumption_record : ARRAY[*] { {timestamp, dose_mgl, sludge_mlss, pressure_final, hold_time} }
alarms_active : ARRAY[*] OF STRING
BEGIN
{ === SENSOR ACQUISITION === }
chamber_pressure_bar = Read_Pressure_Transducer()
filtrate_flow_lpm = Read_Filtrate_Flow_Meter()
filtrate_turbidity_ntu = Read_Turbidity_Probe()
chamber_volume_pct = Estimate_Chamber_Volume() { via pressure or load }
feed_flow_m3h = Read_Feed_Flow()
sludge_mlss_mgl = Read_Feed_MLSS() { optional TSS analyzer }
sludge_polymer_dose_mgl = Read_Polymer_Dose() { chemical metering pump }
{ === FILTER PRESS STATE MACHINE === }
CASE cycle_state
WHEN IDLE:
{ Waiting for operator start or automated schedule }
pump_speed_vfd_hz := 0
discharge_valve_cmd := 100 { open to atmosphere }
IF Operator_Pressed_Start THEN
cycle_state := FILL
cycle_timer_sec := 0
Log_Event("CYCLE_START")
{ Log starting conditions }
start_record = {
timestamp: Get_Timestamp(),
sludge_mlss: sludge_mlss_mgl,
polymer_dose: sludge_polymer_dose_mgl,
chamber_temp: Read_Chamber_Temperature()
}
END IF
WHEN FILL:
{ Pump sludge in until chamber 80% full (10 min typical) }
{ Open inlet, run pump }
pump_speed_vfd_hz := Volumetric_To_VFD_Hz(FILL_RATE_M3H_TARGET)
discharge_valve_cmd := 0 { close discharge during fill }
{ Check fill progress }
IF chamber_volume_pct >= FILL_VOLUME_SETPOINT_PCT THEN
{ Chamber full, start pressure ramp }
cycle_state := RAMP
cycle_timer_sec := 0
target_pressure_bar := BASE_PRESSURE_BAR
pressure_ramp_rate_bar_sec := RAMP_RATE_BAR_SEC
Log_Event("FILL_COMPLETE", volume_pct=chamber_volume_pct, time_sec=cycle_timer_sec)
ELSIF cycle_timer_sec > FILL_TIME_MAX_SEC THEN
{ Timeout — sludge feed too slow }
Log_Warning("FILL_TIMEOUT_SLUDGE_FEED_BLOCKED")
cycle_state := IDLE
pump_speed_vfd_hz := 0
END IF
cycle_timer_sec := cycle_timer_sec + 1
WHEN RAMP:
{ Gradually increase pressure to target (3 bar/min) }
pump_speed_vfd_hz = Pressure_To_VFD_Hz(chamber_pressure_bar, target_pressure_bar)
{ Monitor ramp progress }
IF chamber_pressure_bar >= target_pressure_bar THEN
{ Target reached, enter hold }
cycle_state := HOLD
cycle_timer_sec := 0
filtrate_total_liters := 0
{ Adaptive check: if filtrate already cloudy, reduce final pressure for next cycle }
IF filtrate_turbidity_ntu > FILTRATE_TURBIDITY_CAUTION_NTU THEN
Log_Warning("FILTRATE_TURBID_DURING_RAMP_REDUCE_PRESSURE_NEXT_CYCLE")
target_pressure_bar := MAX(10, target_pressure_bar - 1)
END IF
Log_Event("RAMP_COMPLETE", final_pressure=chamber_pressure_bar)
ELSIF cycle_timer_sec > RAMP_TIME_MIN_SEC + 60 THEN { ramp slow }
Log_Warning("RAMP_SLOW_CHECK_PUMP_CAPACITY_REDUCER")
END IF
cycle_timer_sec := cycle_timer_sec + 1
WHEN HOLD:
{ Maintain pressure while sludge dehydrates }
pump_speed_vfd_hz = Pressure_To_VFD_Hz(chamber_pressure_bar, target_pressure_bar)
discharge_valve_cmd := 0 { drain closed }
{ Accumulate filtrate }
filtrate_total_liters := filtrate_total_liters + (filtrate_flow_lpm / 60)
{ Decision: continue holding or move to depressurize? }
hold_time_enough = (cycle_timer_sec >= HOLD_TIME_MIN_SEC)
cake_dry_indicator = (filtrate_flow_lpm < FILTRATE_FLOW_THRESHOLD_LPM)
hold_time_max_reached = (cycle_timer_sec >= HOLD_TIME_MAX_SEC)
IF (cake_dry_indicator OR hold_time_max_reached) AND hold_time_enough THEN
{ Release pressure }
cycle_state := DEPRESSURIZE
cycle_timer_sec := 0
{ Log hold performance }
hold_time_actual_sec := cycle_timer_sec
final_pressure_bar := chamber_pressure_bar
Log_Event("HOLD_COMPLETE", hold_time_sec=hold_time_actual_sec, final_pressure=final_pressure_bar)
ELSIF cycle_timer_sec > HOLD_TIME_MAX_SEC THEN
{ Force depressurize after max hold (don't over-press indefinitely) }
Log_Warning("HOLD_MAX_TIME_REACHED_FORCE_DEPRESSURIZE")
cycle_state := DEPRESSURIZE
cycle_timer_sec := 0
END IF
cycle_timer_sec := cycle_timer_sec + 1
WHEN DEPRESSURIZE:
{ Reduce pressure smoothly (1 bar/sec) to avoid shock }
discharge_valve_cmd = Linear_Ramp(
start=0, end=100,
time_start=0, time_end=DEPRESSURIZE_TIME_MIN_SEC,
current_time=cycle_timer_sec
) { open drain over 5 min }
{ Target pressure decays towards zero }
IF cycle_timer_sec < DEPRESSURIZE_TIME_MIN_SEC THEN
target_pressure_bar = Base_Pressure × (1 - (cycle_timer_sec / DEPRESSURIZE_TIME_MIN_SEC))
pump_speed_vfd_hz = Pressure_To_VFD_Hz(chamber_pressure_bar, target_pressure_bar)
ELSE
pump_speed_vfd_hz := 0
discharge_valve_cmd := 100 { fully open }
END IF
{ Once pressure ~0, move to cake discharge }
IF chamber_pressure_bar < 1 THEN
cycle_state := CAKE_DISCHARGE
cycle_timer_sec := 0
Log_Event("DEPRESSURIZE_COMPLETE", residual_pressure=chamber_pressure_bar)
END IF
cycle_timer_sec := cycle_timer_sec + 1
WHEN CAKE_DISCHARGE:
{ Separate platens to release cake (platen gaps to ~100 mm) }
Activate_Platen_Separation_Motor()
platen_separation_mm := Increase_Separation_Linear(
start=10, end=150,
time_sec=10,
current_time=cycle_timer_sec
)
{ Monitor cake fall & final filtrate }
IF platen_separation_mm >= 100 THEN
cake_weight_kg = Read_Cake_Scale() { if available }
{ Log cycle completion }
final_record = {
timestamp: Get_Timestamp(),
cycle_duration_min: cycle_timer_sec / 60,
final_pressure_bar: final_pressure_bar,
hold_time_sec: hold_time_actual_sec,
filtrate_total_liters: filtrate_total_liters,
cake_weight_kg: cake_weight_kg,
sludge_mlss: sludge_mlss_mgl,
polymer_dose: sludge_polymer_dose_mgl,
filtrate_turbidity_peak_ntu: MAX(filtrate_turbidity_history[])
}
APPEND polymer_consumption_record final_record
Log_Event("CYCLE_COMPLETE_CAKE_DISCHARGED")
{ Return to idle }
cycle_state := IDLE
cycle_timer_sec := 0
{ Auto-schedule next cycle if demand }
IF Sludge_Queue_Pending THEN
Operator_Pressed_Start := TRUE { trigger next cycle }
END IF
END IF
cycle_timer_sec := cycle_timer_sec + 1
END CASE
{ === SAFETY INTERLOCKS === }
IF chamber_pressure_bar > MAX_PRESSURE_BAR THEN
Log_Alarm("PRESSURE_EXCEEDS_LIMIT_EMERGENCY_DUMP")
Activate_Relief_Valve()
pump_speed_vfd_hz := 0
END IF
IF filtrate_turbidity_ntu > FILTRATE_TURBIDITY_ALARM_NTU THEN
Log_Warning("FILTRATE_VERY_TURBID_POLYMER_DOSE_INCREASE_RECOMMENDED")
END IF
END PROCEDURE
```
---
## 4. Tag List
```
CHAMBER_PRESSURE_BAR { bar, primary control variable }
FILTRATE_FLOW_LPM { L/min, outlet }
FILTRATE_TURBIDITY_NTU { nephelometric units }
CHAMBER_VOLUME_PCT { % full estimate }
FEED_FLOW_M3H { inlet pump }
SLUDGE_MLSS_MGL { influent solids concentration }
POLYMER_DOSE_MGL { cationic polymer added }
PUMP_SPEED_VFD_HZ { Hz, hydraulic pump }
CYCLE_STATE { IDLE, FILL, RAMP, HOLD, DEPRESSURIZE, DISCHARGE }
HOLD_TIME_ACTUAL_SEC { how long actual hold took }
CAKE_WEIGHT_KG { if scale present }
FILTRATE_TOTAL_LITERS { per cycle }
FINAL_PRESSURE_BAR { what pressure was achieved }
CAKE_SEPARATION_MM { platen gap }
```
---
## 5. Alarm & Trip Matrix
| **Condition** | **Severity** | **Action** |
|---|---|---|
| **Pressure > 20 bar** | 🔴 CRIT | Emergency relief valve open; stop pump |
| **Filtrate turbidity >1000 NTU** | ⚠ WARN | Reduce pressure next cycle; increase polymer |
| **Fill timeout >10 min** | ⚠ WARN | Check inlet pump; sludge feed blockage |
| **Hold refusal (<2 LPM never reached)** | ⚠ WARN | Sludge may be over-conditioned; reduce polymer |
| **Cake discharge slow** | 🟡 WARN | Platen stickiness; clean plates soon |
---
## 6. HMI Layout
```
╔════════════════════════════════════════════════════════════════════╗
║ FILTER PRESS & SLUDGE DEWATERING — BATCH OPERATION ║
╚════════════════════════════════════════════════════════════════════╝
CURRENT CYCLE: [ HOLD PHASE ] 34 of 35 min ✓ ON SCHEDULE
┌─────────────────────────────────────────────────────────────────┐
│ CHAMBER PRESSURE & STATUS │
│ │
│ Target: 12.0 bar │
│ Current: 12.1 bar ✓ [████████████░░░░░░░░░░░] │
│ Status: STEADY (holding) │
│ │
│ Chamber Volume: 87% (full @ 80%) │
│ Pressure Ramp: Completed in 4.8 min (nominal: 5.0 min) │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ FILTRATE PRODUCTION & QUALITY │
│ │
│ Outlet Flow: 0.3 L/min ↓ (drying; started at 18 L/min) │
│ Total Filtrate: 142 L (from 160 L theoretical) │
│ Turbidity: 380 NTU ✓ OK (target <500 NTU) │
│ │
│ Cake Dryness Estimate: 19.2% moisture (target 18–22%) │
│ (Based on filtrate recovery vs input sludge volume) │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ CYCLE TIMELINE │
│ │
│ Fill (10m) [███████████░░░░░░░] 8.2 min COMPLETE │
│ Ramp (5m) [█████░░░░░░░░░░░░░░] 4.8 min COMPLETE │
│ Hold (15m+) [███████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 34/35 min
│ Depressurize [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] Pending │
│ Discharge [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] Not started │
│ │
│ Total cycle time so far: 47.0 minutes │
│ Est. total cycle completion: 57.0 min (within 60 min target) │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ SLUDGE FEED & CONDITIONING │
│ │
│ Feed Flow: 20.1 m³/h ✓ (nominal 20 m³/h) │
│ Sludge MLSS: 5200 mg/L (conc. inlet, reasonable) │
│ Polymer Dose: 1.2 mg/L (adjusted up from 1.0 yesterday) │
│ │
│ Cake Weight (on scale): 185 kg [target 180–200 kg] │
│ Days Since Plate Cleaning: 47 (recommend @ 100 cycles) │
└─────────────────────────────────────────────────────────────────┘
BATCH STATISTICS (Today — 5 cycles completed):
Avg Cycle Time: 54.2 min | Min: 48 min | Max: 61 min
Avg Cake %TS: 19.8% | Min: 18.2% | Max: 21.1%
Filtrate Quality: 3/5 batches <400 NTU (one elevated; increase polymer)
BUTTONS:
[ Start Cycle ] [ Stop Cycle (Emergency) ] [ Skip Cycle ] [ View Detailed Log ]
```
---
## 7. Configuration
**JSON (filter_press_config.json)**
```json
{
"press": {
"type": "plate_frame_filter_press",
"chamber_volume_liters": 1200,
"max_pressure_bar": 20,
"pump_displacement_cc_rev": 45
},
"fill_phase": {
"duration_sec_max": 600,
"target_volume_pct": 80,
"feed_flow_m3h_target": 20
},
"ramp_phase": {
"duration_sec_target": 300,
"ramp_rate_bar_sec": 0.05,
"base_pressure_bar": 12
},
"hold_phase": {
"duration_sec_min": 900,
"duration_sec_max": 2100,
"filtrate_flow_lpm_threshold": 2,
"filtrate_turbidity_caution": 500,
"filtrate_turbidity_alarm": 1000
},
"depressurize_phase": {
"duration_sec_target": 300,
"rate_bar_sec": 0.067
},
"discharge_phase": {
"platen_separation_target_mm": 150,
"duration_sec": 10
},
"polymer": {
"cationic_dose_mgl": 1.0,
"pressure_if_turbid_reduction": 2
}
}
```
---
## 8. Commissioning Checklist
- [ ] Hydraulic system flushed & pressure-tested to 25 bar
- [ ] Plate seals inspected; no visible leaks
- [ ] Pump displacement verified (cc/rev); curve established
- [ ] Turbidity sensor calibrated (range 0–4000 NTU)
- [ ] Pressure transducer calibrated (0–25 bar)
- [ ] Filtrate flow meter (if present) validated against bucket test
- [ ] Sludge thickener & concentration checked (must be 4–6% solids minimum)
- [ ] Polymer injection system tested (correct dose, mixing)
- [ ] First test cycle with thin sludge: observe pressure ramp, flow curve
- [ ] Cake moisture test: collect sample, oven-dry @ 105°C / 2 hours; measure %TS
- [ ] 10-cycle endurance run: log all cycles; identify normal pressure/time ranges
- [ ] Operator trained: start, monitor, emergency stop, cake handling
- [ ] Preventive maintenance schedule established (plate cleaning every 100–150 cycles)
---
**Document Version:** 1.0
**Last Updated:** 2026-04-13
**Status:** Ready for Production
**Approval:** Wastewater Operations & Engineering (pending)