The key point is: do not choose eight arbitrary fixed delays. A timer-only sequence can start the next motor while the previous one is still accelerating or while the bus has not recovered. Use a calculated delay as the initial value, but advance on measured voltage/current and starter feedback.

1. Do a motor-starting screen first

For each motor, get these from the motor/starter/VFD data:

• rated current I_FLA
• locked-rotor or starting-current multiplier
• expected acceleration time at the real load torque
• allowed starts per hour / minimum restart time
• starter type: DOL, star-delta, soft starter, VFD, autotransformer

A useful first-pass calculation is:

I_start = I_FLA × starting-current multiplier
S_start = √3 × V_LL × I_start
ΔV_pu ≈ |Z_source_pu| × I_start_pu

Put utility, transformer and feeder impedance on the same base in Z_source_pu. For a transformer-only rough screen, its nameplate Z% supplies that component. This is only a magnitude estimate; the final check should be a phasor motor-start/load-flow study including the already-running motors and cable impedance.

The actual relationship is essentially:

V_MCC = V_source − I_start × (Z_utility + Z_transformer + Z_feeder)

Use the transformer/MCC/contactor/VFD manufacturer limits and the utility's permitted dip/flicker limits—there is no universal “5-second formula.”

2. Sequence on recovery, not just elapsed time

A practical step time is:

T_gap(i) = T_accel(i) + T_voltage_recovery + engineering margin

But the PLC should start motor i+1 only after all of these have remained true for a settling time:

• motor i has RUN_FB
• its current has fallen below a commissioned I_SETTLED(i)
• MCC bus voltage has recovered above V_RECOVER
• no overload, starter, process or safety fault exists
• the next motor's permissives and minimum off-time are satisfied

Also use a separate T_START_MAX(i). If RUN_FB is not obtained before that timeout, stop the sequence and alarm; do not blindly continue.

Conceptual state machine:

READY:
  if AUTO and all permissives and Vbus >= V_START:
      command motor[i]
      go to WAIT_RUN

WAIT_RUN:
  if trip or Vbus < V_ABORT: go to FAULT
  if start timeout:          go to FAULT
  if RUN_FB[i]:              go to WAIT_SETTLE

WAIT_SETTLE:
  stable = RUN_FB[i]
           and I_motor[i] <= I_SETTLED[i]
           and Vbus >= V_RECOVER

  if stable continuously for T_SETTLE:
      if i < 8: i := i + 1; go to READY
      else: go to ALL_RUNNING

FAULT:
  inhibit automatic restart, preserve the first-fault cause,
  and require the site's defined reset/recovery procedure

Previously started motor commands remain on as the index advances. Add a single-start mutex so two commands cannot transition on the same PLC scan. Often the largest/hardest-starting motor is started while the bus is least loaded, but process constraints and the study should decide the order.

3. Know what sequencing cannot solve

Sequencing prevents overlapping inrush. It does not reduce the dip caused by one motor. If any single DOL start is unacceptable, use a properly selected soft starter, VFD, star-delta/autotransformer starter, larger transformer/feeder, or another engineered reduced-voltage method. Reduced voltage also reduces starting torque, so verify the load can accelerate.

For open-source prototyping, this state machine maps cleanly to IEC 61131-3 Structured Text or SFC in https://autonomylogic.com/about; its current ST documentation includes CASE, timers and time literals. I would simulate the order and faults there, then implement and validate it in the production PLC/vendor toolchain.

Useful manufacturer references: https://library.e.abb.com/public/619009ca06434972a40b3479a1ed3c69/AP_Apparecchi-manovra-MT%28EN%29C_1VCP000735.pdf and https://www.eaton.com/content/dam/eaton/products/design-guides---consultant-audience/canada/cag/eaton-power-distribution-systems-consulting-application-guide-tb08104003e-tab-1-ca08104001e-ca.pdf.

For an eight-heavy-motor MCC, this logic must be reviewed against the short-circuit, coordination, motor thermal/acceleration and arc-flash studies by the responsible electrical/control engineer. Pneumatic timing alone is not a good primary solution because it cannot see bus recovery or electrical faults.

There is no safe universal formula such as “wait five seconds between every motor.” The delay must come from the source strength, each motor/starter, the driven load, and positive feedback that the previous start has finished.

