UT_PUMP_CASCADE — Multi-pump booster and manifold

Runs several pumps (any number) on one header to hold a pressure (or a flow):
irrigation manifolds, booster sets, town and stock-water supply. Pumps come on one
at a time as the demand rises and drop off one at a time as it falls, the work is
shared by run hours, a pump that fails hands over to the next, and a small jockey
pump can carry the low demand on its own.

Each pump keeps its own motor block, mixed freely: UT_MOTOR for a
contactor or soft starter (fixed speed), UT_MOTOR_VSD for a drive.
The cascade takes the array of the pumps' motor records, like
UT_DUTY; the array size is the number of pumps. Every VSD the group runs
gets the same speed; fixed-speed pumps run flat out. The control loop inside is a
UT_SPEED_CTRL (its record is Data.ctrl), so the pipe fill,
sleep / wake, overpressure, burst-pipe, hunting and failed-sensor handling are the same
as on a single pump.

Pins

Record UT_PUMP_CASCADE_DATA

Staging

Rotation

Protection and the loop

ctrl.control chooses what the shared speed follows, as on
UT_SPEED_CTRL: the PID on
the header pressure Pv (UT_SC_CTRL_PV, the default), the PID on the Flow pin
(UT_SC_CTRL_FLOW, setpoints ctrl.flowSp / flowSpLow / flowSpHigh), or a fixed
speed (UT_SC_CTRL_FIXED, ctrl.fixedSpeed / fixedSpeedLow / fixedSpeedHigh).
ctrl.preset picks NORMAL, LOW or HIGH: for example ctrl.spLow for a travelling
irrigator working near the station. ctrl.highPv always watches Pv. The value
under control is ctrl.pv.

Stopping

HMI commands (act once, cleared by the block)

Status fields

Status

statusCode, faultId and statusText say the one main thing the group is
doing, or what holds it back. The most important reason wins: configuration > fault >
held / waiting > warning > running > idle. Where the loop's own status is the main
thing (its settings, its trips, sleep, Enable cycling, its warnings, pipe fill,
boost, flow limit, fallback) the loop's status and its fault (ctrl.statusCode, see
UT_SPEED_CTRL) are shown, with the loop's timeLeft.
Enabled with no pump running or starting (a called pump's run command out), it always
shows a held, fault or configuration status; UT_ST_STARTING shows over a warning.
The pump a status is about is statusUnit (an array index); the counts are
runningCount, calledCount and availableCount, the speed speed, and the time
left timeLeft. The text is rebuilt only when the status or the fault changes. The
numbers are in conventions.

Fields in each pump's motor record (UT_MOTOR_DATA)

capacity and jockey sit in the motor record so they travel with the pump: any
number of pumps, any array bounds, nothing to keep in step in a second array. They
cost a REAL and a BOOL per motor, and a motor that is not in a cascade ignores them.

How it works

Every arrangement

• Enable starts the loop; its Run starts the group with one pump. A pump is
  available when it is in Auto and ready (healthy, interlock and permissive made, not
  in its restart delay). Hand, Off, OOS and faulted pumps are skipped.
• One start at a time. Nothing is called while a called pump is not yet running.
  Stage delays count from the last start or stop command, so a pump that waited for
  its turn never starts in the same breath as the next one.
• Failover. A pump that trips or leaves Auto is released at once and the next one
  is called. A called pump not running failoverDelay after its run command is
  skipped (until it leaves Auto or faults and comes back, or the group next starts
  from none; skip memory for the first 32 pumps) and the next one is called. A pump
  in its restart delay is not ready, so it is never taken for a failed start.
• maxRunning counts pumps running in Hand. A pump put in Hand while the group is at
  the limit makes the group release one of its own.
• Stops. Any trip (overpressure TRIP, burst, high flow, a failed sensor with
  STOP, fill timeout) or a loop setting that runs nothing stops every pump at once: a
  fault never leaves a pump running against a closed system. Enable FALSE or sleep
  stops every pump at once too with stopMode ALL_AT_ONCE (the default). With
  UT_PC_STOP_STAGED the called VSDs go to ctrl.minSpeed and the pumps stop one at
  a time: the first at once, then one every stopStep, fixed-speed pumps first, then
  the jockey (stopping, status UT_ST_STOPPING). A trip during a staged stop stops the rest at
  once. Enable back during a staged stop keeps the pumps still running and carries
  on from them.
• Overpressure WARN holds the speed at the minimum and drops a pump each
  destageDelay while it lasts (never the last one; TRIP is the hard limit).
• Failed sensor. STOP: everything stops (fault). FALLBACK: one pump (a VSD if one is
  running) at ctrl.fallbackSpeed, the others stop. HOLD: the pumps and the speed stay
  as they are. A hunting trip keeps the pumps and runs at the fallback speed.
• Burst. ctrl.lowPvAtMax (at full speed and Pv still below half the setpoint)
  waits while another pump can still be added: the next pump is the answer first. With
  every pump in and the pressure still low, it trips. highFlow trips on the flow.
• Pipe fill (ctrl.pipeFill) runs with one duty pump (a VSD if available), never
  the jockey; staging starts when the fill is done.
• Sleep. The loop's sleep (low speed or low flow, then boost, then sleep) stops every
  pump; a pressure drop wakes the group with one pump (the jockey first).
• Power cut. Only the rotation's next pump in turn is kept (saved at once when it
  changes, that is when a pump is started; not for FIXED), so after frequent power cuts
  the first pump does not always lead. The run hours for HOURS (each pump's
  grpRunTime) start at 0, also when the motor records are RETAIN (equal hours go
  by the kept turn), every grpRun starts cleared, nothing is called on the first
  scan, and the pumps start again one at a time. The motors keep their own modes and
  restart delays.
