3-Motor Start Sequence PLC Exercise: Ladder Logic

Sequential motor starting is one of the most common control tasks in industrial automation. Conveyors, crushing circuits, ventilation systems, and process lines all start motors in a fixed order to protect electrical infrastructure and mechanical drivetrains. Writing this sequence cleanly in ladder logic, with proper interlocks and fault handling, is a skill every PLC programmer needs to have locked down. This exercise builds it from scratch in Studio 5000, but the pattern transfers directly to any platform.

What Is a Motor Start Sequence in a PLC?

A motor start sequence is a PLC program that commands two or more motors to start in a defined order, with timed delays and run-confirm interlocks between each step. Motor 1 starts first. Once its run-confirm feedback bit goes high and a delay expires, motor 2 starts. The same pattern repeats for motor 3. If any motor fails to confirm within a timeout window, the sequence halts and a fault is raised. No subsequent motor starts until the fault is cleared.

Exercise Specification

Before writing a single rung, define what you are building. Skipping this step is what turns a 30-minute exercise into a two-hour debugging session. Here is the spec for this exercise:

• Three motors: M1 (discharge conveyor), M2 (transfer conveyor), M3 (feed conveyor)
• Start sequence: M1 first, then M2 after a 5-second delay, then M3 after another 5-second delay
• Stop sequence: reverse order (M3 stops first, M2 stops 3 seconds later, M1 stops 3 seconds after M2)
• Each motor has a run-confirm feedback input (contactor auxiliary contact)
• If run-confirm does not arrive within 4 seconds of the output command, latch a fault and halt
• An E-stop clears all outputs immediately with no sequenced stop
• HMI provides Start, Stop, and individual fault-acknowledge bits

I/O Tag List

Internal tags you will also need: Seq_Running (BOOL), M1_FaultLatch, M2_FaultLatch, M3_FaultLatch (BOOL), M1_FaultAck, M2_FaultAck, M3_FaultAck (BOOL from HMI), and six TON timer tags: M1_StartTimeout, M2_StartDelay, M2_StartTimeout, M3_StartDelay, M3_StartTimeout, plus M2_StopDelay and M3_StopDelay for the reverse stop sequence. If you are new to timer instructions, the TON, TOF and TONR guide covers the exact instruction behaviour before you wire these up.

Building the Start Sequence Rungs

Rung 1: System Enable (Seq_Running)

The first rung latches the sequence active. A seal-in contact on Seq_Running holds it on after the momentary start button releases. The Stop command and any fault latch break the rung. This is the same pattern covered in the XIC vs XIO contact explanation, and it is the correct way to handle momentary pushbuttons.

How the Logic Actually Works

Walk through the start path first. When HMI_StartCmd pulses true with no faults active, Seq_Running latches on. The next rung immediately sets M1_Out. The timeout timer M1_StartTimeout starts ticking the moment M1_Out is on and M1_RunFB is still off. If the contactor closes within 4 seconds, M1_RunFB goes true, the timer rung goes false, and the timer stops without reaching DN. No fault. The delay timer M2_StartDelay then starts, gated by M1_Out AND M1_RunFB. After 5 seconds, M2_Out latches on and the same pattern repeats for motor 2, then motor 3.

The fault path is what separates a production program from a textbook example. If M1_RunFB never arrives and M1_StartTimeout.DN goes true, a one-shot (OSR) fires exactly once and latches M1_FaultLatch. That latch immediately breaks the Seq_Running enabling rung, so no further motors can start. The operator has to acknowledge the fault from the HMI (with the machine stopped) before the latch clears. This one-shot pattern is important: without it, the fault latch would continuously try to set and clear on every scan. The OSR and edge detection approach is worth reviewing if this is new to you.

The Reverse Stop Sequence

