UT_DUTY — Duty / assist / standby for any group of motors

Shares a demand ("I need N units running") across a group of motor-driven units:
fans, compressors, blowers, heater banks, cooling towers, or pumps when you
don't need UT_PUMP_STATION's level logic. It handles rotation,
failover, staggered starts and exercise of idle units.

The group is an array of the units' motor records. Each UT_MOTOR* block uses
one element as its Data, and its Auto command comes from the group automatically
(grpActive / grpRun). A unit is available when it is in Auto and ready (healthy,
interlock and permissive made).

Pins

Record UT_DUTY_DATA

Each unit's rank is in Units[i].grpRank (1 = lead). Run time per unit for
UT_ROT_HOURS is counted by the group in Units[i].grpRunTime, for every unit.

Status

statusCode and statusText say the one main thing the group is doing, or what
holds it back. The group has no faults of its own: each unit's motor status says why
it tripped. The most important reason wins: held / waiting > running > idle. With
Required above 0 and no unit running or starting (its run command out), the status
is always a held one. The unit a status is about is statusUnit (an array index),
the time left is in timeLeft, and the counts are runningCount, calledCount and
availableCount. The text is rebuilt only when the status changes. The numbers are
in conventions.

How it works

• Units are called one at a time, best rank first, at least stageDelay apart and
  only once the last one called is running. Extra units are released one at a time,
  worst rank first, at least destageDelay apart.
• A unit that trips or leaves Auto (Hand, Off, OOS) is released at once and replaced.
  A called unit that does not run within failoverDelay is skipped until it has been
  unavailable or the group next starts from none (skip memory: first 32 units). A
  unit coming back is not swapped in while another is doing the job. A unit that is
  only waiting out its own restartDelay (just stopped, or after a power cut) has not
  failed: it hands over to another unit if there is one, and is called again once no
  other is left, so a lone compressor restarts when its delay ends.
• Exercise: one idle, available unit at a time (any unit in the array) whose motor has
  been stopped for exerciseInterval (its offTime) runs exerciseTime. It does not count toward Required, only
  touches units in Auto, and counts as a start for stageDelay. nextExerciseIn
  shows when the next one is due.
• rotateIn counts down to the next INTERVAL rotation and starts again at each
  rotation (also one by Rotate / cmdRotate).
• Power cut: only the lead is kept (saved at once when it changes, which is
  rare), so the rotation carries on instead of the first unit always leading after
  frequent power cuts. Run times for HOURS (grpRunTime) start again at 0, also when the
  motor records are RETAIN (equal times go in turn from the kept lead), and so does
  the exercise timing (the motors' offTime counts from power-up). Every grpRun starts cleared
  and units start one at a time again. The motors keep their own modes. A motor ignores grpRun on its first scan,
  so a retained record never starts it, and it clears grpActive each scan: if UT_DUTY stops being called,
  its motors go back to their own AutoCmd on the next scan. Call order does not
  matter (after the motors, they follow one scan later).

Using it

VAR Fans : ARRAY[1..3] OF UT_MOTOR_DATA; END_VAR
Duty(Required := FansNeeded, Units := Fans, Data := DutyCfg);
F1(AutoCmd := FALSE, Feedback := F1_Aux, Overload := F1_OL, Data := Fans[1]);
(* … F2, F3 … *)

AutoCmd must be wired (the editor checks it) but is not used while the group owns
the motor.