• Manual speed. ctrl.cmdManual runs the called pumps at ctrl.manualSpeed, with
  the loop's protections still acting (overpressure, burst at the top speed); no pump
  is added or dropped until ctrl.cmdAuto.
• Each pump's own protection. The cascade sees only what a pump's motor record
  says: a pump whose motor trips (overload, no feedback, a drive fault) is no longer
  ready, so the group releases it and calls the next. A pump's hydraulic checks
  (dry run, prime, seal leak, a pump's own pressure or flow switches) live in its
  UT_PUMP, which has no group link to the cascade: wire
  UT_PUMP.Healthy to the motor block's Interlock, so a pump that fails a hydraulic
  check holds its motor off, reads not ready and is replaced. Without that wire a pump
  running dry stays called.

1. All pumps on VSDs

Every running pump gets the same speed from the loop. A pump is added when the speed
is at its maximum and Pv is still short of sp by more than ctrl.atSpBand for
stageDelay. One is dropped at the minimum speed, or, with dropSpeed set, when the
speed stays below dropSpeed for destageDelay. Set dropSpeed a few % below the
speed the pumps settle at just after one is added (that gap is the hysteresis). With a
lot of static head that speed differs from stage to stage: use FLOW or PER_PUMP
staging there.

2. One VSD plus fixed-speed pumps

The VSD starts first (the first pump is always a VSD when one is available) and trims.
A fixed pump is added when the VSD is at full speed and still short, and dropped first
when the VSD is at its minimum (or below dropSpeed): the VSD is the last to go. If the
VSD is lost, the fixed pumps carry on on the pressure bands (arrangement 3).

3. All fixed-speed

No speed: pumps are added when Pv stays addBand below sp for stageDelay and dropped
when it stays dropBand above sp for destageDelay. Make the bands wider than the
pressure step one pump makes, or the set will cycle (the delays only slow it).

4. Mixed sizes and a jockey

Give each pump its capacity. With FLOW staging the running capacity is the sum of the
pumps running, so a small and a large pump count for what they are. Mark the small
pump jockey := TRUE: it starts first and runs alone. When it cannot keep up (Flow
above addPct % of its capacity, or the pressure short on the PV rule) a duty pump
starts, and the jockey stops once the duty pump runs. When one duty pump is left and
the demand falls (Flow below dropPct % of the jockey's capacity, or the PV drop rule
when its capacity is 0), the jockey starts again and the duty pump stops once it
runs. A jockey that has to hand over on pressure while its flow is below its capacity
is not doing its job (air-locked, worn): it is skipped until the group next starts.
Several pumps may be jockeys: they rotate among themselves, one at a time.

Staging criteria

FLOW and PER_PUMP also add a pump on the PV rule: the pressure is never left short
while a pump is free. If that happens, the flow settings are wrong (a capacity too
high, bepMax too high), so the group warns (pvStaging, bit 11) and stages on the
pressure until it next starts from none. They fall back to PV with a warning while the
flow meter is bad (flowBad, bit 9), or while their settings are not usable (a duty
pump with no capacity, bepMax not above bepMin: wrnConfig).

Rotation (even wear)

Equal run hours is the answer to "start at random so one pump doesn't do all the
work": the pump with the fewest hours always starts next. Run hours are counted inside
the block (first 32 pumps) and start again at 0 after a power cut (equal hours: the
next in turn, which is kept). A swap (HOURS,
INTERVAL, Rotate, cmdRotate) is between pumps of the same kind (VSD for VSD, fixed
for fixed, jockey for jockey), waits while a pump is to be added or dropped, starts the
new pump first and stops the old one once it runs; at maxRunning the old one stops
first. In arrangement 2 the VSD runs whenever the group runs (it is the trim pump).

Wiring

The cascade before the motors, each in its own unconditional rung. AutoCmd must be
wired (the editor checks it) but is not used while the group owns the motor.

All on VSDs (arrangement 1)

VAR Pumps : ARRAY[1..6] OF UT_MOTOR_DATA; Booster : UT_PUMP_CASCADE; Cfg : UT_PUMP_CASCADE_DATA;
    P : ARRAY[1..6] OF UT_MOTOR_VSD; PV : ARRAY[1..6] OF UT_MOTOR_VSD_DATA; END_VAR
Cfg.ctrl.sp := 5.0;                       (* bar *)
Cfg.ctrl.minSpeed := 45.0;
Cfg.dropSpeed := 70.0;
Booster(Enable := SystemOn, Pv := Header.Value, PvGood := Header.Good, Units := Pumps, Data := Cfg);
P[1](AutoCmd := FALSE, Feedback := P1_Running, DriveReady := P1_Ready, DriveFault := P1_Fault,
     Data := Pumps[1], Vsd := PV[1]);
P1_RunRelay := P[1].Run;
P1_SpeedAO := P[1].SpeedRefRaw;           (* every drive gets the same reference *)
(* ... P[2] to P[6] the same ... *)

One VSD plus contactors and soft starters (arrangement 2)

P1(AutoCmd := FALSE, Feedback := VSD1_Running, DriveFault := VSD1_Fault, Data := Pumps[1],
   Vsd := P1Vsd);                                                                           (* UT_MOTOR_VSD *)
P2(AutoCmd := FALSE, Feedback := K2_Aux, Overload := NOT P2_OL_NC, Data := Pumps[2]);       (* UT_MOTOR, contactor *)
P3(AutoCmd := FALSE, Feedback := SS3_TopOfRamp, DriveFault := SS3_Fault, Data := Pumps[3]); (* UT_MOTOR, soft starter *)
K2_Coil := P2.Run;
SS3_Run := P3.Run;

Nothing to set for the trim pump: the block knows Pumps[1] is a VSD (isVsd) and
starts it first.

All fixed-speed (arrangement 3)

Cfg.addBand := 1.0;                       (* add below 4.0 bar *)
Cfg.dropBand := 1.5;                      (* drop above 6.5 bar *)
Cfg.ctrl.sleep.enable := TRUE;
Cfg.ctrl.sleep.flow := 5.0;               (* sleep below 5 m3/h *)
Booster(Enable := SystemOn, Pv := Header.Value, Flow := FlowMeter.Value, FlowGood := FlowMeter.Good,
        Units := Pumps, Data := Cfg);

Mixed sizes with a jockey (arrangement 4)

Pumps[1].jockey := TRUE;                  (* the small pump *)
Pumps[1].capacity := 12.0;                (* m3/h at the setpoint pressure *)
FOR k := 2 TO 6 DO Pumps[k].capacity := 80.0; END_FOR;
Cfg.stageBy := UT_PC_STAGE_FLOW;
Booster(Enable := SystemOn, Pv := Header.Value, Flow := FlowMeter.Value, FlowGood := FlowMeter.Good,
        Units := Pumps, Data := Cfg);

Invalid settings

• Runs nothing (Fault, configBad, bit 0): the loop's own (ctrl.sp 0, not a
  number or infinite, ctrl.minSpeed above ctrl.maxSpeed and the rest listed in
  UT_SPEED_CTRL).