A clean stop matters as much as a clean start. When HMI_StopCmd fires, M3_Out is immediately unlatched (feed conveyor stops, no more material entering the line). M2_StopDelay starts timing. After 3 seconds, M2_Out unlatches. M3_StopDelay then starts, and after another 3 seconds M1_Out unlatches. The discharge conveyor runs last, clearing whatever is still on the belt. This is exactly the same principle used in the pump station exercise, just applied to a conveyor train instead of a wet well.

The E-stop path is separate and unconditional. A single rung with XIO(Estop_Active) fires three OTU instructions in one scan. No delay, no sequence. Safety hardware handles the physical disconnection; the PLC just mirrors that state in software immediately. For more on how the E-stop circuit itself is wired, see emergency stop circuit wiring categories.

Common Mistakes in Motor Sequence Logic

• Using OTE instead of OTL/OTU for motor outputs: the output drops for one scan whenever a seal-in rung momentarily goes false, which can cause contactors to chatter.
• Forgetting to reset the delay timers when the sequence stops: if you restart quickly, the delay timer still has its accumulated value and M2 or M3 may start instantly on the next run.
• Setting run-confirm timeout too short: 4 seconds is fine for a direct-on-line motor under 5.5 kW, but a larger motor through a star-delta starter may need 8 to 12 seconds to fully confirm.
• Not including any fault in the Seq_Running guard: if M2 faults and M1 is still running, you need to decide whether M1 should coast or stop. Feeding Seq_Running through all fault latches forces a deliberate choice.
• Wiring a normally-closed auxiliary contact as the run-confirm: if the contact wires break, the PLC sees false run-confirm permanently, masking real faults. Use NO auxiliary contacts for run-confirm and let the timeout catch open-circuit failures.

Extending the Exercise

Once the base sequence works, add these layers to make it production-grade:

1. Add a CTU counter that counts successful start cycles. After 500 cycles, set a maintenance-due bit. See PLC counter instructions for the CTU setup.
2. Add an HMI faceplate showing each motor's state: stopped, starting, running, faulted. The HMI tag linking guide shows how to map these bits correctly.
3. Replace the fixed 5-second inter-motor delay with an HMI-adjustable DINT parameter loaded from a recipe. This is the same indexed recipe pattern used in the bottle filling project.
4. Add a 'jog' mode that allows individual motor starts without the sequence, gated by a key switch input so operators cannot accidentally jog a motor mid-production.
5. Test the fault path deliberately: with the program running in simulation (see how to simulate ladder logic without a PLC), force M2_RunFB to stay false and confirm the fault latches, M3 never starts, and the ack cycle works correctly.

Translating This to Siemens TIA Portal

The structure maps cleanly to S7-1200 or S7-1500. Replace OTL/OTU with Set/Reset coils (S and R). Replace Rockwell TON with the IEC TON function block from the standard library. Tag names follow the TIA Portal convention (e.g., M1_StartTimeout.Q instead of .DN). If you are new to TIA Portal timers, S7-1200 timers in TIA Portal covers the exact block interface. The fault latch OSR pattern works the same way using a P_TRIG coil instead of an OSR instruction. Store the fault bits in a Global DB for clean HMI access, as shown in the S7-1200 Global vs Instance DB guide.

Troubleshooting the Sequence Online

Once the program is downloaded, use online monitoring to step through the sequence in real time. Watch the timer accumulated values climb and confirm each DN bit fires at the right moment. If M2_StartDelay never starts timing, check that M1_RunFB is actually going true: force the input in software (with the machine safe and isolated) and confirm the rung logic. The PLC troubleshooting with online monitoring guide has a systematic method for exactly this kind of step-by-step verification. If a physical input is suspect, how to test a PLC input with a multimeter will confirm whether the signal is reaching the module at all.

What to Read Next

The motor start sequence is a core building block. From here, take on the PLC pump station exercise which adds duty/standby alternation and high-level interlocks to a similar timed structure. For a more complex sequential machine, the PLC bottle filling machine project introduces step-based state control that scales to larger systems. And if you want to sharpen your troubleshooting skills on sequences like this one, work through the PLC troubleshooting interview questions to see how faults in sequential logic are diagnosed under pressure.