Motor Starter in Ladder Logic: Step-by-Step Tutorial

The motor starter circuit is arguably the most fundamental building block in industrial controls. Every controls engineer encounters it in their first week on the job, and every PLC program of meaningful complexity contains at least one variation. This tutorial walks through implementing a complete motor starter in ladder logic, from the basic seal-in circuit through forward/reverse control with full safety interlocks.

What a Motor Starter Circuit Does

A motor starter circuit provides controlled switching of an electric motor. Unlike a simple toggle switch, a motor starter implements three-wire control: the motor can be started with a momentary pushbutton, it latches itself on (the seal-in), and it can be stopped either intentionally via the stop button or automatically when a fault condition such as an overload is detected.

In hardwired relay logic, this is accomplished with a contactor whose auxiliary contact provides the seal-in path. In a PLC, we replicate this exact behavior in ladder logic using internal coils and contacts. The logic is identical in principle, but the PLC gives us far more flexibility to add conditions, timers, and interlocks without rewiring.

Components of the Motor Starter

• Start Pushbutton (NO) — A normally-open momentary contact. Pressing it closes the circuit momentarily to initiate the start sequence.
• Stop Pushbutton (NC) — A normally-closed momentary contact. Pressing it breaks the circuit, de-energizing the contactor and stopping the motor.
• Contactor (M) — The power switching device. When its coil is energized, it closes the main contacts that feed power to the motor.
• Overload Relay (OL) — A thermal or electronic device that opens a normally-closed contact when the motor draws excessive current for too long.
• Auxiliary Contact (M) — A normally-open contact on the contactor that closes when the contactor is energized. This provides the seal-in path.

The Classic 3-Wire Control Circuit

The term "3-wire control" refers to the three conductors required: one for the start signal, one for the stop signal, and one common return. The key characteristic is low-voltage protection (LVP). If power is lost and restored, the motor does not restart automatically. The operator must press the start button again. This is a critical safety feature in industrial environments.

The circuit works as follows: pressing the start button energizes the contactor coil. The contactor's auxiliary contact closes, creating a parallel path around the start button. When the operator releases the start button, current continues flowing through the auxiliary contact. Pressing stop (or an overload trip) breaks the only remaining current path, de-energizing the coil and dropping out all contacts including the seal-in.

Ladder Logic: Basic Seal-In Circuit

Here is the fundamental motor starter translated into ladder logic. The stop button is programmed as an XIC (examine if closed) instruction because the physical NC contact is mapped to a bit that is TRUE when the button is not pressed, and FALSE when pressed.