• Warning, safe value used (wrnConfig, bit 10, Warning): stageDelay,
  destageDelay or failoverDelay negative → T#10s / T#20s / T#10s; addBand or
  dropBand negative, not a number or infinite → 0.3; dropSpeed outside 0..100 or not a
  number → 0 (the minimum speed only); addPct / dropPct not in 0 < dropPct < addPct ≤
  100 → 90 / 75; maxRunning negative → 1 (the safe side); an unknown rotation → HOURS,
  an unknown stageBy → PV; FIXED with fixedLead not a pump → the first; hoursDiff or
  rotateInterval negative → 0 (no swap); stopStep negative → T#3s; an unknown
  stopMode → all at once; PER_PUMP with bepMax not above bepMin →
  PV staging; FLOW with a duty pump's capacity 0 → PV staging; a capacity negative, not
  a number or infinite → 0; every pump a jockey (the jockey runs alone); highFlow with a
  bad setpoint, deadband or time. The loop's own warnings are its bit 7.
• Signals: Pv not a number or infinite (or PvGood FALSE) is a failed sensor (the
  loop's pvFail). Flow not a number or infinite (or FlowGood FALSE) while it is used
  gives flowBad (bit 9) and PV staging; highFlow, low-flow sleep and the flow limit
  then ignore it.