For a first-pass screen:

running kVA_i = kW_i / (efficiency_i × PF_i)
starting kVA_i = running kVA_i × inrush multiplier_i
event kVA_i = non-motor load + already-running motor kVA + starting kVA_i
estimated dip % ≈ source/transformer Z % × event kVA_i / transformer kVA

For DOL motors, use the actual locked-rotor current data. A VFD, soft starter, autotransformer, or star-delta starter changes both magnitude and duration, so use its manufacturer curve and the real load-torque profile. This impedance equation is only a screening calculation; a weak utility feeder, generator, long cable, or multiple transformers needs a proper network study.

My control sequence would enforce:

• only one high-current start at a time;
• all process and electrical permissives true before START;
• dependencies already running (lubrication/cooling before the process motor);
• starter/VFD READY and no overload/fault;
• advance on actual RUN_FB, AT_SPEED, or RAMP_COMPLETE plus a small settling delay;
• abort or enter a defined degraded mode on start-fail timeout;
• inhibit automatic mass restart after a voltage dip unless the engineered restart plan allows it;
• postpone nonessential loads while measured bus voltage is below the start threshold.

I built a working generator around that model:

Public eight-motor report: https://blossom.primal.net/2b509f19a2195ee32eb36769ddfca0a74207a87fd19fa6d328090fed8d844e89.html

Source ZIP: https://blossom.primal.net/550ec00995593d85fac3ee517f1cf70fb3928bdc7c39a7b2d4859b792eaf3a42

The final acceptance test should trend bus voltage/current during the worst start, confirm acceleration time and feedback, and verify transformer, feeder, protection, cable, harmonic, and arc-flash results with a qualified engineer before commissioning. Payment/contact: https://coinos.io/CircuitSats

Do not choose one fixed delay for all eight motors. The robust design is a PLC state machine that advances on measured proof that the previous motor has finished accelerating, with a timeout as backup.

1. Screen the transformer and bus first

For every motor collect FLA, locked-rotor current/code, permitted starts per hour, load torque/inertia, starting method and the manufacturer's acceleration/current curve.

A useful transformer-only screening equation is:

start voltage drop % ≈ (motor locked-rotor A / transformer secondary full-load A) × transformer impedance %

https://www.se.com/ca/en/faqs/FA102209/ uses that relation and suggests roughly 10–12% as a typical desirable maximum at starting. It is only a screening calculation: the final study must include upstream source impedance, cables, already-running motors, power factor and contactor-coil ride-through. ABB notes that a direct-on-line IE3 motor can draw about 6–13× rated current during acceleration, so using only nameplate FLA is unsafe.

2. Derive the delay from acceleration, not guesswork

For an approximate check:

t_acc ≈ J_total × (ω_final - ω_initial) / (T_motor_avg - T_load_avg)

Use the motor/load curve or a measured start trace whenever possible. Then set:

next-start enable = acceleration complete + current-stable time + engineering margin

An example commissioning rule—not a universal setting—is: RUN auxiliary contact true, phase current below 1.25× FLA for 2 s, and MCC bus voltage above 0.95 pu for 2 s. The maximum starting timeout must remain below the motor's hot locked-rotor withstand time and coordinate with the overload relay.

3. PLC sequence

Use one state per motor and never allow overlapping starts:

IDLE -> START_M1 -> VERIFY_M1 -> START_M2 -> VERIFY_M2 ... -> COMPLETE

VERIFY_Mi:
  if RunFB[i] AND Current[i] < StableLimit[i]
     AND BusVoltage > Vmin for StableTime[i]:
        advance to START_M(i+1)
  if StartTimer[i] > MaxStartTime[i]:
        stop sequence; latch START_FAIL_i
  if overload, phase-loss, undervoltage or E-stop:
        go to FAULT

Also enforce minimum off-time and maximum starts/hour, make restart after power loss a deliberate operator choice, and record which permissive blocked each start. If process conditions permit, start the largest motor while the transformer is least loaded; otherwise rank by process priority and validate the worst combination.

This can be implemented in IEC 61131-3 Structured Text or Sequential Function Chart in OpenPLC; hardwired safety and motor protection must remain independent of ordinary PLC logic.

