Elevator PLC Programming: Ladder Logic, States and Safety Interlocks
Elevator PLC Programming Explained
An elevator PLC program is a state machine wrapped in interlocks. The PLC reads floor-call buttons and position switches, decides which floor to serve next, drives the hoist motor up or down until the car arrives, then opens the door on a timer — and it never moves the car while a door is open. Get the state machine and the door/move interlock right and the rest is wiring.
This guide walks through a complete elevator control PLC design: the I/O, the lift state machine, the call-button and door-timer rungs, the nearest-floor dispatch logic, and the safety interlocks that keep the whole thing safe. Every rung here is something you can build and test in a browser PLC simulator before you ever touch real hardware.
Map the I/O first
Before any ladder logic, list what the PLC senses and what it controls. An elevator control PLC has four families of I/O: call buttons, position feedback, the hoist motor, and the door motor.
- Inputs — floor-call buttons (one per floor), per-floor position/limit switches that confirm the car has arrived, a door-closed limit switch, and a door-open photo-eye for obstruction.
- Outputs — hoist motor up, hoist motor down, door open and door close.
A small three-floor lift PLC program already needs around a dozen I/O points. Naming them clearly — Call_F1, At_F2, Motor_Up, Door_Open — pays for itself the first time you debug a rung.
The elevator as a state machine
An elevator is the textbook example of a PLC state machine. At any instant the car is in exactly one state, and a single, well-defined event moves it to the next. Modelling it this way stops the classic beginner bug where the motor and the door both try to run at once.
The cycle reads simply:
- Idle — car parked, door closed, waiting for a call.
- Moving up / Moving down — a call is registered above or below; the PLC drives the hoist toward the target floor.
- Arrived — the target floor's position switch closes; the motor stops.
- Door open — the door motor opens the door and a timer holds it open.
- Door close — the timer expires, the door closes, and the car returns to Idle ready for the next call.
The single most important rule lives between these states: the car may only leave Idle when the door-closed limit switch is made. That one interlock is what makes the design safe rather than dangerous.
Latching a floor call
A passenger taps a call button for a fraction of a second, but the request must persist until the car serves that floor. That is a classic seal-in (latch) rung: the call button sets a call bit, the bit seals itself in, and an "arrived at that floor" contact breaks the seal to clear it.
Read it left to right: pressing Call_F2 (or the already-latched Call_F2 bit sealing itself in) energises the call coil, while the normally-closed At_F2 contact drops the latch the moment the car reaches floor 2. You build one of these rungs per floor.
Holding the door open with a timer
Once the car arrives and the door opens, it must stay open long enough for people to get in and out — but not forever. A TON on-delay timer does this cleanly: start the timer when the door is fully open, and only command "door close" once the timer is done and nothing is blocking the doorway.
The photo-eye is wired as a normally-closed contact in series, so if anything breaks the beam the close command is inhibited and the dwell timer effectively restarts. (Need a refresher on on-delay timers? See PLC timers explained.)
Deciding which floor to serve next
With several calls latched at once, the PLC must choose a target. The simplest workable rule for a small lift is nearest floor in the current direction of travel — it keeps the car moving one way until it has served every call that direction, then reverses. This is the heart of real elevator dispatch and it avoids the car oscillating between two impatient passengers.
In ladder logic you implement this by comparing the current floor number with the latched call bits and the stored direction, then setting Motor_Up or Motor_Down accordingly. The key is that direction is itself a stored state, not something you recompute from scratch every scan.
Safety interlocks come first
No elevator PLC program is finished until the interlocks are in place. These are non-negotiable and most of them belong in series with the motor and door outputs so they can override the logic above.
The two that catch beginners every time: never energise both Motor_Up and Motor_Down (cross-interlock the two coils so each drops the other), and never run the hoist with the door open (put Door_Closed as a normally-open contact in series with both motor coils). Add the top and bottom over-travel limit switches and an emergency-stop that drops every output, and you have a design that fails safe.
The motor-up rung shows exactly how those interlocks stack in series ahead of the coil:
Single-floor vs multi-floor: how much logic do you really need?
A two-stop "single-floor" lift (up, down, two doors) is dramatically simpler than a multi-floor design. Knowing where the complexity lives helps you scope your first project.
Start with a two- or three-floor lift, get the state machine and interlocks rock-solid, then scale the same patterns up. The dispatch logic is the only part that grows meaningfully with floor count.
Build it in your browser
The fastest way to make elevator ladder logic click is to wire it up and watch the states change as you press call buttons. You can build this whole lift PLC program — call latches, door timer, motor interlocks and all — in the free browser PLC simulator, or jump straight into a pre-built elevator exercise from the scenarios library and see the safety interlocks fire when you try to break them.
FAQ
How do you program an elevator with a PLC? Model the car as a state machine (idle → moving → arrived → door open → door close), latch each floor call with a seal-in rung, drive the hoist motor toward the nearest requested floor, open the door on a TON timer, and gate every motor output behind a door-closed interlock so the car can never move with an open door.
What ladder logic does an elevator need? At minimum: one seal-in (latch) rung per floor call, a door-open timer rung, two hoist-motor rungs (up and down) that are cross-interlocked, a door-open and door-close rung, and series safety contacts for the door-closed switch, over-travel limits and emergency stop.
What is the most important elevator PLC interlock?
The door-closed interlock: a normally-open Door_Closed contact in series with both hoist-motor coils so the car physically cannot move while a door is open. The up/down cross-interlock is a close second.
How do you handle multiple floor calls at once? Latch every call so none are lost, store the current direction of travel, and serve the nearest requested floor in that direction before reversing. This keeps the car moving efficiently instead of bouncing between calls.