Motor Control Circuits

The Core Idea

A motor control circuit turns operator requests and equipment feedback into a motor command. Start/stop memory, overload conditions, and direction interlocks determine when that command may stay on.

What you will learn

• Build three-wire start/stop control: a momentary Start, a seal-in, and a normally closed Stop.

• Latch an overload trip so the motor needs a Reset and then a new Start.

• Interlock forward and reverse so the two directions can never be on together.

• Add a jog that runs the motor only while held and never seals in.

Why it matters

Real motor commands depend on more than one button. Reading these common circuits helps you understand both normal operation and why a motor is being prevented from running.

The problem

One motor starter, three everyday control circuits. Each has its own small example.

Every Stop button in this lesson is normally closed. STOP_PB is TRUE while the button is released and FALSE while it is pressed. The program uses a normally open contact on STOP_PB to permit running, so pressing Stop, or a broken wire, stops the motor. This Stop is an ordinary operating stop. Emergency stops belong to a separate safety system, such as a safety relay or a safety-rated controller, not to ordinary programmable logic controller (PLC) logic, and nothing in this lesson is a safety circuit.

1. Three-wire start/stop with an overload. "Three-wire" comes from hard-wired starters: three wires run from the pushbutton station to the starter, and a contact on the contactor seals in the Start button. Because the seal is lost whenever the motor stops, the motor never restarts by itself; someone has to press Start again.

The overload relay protects the motor from overheating. In a real starter its contact usually also opens the contactor coil circuit directly. The program's job is to remember the trip, show it on OL_FAULT, and refuse Start until Reset is pressed. Reset must not restart the motor.

2. Forward and reverse. FWD_PB and REV_PB are momentary buttons. MOTOR_FWD and MOTOR_REV drive two contactors that connect the motor with two of its supply phases swapped. Both closed at once would short those phases together, so the two outputs must never be TRUE together, and the motor must be stopped before it changes direction. Real reversing starters also have a mechanical interlock and interlock contacts wired between the two contactors; the program's interlock adds to them and does not replace them.

3. Jog. JOG_PB is TRUE while the Jog button is held. Jog runs the motor in short bursts for positioning or setup, so the motor must run only while Jog is held and never seal in.

This lesson builds on the seal-in from Start/Stop Seal-In Circuit, the set and reset coils from Latch and Unlatch, and the start conditions from Interlocks and Permissives.

Predict

The motor is running when the overload relay trips. Later, someone resets the relay at the starter, so OL_OK is TRUE again. Does the motor restart by itself? What happens if the operator presses Start before pressing Reset?

Keep your answer in mind while you run the demo.

Try it

Hold each button for a moment; the program reads inputs once every 100 ms scan, so a very quick tap can be missed.

1. Press START and release it. The motor keeps running.

2. Press STOP. The motor stops, and releasing Stop does not restart it.

3. Start the motor again, then hold OVERLOAD for about a second. This button is wired like Stop: OL_OK is FALSE only while you hold it. Releasing it is like resetting the relay at the starter.

4. Press START. Then press RESET, and press START again.

Check your prediction

The motor does not restart when the relay recovers, and Start does nothing before Reset. The trip latched OL_FAULT, and the normally closed OL_FAULT contact in the motor rung blocks Start. The trip also opened the seal-in, so pressing Reset only clears the fault; the motor waits for a new Start press.

Look closer

Pause and use Step one scan around the trip.

• Rung 1 has a normally closed contact on OL_OK driving a set coil for OL_FAULT. In the first scan where OL_OK is FALSE, OL_FAULT latches.

• Rung 2 drives the reset coil for OL_FAULT only when RESET_PB and OL_OK are both TRUE. Reset cannot clear the fault while the relay is still tripped.

• Rung 3 is the three-wire circuit: START_PB in parallel with a MOTOR_OUT seal-in contact, then a normally open STOP_PB contact and a normally closed OL_FAULT contact. Rung 1 runs first, so the motor turns off in the same scan as the trip. Once MOTOR_OUT is FALSE, its seal-in contact is open too.

That last point is the whole idea of three-wire control. The seal-in is memory that any stop or trip erases. The fault latch is a second memory that only Reset erases. Starting needs both: a clear fault and a fresh Start press.

Change it

This forward/reverse program has two working seal-in rungs but no interlock. In the editor's tag list, set FWD_PB TRUE and then FALSE to press Forward; set STOP_PB FALSE and then TRUE to press Stop. Start forward, then press Reverse without pressing Stop, and watch both outputs turn on. Then add the interlock and try again. Reverse should now be refused until you press Stop.