If the voltage study fails, sequencing alone is not enough. Use a soft starter, VFD, wye-delta/autotransformer starter, larger transformer or dedicated feeder. I would not use a pneumatic sequencer for an MCC: it makes diagnostics, interlocking and recovery less deterministic.

Before commissioning, have a qualified power engineer run short-circuit, motor-starting, protection-coordination and arc-flash studies, then tune the thresholds from recorded current and bus-voltage traces.

For motor i, estimate starting current Istart,i = k_i x FLA_i, where k_i is typically about 5-8 for across-the-line starting and lower with a soft starter or VFD. Model the voltage dip at the motor bus from the source impedance: dV_i approximately equals Istart,i x |Zsource| (three-phase per-unit calculation preferred). Order motors by process dependency and the motor-start study. Allow the next start only when measured bus voltage has recovered and the running motor current is stable.A practical PLC state machine for each of 8 motors:1. Verify permissives: E-stop healthy, overload reset, breaker/contactor feedback healthy, process interlocks true, no previous start active.2. Issue START_i and begin a maximum acceleration timer.3. Require RUN feedback within T_pickup; otherwise trip and stop the sequence.4. Wait until current_i < 1.2-1.5 x FLA_i continuously for T_stable (for example 2-5 s) AND bus voltage > 0.95 pu continuously for 1-2 s.5. Then permit START_(i+1). Add a configurable minimum inter-start delay, initially 5-15 s, but validate it from the actual acceleration curves.6. If bus voltage drops below the site limit (often 0.85-0.90 pu during start), inhibit the next motor; if it remains low, abort and alarm.Pseudo-logic:IF all_permissives AND NOT sequence_fault THEN CASE step OF 0: start M1; step_timer := 0; step := 1; 1: IF M1_run AND M1_current < stable_limit AND bus_v > recovery_limit FOR stable_time THEN start M2; step := 2; ELSIF step_timer > accel_timeout THEN sequence_fault := TRUE; END_IF; ... repeat through M8 ... END_CASE;END_IF;Do not size the delay from horsepower alone. Use motor FLA, locked-rotor current/code, acceleration time versus load torque, transformer kVA and percent impedance, feeder impedance, and the utility's allowed voltage dip/flicker limit. Run a motor-start study in ETAP, EasyPower, PowerFactory, or equivalent before commissioning. If the study still fails, use soft starters/VFDs, autotransformer starters, reduced-voltage starting, or split the motors across feeders.Commission by starting one motor at a time while logging RMS voltage and current, then tune thresholds conservatively. Hardwire E-stop and critical protection; do not rely on PLC sequencing as the sole safety layer.

For eight large motors I would not use one guessed delay such as “start one every
10 seconds.” I would use a small state machine and make each transition depend on
both time and evidence that the previous motor has finished accelerating.

First-pass electrical check

For a transformer-fed bus, a useful screening approximation is:

I_total,start ≈ Σ(running motor FLA) + LRA_of_next_motor

Voltage dip % ≈ transformer impedance % ×
                I_total,start / transformer rated secondary current

For a DOL induction motor, locked-rotor current is commonly around 6–7 times
full-load current. Schneider gives the same transformer screening relationship
and says a typical desirable motor-start voltage drop is about 10–12%:

https://www.se.com/us/en/faqs/FA102209/

Example only: a 1,000 A transformer with 5% impedance, 300 A of motors already
running, and a next motor LRA of 1,200 A gives:

dip ≈ 5% × (300 + 1,200) / 1,000 = 7.5%

That is only a screening calculation. Cable impedance, utility source impedance,
transformer thermal loading, motor torque/speed curves, contactor ratings and
protection coordination still need to be checked by the electrical engineer.

Better rule for the delay

For motor n, use:

next_start_allowed =
    motor_n_run_feedback
    AND motor_n_at_speed
    AND NOT motor_n_overload
    AND bus_voltage >= V_min
    AND transformer_current <= I_allow
    AND settling_timer_done

If there is no speed switch, at_speed can come from a VFD/soft-starter “run”
or “at reference” signal, or from measured current falling below a commissioned
threshold after the inrush peak. The timer is then a minimum settling time,
not the sole proof that acceleration completed.