|                                                    |
|    Stop_PB      Start_PB       OL_NC        Motor  |
|---] [------+------] [------+---] [-----( )--------|
|            |               |                       |
|            |    Motor      |                       |
|            +------] [------+                       |
|                                                    |

In this rung:

• Stop_PB (XIC) — TRUE when the NC stop button is not pressed. Goes FALSE when the operator presses stop.
• Start_PB (XIC) — TRUE momentarily when the NO start button is pressed.
• Motor (auxiliary/seal-in contact, XIC) — TRUE when the motor output is already energized. This is the latch.
• OL_NC (XIC) — TRUE when the overload relay is healthy. Goes FALSE on an overload trip.
• Motor (OTE coil) — Energizes the motor contactor output.

How the Seal-In Works

When Start_PB is pressed and both Stop_PB and OL_NC are TRUE, the Motor coil energizes. On the next scan, the Motor contact in the parallel branch goes TRUE. Now even when Start_PB opens, current flows through the Motor contact branch. The motor remains running until either Stop_PB is pressed (opening the series NC path) or OL_NC trips.

Adding Overload Protection

The overload relay contact (OL_NC) is already in our basic circuit. In practice, you should also add logic to indicate the fault condition and require a manual reset:

|                                                    |
|    OL_NC                              OL_Fault     |
|---]/[-----------------------------------( )--------|
|                                                    |
|    OL_Fault      OL_Indicator                      |
|---] [-----------------------------------( )--------|
|                                                    |

The first rung uses an XIO (examine if open) instruction on OL_NC. When the overload trips, OL_NC goes FALSE, making the XIO instruction TRUE, which sets the OL_Fault bit. The second rung drives a fault indicator (HMI alarm, pilot light, etc.). You may also latch the fault bit so it persists even after the overload relay resets, requiring the operator to acknowledge the fault before restarting.

Adding Jogging Capability

A jog function allows the operator to run the motor only while holding the jog button. The motor must not seal in during a jog. This requires bypassing the seal-in contact when the jog button is active:

|                                                    |
|    Stop_PB      Start_PB    Jog_PB      Motor      |
|---] [------+------] [---+---]/[----+---( )---------|
|            |            |          |               |
|            |    Motor   |          |               |
|            +------] [---+          |               |
|            |                       |               |
|            +------] [---] [--------+               |
|                  Jog_PB   Jog_PB                   |
|                                                    |

Wait, that gets confusing. A cleaner implementation uses a separate approach:

Rung 1 - Seal-in (disabled during jog):
|                                                    |
|  Stop_PB    Start_PB    Jog_PB(NC)   OL    Run    |
|---] [---+----] [----+----] [--------] [---( )------|
|         |          |                               |
|         +---] [----+   (Run seal-in)               |
|             Run                                    |
|                                                    |

Rung 2 - Jog (no seal-in):
|                                                    |
|  Stop_PB    Jog_PB    OL          Jog_Out          |
|---] [--------] [------] [----------( )-------------|
|                                                    |

Rung 3 - Motor output:
|                                                    |
|     Run                            Motor           |
|--+--] [---+----------------------------( )---------|
|  |        |                                        |
|  +--] [---+                                        |
|   Jog_Out                                          |
|                                                    |

In Rung 1, the Jog_PB normally-closed contact prevents the seal-in circuit from engaging while the jog button is held. In Rung 2, the jog output energizes only while the button is held, with no seal-in branch. Rung 3 combines both paths to drive the physical motor output.

Forward/Reverse with Interlock

Reversing the direction of a three-phase motor requires swapping two of the three phase conductors. This is done with two contactors: one for forward (M_FWD) and one for reverse (M_REV). Energizing both simultaneously would cause a dead short, so electrical and programmatic interlocks are mandatory.

Rung 1 - Forward:
|                                                       |
|  Stop   Fwd_PB   Rev_Out(NC)   OL      Fwd_Out       |
|--] [--+--] [--+----]/[--------] [-------( )-----------|
|       |       |                                       |
|       +-] [---+  (Fwd_Out seal-in)                    |
|        Fwd_Out                                        |
|                                                       |

Rung 2 - Reverse:
|                                                       |
|  Stop   Rev_PB   Fwd_Out(NC)   OL      Rev_Out       |
|--] [--+--] [--+----]/[--------] [-------( )-----------|
|       |       |                                       |
|       +-] [---+  (Rev_Out seal-in)                    |
|        Rev_Out                                        |
|                                                       |

Rung 3 - Physical outputs:
|                                                       |
|  Fwd_Out                            Motor_Forward     |
|---] [--------------------------------------( )--------|
|                                                       |
|  Rev_Out                            Motor_Reverse     |
|---] [--------------------------------------( )--------|
|                                                       |

The XIO (examine if open) contacts — Rev_Out in the forward rung, Fwd_Out in the reverse rung — are the programmatic interlocks. If the reverse output is already energized, the forward rung cannot complete, and vice versa. This is in addition to the physical/electrical interlock on the contactors themselves (mechanical interlock bar or auxiliary NC contacts wired in series with the opposing contactor coil).

Direction Change Timing

In a real application, you should add a time delay between stopping in one direction and starting in the other. A motor spinning at full speed in one direction cannot be immediately reversed without extreme mechanical stress. A typical implementation uses a TOF (Timer Off-Delay) that enforces a 2-3 second delay after the forward output drops before the reverse rung can complete.

Complete Example with All Safety Interlocks

A production-ready motor starter combines everything above and adds additional safety inputs. Here is the complete interlock chain that should appear in series before any motor output:

• E-Stop — Emergency stop circuit (hardwired NC, read as XIC)
• Guard_OK — Machine guarding / safety gate closed
• OL_NC — Overload relay healthy
• Drive_Ready — VFD or soft starter in ready state (if applicable)
• Opposite direction interlock — XIO on opposing output
• Permissive conditions — Lubrication pressure OK, cooling flow confirmed, etc.

|                                                              |
|  EStop  Guard  OL   Drive_Rdy  Stop  Start  Rev(NC)  Fwd    |
|--] [---] [---] [-----] [------] [--+--] [--+--]/[---( )-----|
|                                    |       |                 |
|                                    +--] [--+  (seal-in)      |
|                                       Fwd                    |
|                                                              |

Every condition must be TRUE for the motor to run. Any single condition going FALSE immediately de-energizes the output. This is the inherent advantage of ladder logic: the fail-safe behavior is built into the structure. A broken wire, a lost signal, a tripped breaker — all result in the motor stopping.

Building This in Plaxio

Plaxio is a modern PLC IDE that lets you build ladder logic programs visually with a professional-grade editor. To implement this motor starter in Plaxio:

• Open Plaxio and create a new project. Select your target PLC platform.
• In the variable table, define your I/O mapping: assign physical inputs (start, stop, e-stop, overload) and outputs (forward contactor, reverse contactor) to their respective addresses.
• Open the Ladder Diagram editor. Each rung is constructed by dragging contacts and coils onto the canvas, or by using keyboard shortcuts for rapid entry.
• Build the forward and reverse rungs with interlocks as shown above. Plaxio validates contact/coil references in real time, flagging undefined variables instantly.
• Use the built-in simulator to test your logic before downloading to hardware. Force inputs on and off to verify the seal-in engages, the interlocks block simultaneous activation, and fault conditions properly de-energize outputs.
• When ready, compile and download to your target PLC. Plaxio handles the IEC 61131-3 code generation.

The advantage of building in Plaxio over legacy tools is the speed of iteration. The visual editor, real-time validation, and integrated simulation mean you catch wiring errors in the logic before they become commissioning nightmares on the factory floor.

Key Takeaways

• The seal-in circuit is the foundation of all motor control in PLCs. Master it thoroughly.
• Always place the stop condition in series (not parallel) so that any break in the chain stops the motor.
• Interlocks for forward/reverse must exist in both software and hardware. Never rely on software alone.
• Jog functions must explicitly bypass the seal-in to prevent unintended latching.
• Production circuits require a full safety chain: E-stop, guarding, overloads, and process permissives.