Show the guided change

Add a normally closed MOTOR_REV contact to the forward rung and a normally closed MOTOR_FWD contact to the reverse rung, each in series with the STOP_PB contact and outside the seal-in branch. While the motor runs forward, the forward output opens the reverse rung, so a Reverse press cannot start it. Stop clears the forward seal-in and closes that contact again, and Reverse now starts. Even if both buttons are pressed in the same scan, the rung that runs first turns on, and the other rung sees its normally closed contact open.

Interlocking only the buttons (a normally closed REV_PB contact in the forward rung) is not enough: a Reverse press then drops forward and starts reverse in the same scan, reversing a running motor without a stop.

Check yourself

Build a motor with Start, Stop, and Jog. The challenge editor opens with the tags START_PB, STOP_PB, JOG_PB, RUN_SEALED, and MOTOR_OUT, and no rungs. Start must run the motor and seal in until Stop is pressed. Jog must run the motor only while it is held and must never seal in. Stop must block both. The checks include repeated jogs and a jog after a stopped run. Run them as often as you need.

Hint 1

Which part of a start/stop rung gives it memory? Jog must not be able to reach that part.

Hint 2

Keep the memory of a normal run in RUN_SEALED, sealed in by Start. Drive MOTOR_OUT in a separate rung, from either the run memory or Jog.

Hint 3

Rung 1: START_PB in parallel with RUN_SEALED, then STOP_PB, driving RUN_SEALED. Rung 2: RUN_SEALED in parallel with JOG_PB, then STOP_PB, driving MOTOR_OUT.

Show the worked solution

1. A normally open START_PB contact in parallel with a normally open RUN_SEALED contact, in series with a normally open STOP_PB contact, drives the output coil RUN_SEALED.

2. A normally open RUN_SEALED contact in parallel with a normally open JOG_PB contact, in series with a normally open STOP_PB contact, drives the output coil MOTOR_OUT.

Jog reaches the motor output but never the seal-in rung, so it has nothing to hold itself on with. Releasing Jog removes its only path. If you seal in with MOTOR_OUT itself, Jog turns on MOTOR_OUT, and the seal-in contact holds it on: the jog has sealed in. Some machines also block Jog while a normal run is active; that version passes the checks too.

What happened and why

All three circuits are about where a signal enters the rung.

• A signal in the seal-in branch, like Start, can begin a run that the seal-in then remembers.

• A signal in series after the branch, like Stop or the overload fault, can end a run and erase that memory.

• A signal that reaches only the output, like Jog, acts only while it lasts.

• A contact of one output in the other output's rung is an interlock: while one direction runs, the other cannot start.

The overload adds one more kind of memory. A set coil holds the fault until a reset condition you choose: here, a healthy relay and a Reset press. Because the trip also breaks the seal-in, clearing the fault never restarts the motor. Conveyors, pumps, fans, and hoists all use these circuits, often together on one starter.

Common mistakes

• Using the overload input directly. Cause: OL_OK is in the motor rung and nothing latches the trip. Symptom: once the relay is reset at the starter, Start works with no Reset, and the fault indication is gone. Fix: latch OL_FAULT with a set coil and block Start with it.

• Resetting without checking the relay. Cause: the reset rung has only RESET_PB. Symptom: Reset clears the fault while the relay is still tripped. Fix: require OL_OK in the reset rung too.

• Keeping the run memory through a trip. Cause: the trip only blocks the output, and a separate run latch stays set. Symptom: the motor restarts by itself when Reset is pressed. Fix: let the trip break the seal-in, or reset the run memory on a trip.

• A normally closed contact on the Stop input. Cause: matching the contact to the button. Symptom: the motor will not start, or starts only while Stop is held. Fix: STOP_PB is already TRUE when it is OK to run, so use a normally open contact.

• No interlock, or only a pushbutton interlock, or an interlock in one rung only. Symptom: both directions energize, or the motor reverses without stopping. Fix: put a normally closed contact of each direction's output in the other direction's rung.

• Jog that seals in. Cause: Jog is in parallel with Start in the seal-in rung, or MOTOR_OUT seals itself. Symptom: the motor keeps running after Jog is released. Fix: keep Jog out of the seal-in rung.

• Jog that bypasses Stop. Cause: Jog is in parallel with the Stop contact. Symptom: holding Jog runs the motor while Stop is pressed. Fix: put the STOP_PB contact in series after both paths.

Enable JavaScript to run the embedded simulator and complete the interactive exercises.