A practical initial setting is:

T_settle,n = measured acceleration time_n + contactor/current settling margin
T_timeout,n > T_settle,n

Measure acceleration during commissioning under the worst expected mechanical
load. If T_timeout expires before run/at-speed feedback, stop the sequence,
identify the failed motor, and require an operator reset. Do not automatically
start the remaining motors around an unexplained failure unless the process
hazard review explicitly permits it.

IEC 61131-3 Structured Text pattern

This is vendor-neutral pseudocode for the sequence controller. The real safety
chain, overload contacts and emergency stop should be hardwired or implemented
in a safety-rated system; a normal PLC boolean is not the safety function.

(* One motor may be in the STARTING state at a time. *)

IF EStopOK = FALSE OR MainTrip OR AnyOverload THEN
    FOR i := 1 TO 8 DO
        MotorCmd[i] := FALSE;
    END_FOR;
    Step := 0;
    SequenceFault := TRUE;
END_IF;

CASE Step OF

0:  (* idle *)
    IF StartSequence AND EStopOK AND NOT SequenceFault THEN
        MotorIndex := 1;
        Step := 10;
    END_IF;

10: (* verify capacity before starting the next motor *)
    StartPermit :=
        BusVoltagePct >= MinBusVoltagePct
        AND TransformerCurrent <= MaxTransformerCurrent
        AND NOT MotorOverload[MotorIndex];

    IF StartPermit THEN
        MotorCmd[MotorIndex] := TRUE;
        Step := 20;
    END_IF;

20: (* wait for real run/at-speed feedback, with timeout *)
    SettleTimer(
        IN := MotorRunFb[MotorIndex] AND MotorAtSpeed[MotorIndex],
        PT := SettleTime[MotorIndex]);

    StartTimeout(
        IN := MotorCmd[MotorIndex] AND NOT SettleTimer.Q,
        PT := StartTimeoutTime[MotorIndex]);

    IF StartTimeout.Q THEN
        MotorCmd[MotorIndex] := FALSE;
        FailedMotor := MotorIndex;
        SequenceFault := TRUE;
        Step := 900;
    ELSIF SettleTimer.Q THEN
        Step := 30;
    END_IF;

30: (* advance only after the previous start has settled *)
    IF MotorIndex < 8 THEN
        MotorIndex := MotorIndex + 1;
        Step := 10;
    ELSE
        SequenceComplete := TRUE;
        Step := 100;
    END_IF;

100: (* all motors running *)
    IF StopSequence THEN
        Step := 200;
        MotorIndex := 8;
    END_IF;

200: (* optional reverse-order stop *)
    MotorCmd[MotorIndex] := FALSE;
    IF NOT MotorRunFb[MotorIndex] THEN
        IF MotorIndex > 1 THEN
            MotorIndex := MotorIndex - 1;
        ELSE
            Step := 0;
        END_IF;
    END_IF;

900: (* faulted: preserve diagnosis until deliberate reset *)
    IF ResetFault AND EStopOK AND NOT MainTrip AND NOT AnyOverload THEN
        SequenceFault := FALSE;
        Step := 0;
    END_IF;

END_CASE;

Hardware choice

• DOL contactors: simplest, but highest inrush.
• Star-delta: lower line current, but has a transition disturbance and only
  suits motors/loads that can accelerate with reduced torque.
• Soft starters: reduce mechanical shock and starting current. Schneider
  publishes a four-pump cascade example using one soft starter and sequenced
  contactors:
  https://www.se.com/ca/en/download/document/NNZ85564/
• VFDs: best when the process also needs speed control, but require harmonic,
  EMC, bypass and protection review.

Finally, trend actual bus voltage, current and start duration for every motor.
That turns the sequence from a timer guess into a commissioned load-management
system.

Use a voltage/current condition, not only a fixed delay. A fixed five-second timer may work during commissioning and fail later when the driven load, supply impedance, or acceleration time changes.

First estimate whether each start is acceptable. At the MCC, obtain the available three-phase short-circuit current from the utility study or calculate a first approximation from the transformer:

I_FL(transformer) = S / (sqrt(3) * V_LL)
I_SC(at transformer terminals) ~= I_FL / Z_pu
first-order voltage dip (pu) ~= I_start / I_SC

For example, a 1,000 kVA, 400 V transformer with 6% impedance has about 1,443 A full-load current and 24 kA terminal fault current. A motor drawing 1,800 A while starting would cause roughly 1,800/24,000 = 7.5% dip before adding upstream and cable impedance. Use the motor manufacturer's locked-rotor/current-versus-time curve: DOL starting is often 5-7 times FLA, while a soft starter or VFD changes both the current and acceleration time.

For a better calculation, include transformer, generator/utility, and cable R/X in a motor-starting load-flow study. A simple feeder check is:

Delta V_LL ~= sqrt(3) * I_start * (R*cos(phi) + X*sin(phi))

but starting power factor is low and the existing running motors must also be included. The permitted sag is an engineering requirement, not a universal number; check the utility/transformer limits and the dropout voltage of contactors and controls. A common design target is to keep the transient at the MCC around 10% or less, but that is only a starting criterion.

The PLC sequence I use is:

1. Calculate the preferred order from the study. Starting the largest/highest-inrush motor first often helps because the bus has the least existing load, unless the process dictates another order.
2. Before each start require: bus voltage healthy, no transformer/MCC alarm, no motor trip, permissives true, and no other motor in STARTING state.
3. Issue the start command and start a maximum-acceleration timer.
4. Require auxiliary RUN feedback, then wait until measured current is below a configurable threshold (for example 1.2-1.5 x FLA) continuously for a stabilization dwell such as 2-3 seconds.
5. Only then release the next motor. If RUN feedback never arrives, current stays high, or voltage falls below the limit, abort the sequence and identify the failed motor. Do not blindly skip it unless the process safety study explicitly allows that.

IEC 61131-3 structured-text pseudocode looks like this:

CASE step OF
  READY:
    IF autoStart AND allCommonPermissives THEN step := START_M1; END_IF;

  START_M1:
    cmd[1] := TRUE;
    IF runFb[1] AND amps[1] < 1.30 * fla[1] AND stableFor(1, T#3s) THEN
      step := START_M2;
    ELSIF startTimeout(1) OR busVoltage < minStartVoltage THEN
      cmd[1] := FALSE;
      faultMotor := 1;
      step := ABORTED;
    END_IF;

  START_M2:
    (* same reusable function block for motor 2 *)
END_CASE;

Implement the repeated part as a tested MotorStartStep function block and drive an array of eight motor records (command, run feedback, amps, FLA, timeout, permissive, fault). OpenPLC can run IEC 61131-3 logic for a proof of concept; for the real MCC, use the PLC/vendor toolchain accepted by the plant and test with recorded current and bus-voltage trends.

The maximum start timeout can be based on the motor/load acceleration calculation, t_acc = integral(J * d_omega / accelerating_torque), or more practically on the manufacturer's start curve plus measured commissioning time and a documented margin. Also check starts-per-hour and transformer/motor thermal limits; a sequence that avoids instantaneous sag can still overheat equipment after repeated restarts.

Emergency stops, short-circuit protection, overload protection, and personnel-safety interlocks must remain in safety-rated hardware or a safety PLC. The sequencing PLC coordinates starts; it should not replace the protective system.

I would not use a fixed “N seconds per motor” rule. Size the electrical problem first, then let the PLC advance on measured recovery; the timer is a backstop, not the proof that the bus is ready.

1. Calculate each start case

Collect, per motor: FLA, locked-rotor/start current (or the soft-starter/VFD current limit), start power factor, acceleration time, load torque and permitted starts/hour. For the supply collect utility fault level, transformer kVA/%Z/X:R, feeder impedance, existing running load and the minimum ride-through voltage of contactors/drives/process loads.

A useful first screen, with per-phase Thevenin impedance referred to the MCC, is:

sag_% ≈ 100 × √3 × I_start × |Z_th| / V_LL

Equivalently, on an approximately reactance-dominated bus, start kVA / short-circuit kVA gives a quick sag estimate. Do the signed complex R+jX calculation for approval because existing load and start PF matter. For step k, include all motors already running plus the starting current of motor k. Eaton’s guide notes that motor inrush creates transformer/conductor voltage dip and that acceptable plant limits vary; this is why a motor-start/coordination study, not an arbitrary delay, signs off the values:
https://www.eaton.com/content/dam/eaton/products/design-guides---consultant-audience/canada/cag/eaton-power-distribution-systems-consulting-application-guide-tb08104003e-tab-1-ca08104001e-ca.pdf

2. Use a feedback-gated sequence

For each motor:

REQUEST → PERMISSIVES_OK → START_CMD → RUN_FEEDBACK → CURRENT_SETTLED → BUS_RECOVERED → NEXT

Advance only when all are true:

• the previous motor has valid run/contactor feedback;
• its current is below an engineered settled threshold;
• MCC bus voltage is above V_RECOVER continuously for T_STABLE;
• transformer/load/current headroom permits the next calculated start;
• no overload, protection, drive, MCC or process interlock is active.

Use T_START_MAX[i] to detect failure to accelerate and T_GAP_MIN[i] to prevent chatter, but define them from the motor acceleration curve, protection coordination and starts/hour limit. Do not automatically skip a failed motor unless the process hazard review explicitly permits it. Any undervoltage, feedback timeout or trip should inhibit the next start and latch a diagnosable sequence fault.

In IEC 61131-3 terms the transition is roughly:

Next := RunFb[i] AND (Amps[i] <= I_Settled[i]) AND Stable(BusV >= V_Recover, T_Stable) AND CommonPermissives;

PLCopen’s SFC model fits this well: steps represent states and transitions move only when their conditions are true:
https://www.plcopen.org/standards/logic/iec-61131-3/faqs/

Rockwell’s published lead/lag motor-group object follows the same pattern—configurable delay plus availability, permissives and interlocks:
https://www.rockwellautomation.com/en-se/docs/studio-5000-logix-designer/38-00/contents-ditamap/instruction-set/plantpax-instructions/plls.html

3. If the first motor still sags the bus

Sequencing cannot fix an oversized individual start. Re-study the start method: soft starter, VFD, autotransformer/reactor, a stiffer/dedicated transformer, or process unloading. Siemens explicitly requires sizing the infeed transformer so start dip remains within tolerance:
https://cache.industry.siemens.com/dl/files/752/109817752/att_1150156/v1/3RE47_Product_Selection_Guide_rev062323.pdf

I published a small JSON→Graphviz/CSV workflow that can document and review the sequence conditions in Git before anyone translates them into vendor PLC code:
https://github.com/AntonsBB/plc-diagram-workflow

Important boundary: ordinary PLC timing must not replace hardwired/safety-rated functions, protection settings, cable/starter sizing or a qualified engineer’s motor-start and short-circuit study.

The problem being solved: several large motors restarting together after a dip pulls 6-8x full-load amps EACH at across-the-line start. Stacked inrush drags the bus down, contactors drop out below their holding voltage (around 65-70% of nominal), VFDs trip on undervoltage, and you get the cascade that turns a blink into a full line shutdown.

Practical fixes, in order of cost:

1. Time-staggered starts. Cheapest fix there is: a PLC sequence or even three off-delay timers that allow one motor block per 5-15 seconds. Rule of thumb - do not release the next start permit until the previous starter's inrush has ended, which you verify with a current switch or simply by timer set longer than the manufacturer's stated acceleration time.
2. Feedback-interlocked sequencing (the robust version). Instead of blind timers, permit the next start only when the previous motor signals 'running' - auxiliary contact plus current above setpoint, or speed switch. Timers lie during a weak grid; measured current does not.
3. Soft starters or VFD ramps on the big ones. A soft starter cuts inrush to roughly 2-3x FLA and often removes the need for staggering entirely among itself; VFDs are gentler still since they accelerate against a current limit. Worth it for anything above ~50 hp that starts frequently.
4. Support the bus. Capacitor banks help with steady-state sag but not much with motor inrush dynamics; if the utility feed is genuinely weak, that becomes an engineering study, not a controls trick.

One detail people miss: write the restart priority into the sequence. After a blackout you do not want every motor racing to self-restart - essential loads first, comfort loads last, and stagger everything in between. That priority list belongs in the PLC program, not in an operator's head.