Elevator PLC Programming: Complete Guide to Lift Control Systems and Automation

Introduction: Mastering Elevator Control Systems with PLC Programming

Elevator PLC programming represents one of the most safety-critical and technically demanding applications in building automation, requiring precise control of mechanical systems, sophisticated call management algorithms, and comprehensive safety monitoring to protect passengers and equipment. From single passenger elevators in small buildings to complex multi-car systems in high-rise towers, PLC-based elevator control has become the industry standard for reliability, performance, and safety.

Modern elevator control systems have evolved far beyond simple up/down relay logic circuits, incorporating variable frequency drives for smooth acceleration profiles, advanced dispatching algorithms for optimal traffic handling, energy regeneration capabilities, and integrated safety systems that meet rigorous international standards. These systems must coordinate motor control, position sensing, door operation, load monitoring, and passenger interface while ensuring fail-safe operation under all conditions.

This comprehensive guide covers every aspect of elevator PLC programming, from fundamental control concepts to advanced group elevator dispatching algorithms used in modern intelligent building systems. Whether you're programming hydraulic elevators, traction systems, or high-speed express elevators, this guide provides the technical knowledge and practical programming techniques needed to create efficient, safe, and reliable elevator control systems.

The transition to PLC-based elevator control enables advanced features such as destination dispatch systems, predictive maintenance monitoring, energy optimization, and seamless integration with building management systems while maintaining the extremely high safety and reliability standards required for passenger transportation applications.

Chapter 1: Elevator System Components and Architecture

Understanding Elevator Drive Systems

Traction elevator systems use steel cables or belts wrapped around drive sheaves to move the elevator car through counterweight balance, providing efficient operation for mid-rise and high-rise applications. Modern gearless permanent magnet motors driven by variable frequency drives deliver smooth acceleration, precise floor leveling, and energy regeneration capabilities that return braking energy to the building electrical system.

Geared traction systems use worm gears or helical gears to increase motor torque while reducing speed, offering cost-effective solutions for low-rise and mid-rise applications with lower speed requirements. PLC programming must account for gear backlash, mechanical efficiency, and different acceleration characteristics compared to gearless systems.

Hydraulic elevator systems use fluid-powered cylinders to raise and lower the car, providing advantages for low-rise applications, pit depth limitations, and heavy load requirements. Control programming differs significantly from traction systems, requiring hydraulic valve control, pressure monitoring, and different motion profile characteristics.

Machine-room-less (MRL) elevator configurations place the drive system in the hoistway to eliminate the machine room requirement, creating architectural flexibility while requiring specialized programming for maintenance mode access, motor cooling, and equipment monitoring in less accessible locations.

Position Sensing and Measurement Systems

Absolute encoders provide precise car position measurement without requiring reference positioning or homing sequences, enabling immediate operation after power restoration and accurate floor-to-floor distance measurement for motion control algorithms. These encoders typically mount on the motor shaft or drive sheave, providing resolution of 1mm or better for smooth leveling control.

Incremental encoders require periodic reference positioning using fixed floor sensors but offer cost advantages for applications where absolute position is not critical. Programming must include encoder initialization sequences, position verification algorithms, and backup position tracking using floor proximity sensors.

Floor position sensors using magnetic, inductive, or optical detection provide coarse position feedback for floor stopping, slowdown zone detection, and encoder position verification. Modern systems use these sensors primarily for backup position confirmation rather than primary stopping control.

Travel limit switches at the top and bottom of the hoistway provide final overtravel protection, triggering emergency stops if normal limit sensors fail to stop car movement. Safety PLC programming must monitor these switches continuously and implement immediate shutdown sequences when activated.

Door Systems and Operators

Center-opening door systems provide the fastest door operation and widest clear opening, using two door panels that open from the center toward the sides. Control programming must synchronize both door motors or ensure mechanical coupling maintains proper panel alignment throughout the opening and closing cycle.

Side-opening single-panel doors offer simpler mechanical systems suitable for lower-traffic applications, requiring only single-motor control but potentially longer door cycle times for wide openings. Programming complexity reduces compared to center-opening systems while maintaining all safety interlock requirements.

Door operator systems use AC or DC motors with encoder feedback to provide smooth, quiet door operation with precise position control and adjustable speed profiles. Modern operators include electronic force limiting that automatically adjusts closing force and reverses on obstruction detection without requiring mechanical clutches.

Light curtain safety devices project infrared beams across the door opening to detect passengers or objects, triggering door reopening when beams are interrupted. Programming must monitor all beam positions, implement appropriate response delays, and provide diagnostic capabilities for individual beam failure detection.

Safety System Components

Overspeed governors mechanically detect excessive car speed and activate safety brakes independent of the control system, providing fail-safe protection against cable failure or drive system runaway. PLC programming monitors governor electrical switches to detect activation and implement appropriate shutdown sequences.

Safety brakes mounted on the car frame engage guide rails to stop car movement when activated by the overspeed governor or electrical safety circuits. Electronic safety brake monitoring systems verify brake release before permitting car movement and detect brake failures through force sensors and position switches.

Door interlocks on each landing door and car door prevent elevator movement unless all doors are fully closed and locked, forming critical safety chains that must be continuously monitored by the safety PLC. Modern systems use coded magnet or electronic interlock systems that verify proper door engagement rather than simple contact switches.

Load weighing systems measure car load to prevent overloading, adjust motor torque compensation, and enable load-based dispatching optimization. Programming must monitor load cells or pressure sensors, calculate passenger count estimates, and implement overload protection sequences that prevent car movement until excess weight is removed.

Chapter 2: PLC Hardware Requirements for Elevator Control

Safety PLC Certification and Selection

Elevator control systems require safety-rated PLCs certified to SIL2 or SIL3 (Safety Integrity Level) standards according to IEC 61508 and elevator-specific safety standards ASME A17.1 (North America) or EN 81 (Europe). These safety PLCs include redundant processors, watchdog timers, memory validation, and diagnostic capabilities that ensure safe operation even during component failures.

Dedicated safety PLCs such as Siemens S7-1500F, Allen-Bradley GuardLogix, or Schneider Electric Preventa separate safety-critical functions from normal control functions, providing certified safety performance while allowing standard PLCs to handle non-safety features such as call management and comfort optimization.

Integrated safety systems combine standard and safety control in single PLC platforms, reducing hardware costs and simplifying integration while maintaining certified safety performance for critical functions. Programming must clearly distinguish safety functions from standard control and follow rigorous validation procedures to maintain safety certification.

Redundant PLC configurations provide additional reliability for critical elevator applications, using dual processors with synchronized operation and automatic failover capabilities. This redundancy extends beyond safety requirements to ensure continuous service availability in mission-critical installations.

I/O Requirements and Configuration

Digital input modules connect to door interlocks, safety switches, floor position sensors, limit switches, and push buttons throughout the elevator system. Safety-rated input modules monitor safety chain components with diagnostic capabilities that detect wiring faults, short circuits, and component failures.

Digital output modules control contactors for motor starters, brake releases, door operators, car lighting, and indicator lights. Safety outputs driving critical functions such as brake control require dual-channel outputs with monitoring to verify proper operation and detect stuck or failed outputs.

Analog input modules interface with position encoders, load cells, pressure sensors, and diagnostic instrumentation to provide continuous measurement feedback for motion control, load monitoring, and predictive maintenance systems. High-resolution analog inputs (16-bit or better) ensure precise position and speed control.

Encoder interface modules provide specialized high-speed counting and position tracking capabilities for absolute or incremental encoders, often including position preset, direction sensing, and high-frequency pulse counting that exceeds standard digital input capabilities.

Communication and Network Integration

Drive communication interfaces connect PLCs to variable frequency drives using industrial protocols such as EtherCAT, PROFINET, or EtherNet/IP to enable precise speed control, torque limiting, and drive status monitoring. Real-time communication ensures deterministic response for smooth motion profiles and immediate fault response.

Building management system integration allows elevator systems to share operational data, respond to building modes (fire, security, energy management), and provide centralized monitoring through protocols such as BACnet, Modbus TCP, or proprietary building automation networks.

Remote monitoring systems enable service technicians to access elevator performance data, diagnostic information, and alarm histories through secure network connections, reducing service response times and enabling predictive maintenance programs.

Destination dispatch systems require high-speed communication between multiple elevator controllers and hall fixtures to coordinate complex group dispatching algorithms that optimize passenger wait times and energy consumption across elevator groups.

Panel Design and Installation

Main elevator controllers mount in dedicated machine rooms or hoistway locations with environmental protection suitable for temperature extremes, humidity, and vibration present in elevator machinery spaces. Panel design must provide adequate cooling, protection from electrical noise, and accessibility for maintenance and troubleshooting.

Power distribution systems provide isolated power supplies for control circuits, safety circuits, and drive systems with appropriate isolation, filtering, and surge protection to ensure reliable operation despite electrical system disturbances. Uninterruptible power supplies (UPS) may power control systems to enable controlled shutdown and trapped passenger communication during power failures.

Emergency communication systems include battery-powered intercoms, alarm buttons, and automatic emergency notification capabilities that function independently of main power supplies. Programming must monitor communication system status and provide clear passenger instructions during emergency conditions.

Diagnostic and maintenance interfaces include operator panels, service displays, or laptop connections that enable technicians to monitor system operation, access diagnostic data, manually control elevator functions for testing, and update programming as needed.

Chapter 3: Call Management and Dispatching Programming

Car Call Registration and Processing

Car call input processing monitors push buttons inside the elevator car, registering floor requests from passengers and storing active calls in call registers for processing by the control algorithm. Programming must debounce button inputs, illuminate call button indicators when registered, and maintain call status throughout power fluctuations using non-volatile memory.

Call prioritization algorithms determine the order in which registered car calls are served based on car direction, floor sequence, and dispatching strategy. Simplex elevators typically serve calls in floor sequence (bottom to top when traveling up, top to bottom when traveling down) while minimizing travel distance and reversal frequency.

Call clearing logic removes served calls from the active call register when the car stops at the requested floor and doors open fully, extinguishing the call button indicator and updating the control algorithm's target floor list. Programming must verify proper door operation and sufficient door opening time before clearing calls.

Call timeout and cancellation features allow car calls to be cancelled if not served within reasonable time periods or through special cancel button sequences, preventing elevator operation to accidentally registered floors while ensuring legitimate calls are protected from premature cancellation.

Hall Call Assignment and Direction Control

Hall call input processing monitors up and down buttons at each landing, registering directional requests that must be assigned to available elevator cars in group systems or serviced by simplex elevators based on current direction and position.

Direction assignment logic determines whether the elevator should serve calls in the up or down direction based on active car calls, hall calls, and car position. Typical algorithms maintain current direction until all calls in that direction are served before reversing to serve calls in the opposite direction.

Call insertion algorithms determine whether hall calls can be inserted into the current trip sequence without excessive delay or if they should be deferred until the return trip. This optimization balances passenger wait time against trip efficiency and car capacity considerations.

Hall call indicators provide visual feedback to waiting passengers showing which elevator is assigned to their call and estimated arrival time in group systems, or simply confirming call registration in simplex installations. Programming must update these indicators based on real-time dispatching decisions and car movement.

Priority Service Modes

Fire service mode overrides normal call management to provide dedicated firefighter control according to ASME A17.1 or EN 81 requirements. Phase I fire service returns all elevators to the designated recall floor with doors open and cancels all calls, while Phase II provides manual car control for firefighter operation with safety interlocks disabled.

VIP service or executive mode provides dedicated car service to authorized users, bypassing hall calls and providing express service to registered floors. Programming must verify authorization through key switches, card readers, or codes while maintaining safety interlocks and emergency override capabilities.

Independent service mode allows maintenance personnel to remove cars from automatic service for testing, maintenance, or special operations while maintaining safety protections. Programming provides manual control capabilities while preventing normal call registration and monitoring critical safety functions.

Emergency power operation automatically reconfigures elevator service when building power fails and backup generators activate, typically providing limited service with one car at a time operation, reduced speed, and restricted floor access to ensure adequate power capacity for emergency evacuation.

Single Elevator Call Logic Example

// Car Call Processing - Ladder Logic Representation
Network 1: Car Call Input Registration
|----[ ]----[ ]----( )----| Car_Call_Floor_2
|   Floor_2  NOT_           Store in call
|   Button   At_Floor_2    register array

Network 2: Direction Determination
|----[/]----[ ]----( )----| Direction_Up
|   Calls_   Calls_        Set UP direction
|   Above    Below         when calls above

Network 3: Target Floor Selection
|----[ ]----[MOVE]--------| Next_Target_Floor
|   Direction Calculate     Find next floor
|   _Up      nearest       in direction
|            floor up      of travel

Network 4: Call Service Completion
|----[ ]----[ ]----[RESET]| Clear_Car_Call
|   At_      Doors_        Remove from
|   Target   Fully_        active calls
|   Floor    Open          when served

Chapter 4: Motion Control Programming for Elevator Systems

Acceleration and Deceleration Profiles

S-curve acceleration profiles provide smooth, comfortable passenger experience by gradually increasing and decreasing acceleration rates rather than applying constant acceleration. This ramping of acceleration (jerk control) eliminates sudden force changes that cause passenger discomfort, load shifting, and mechanical stress on drive components.

PLC programming generates S-curve profiles by calculating position, velocity, and acceleration setpoints at each control cycle based on current car position, target floor position, maximum speed, and comfort parameters. Modern systems update these calculations every 10-20 milliseconds to maintain smooth control throughout the trip.

Acceleration limiting based on car load adjusts motion profiles to maintain consistent passenger comfort regardless of car loading. Heavy loads require reduced acceleration to maintain acceptable jerk levels while empty cars can use higher acceleration to improve traffic handling performance.

Emergency deceleration profiles provide maximum safe deceleration when safety systems detect overspeed, obstruction, or other hazardous conditions. These profiles override comfort optimization to achieve rapid stopping while remaining within safe mechanical limits of cables, brakes, and structural components.

Floor-to-Floor Travel Sequencing

Travel sequence initiation begins when doors are fully closed and locked, all safety interlocks are satisfied, and a valid target floor is selected. Programming verifies all conditions through safety-rated logic before releasing brakes and enabling drive system operation.

Acceleration phase control commands the drive to follow the programmed acceleration profile from standstill to rated speed (or appropriate speed for short floors) while monitoring actual speed and position to verify proper system response and detect abnormal conditions.

Constant speed travel maintains rated velocity for longer floor-to-floor distances, providing energy-efficient operation while monitoring for overspeed conditions, position tracking accuracy, and drive system faults. The PLC continuously calculates remaining distance to target floor to determine optimal deceleration initiation point.

Deceleration initiation occurs at the calculated position that allows smooth stopping at the target floor leveling zone using the programmed deceleration profile. Programming must account for system delays, mechanical characteristics, and load-dependent braking performance to ensure consistent leveling accuracy.

Speed Reference Generation and Control

VFD speed reference signals from the PLC command the drive system to produce desired motor speeds corresponding to the motion profile setpoints. Analog output signals (typically 0-10V or 4-20mA) or digital communication protocols transmit speed commands with resolution sufficient for smooth control (12-bit minimum, 16-bit preferred).

Speed feedback monitoring compares actual motor speed from encoder feedback to commanded speed, detecting drive faults, mechanical problems, or loading conditions that prevent normal operation. Programming implements closed-loop supervision that verifies acceptable speed tracking throughout all motion phases.

Position-based speed profiling continuously calculates optimal speed based on remaining distance to target floor, ensuring smooth deceleration to leveling speed regardless of actual car load, system variations, or external disturbances. This feed-forward control improves leveling accuracy compared to simple time-based profiles.

Torque limiting functions restrict motor torque to safe levels during acceleration, constant speed operation, and deceleration to prevent cable slippage, excessive mechanical stress, and uncomfortable force changes. Programming monitors drive torque feedback and adjusts speed commands when limits are approached.

Leveling Control and Re-Leveling

Leveling zone approach transitions the car from normal travel mode to precision leveling mode when floor sensors indicate entry into the leveling zone (typically ±50-100mm from floor level). Control switches from speed profile following to precision position control for final approach to floor level.

Fine positioning control uses high-resolution encoder feedback (1mm resolution or better) to stop the car precisely at floor level, typically within ±5mm tolerance. PLC programming commands very low speeds (0.05-0.15 m/s) and small position corrections to achieve accurate leveling despite load changes and mechanical variations.

Re-leveling operation automatically adjusts car position to maintain floor level during loading and unloading as passenger weight changes cause cable stretch or hydraulic pressure variations. Programming monitors position error while doors are open and commands small corrective movements to restore level position.

Pre-opening door control initiates door opening sequence while the car is still moving at very low speed during final leveling approach, reducing total floor time and improving traffic handling performance. This advanced feature requires precise position control and safety verification before door movement begins.

S-Curve Motion Profile Programming Example

// S-Curve Profile Generation - Structured Text
PROGRAM Elevator_Motion_Control
VAR
    Current_Position : REAL;     // Current car position (mm)
    Target_Position : REAL;      // Target floor position (mm)
    Current_Velocity : REAL;     // Current speed (mm/s)
    Current_Accel : REAL;        // Current acceleration (mm/s²)

    Max_Velocity : REAL := 2500.0;    // 2.5 m/s rated speed
    Max_Accel : REAL := 1000.0;       // 1.0 m/s² max acceleration
    Max_Jerk : REAL := 2000.0;        // 2.0 m/s³ jerk limit

    Phase : INT;                 // Motion phase tracker
    Speed_Reference : REAL;      // Output to VFD
    Profile_Time : REAL;         // Elapsed time in current phase
END_VAR

// Calculate S-Curve Profile Phases
Distance_Remaining := Target_Position - Current_Position;

CASE Phase OF
    0: // Standby - Check for start conditions
        IF Doors_Closed AND Safety_OK AND Distance_Remaining > 100 THEN
            Phase := 1;  // Start acceleration
            Profile_Time := 0;
        END_IF;

    1: // Jerk-In (Increasing Acceleration)
        Profile_Time := Profile_Time + Cycle_Time;
        Current_Accel := Max_Jerk * Profile_Time;

        IF Current_Accel >= Max_Accel THEN
            Phase := 2;  // Transition to constant acceleration
            Current_Accel := Max_Accel;
        END_IF;

    2: // Constant Acceleration
        Current_Velocity := Current_Velocity + (Current_Accel * Cycle_Time);

        IF Current_Velocity >= Max_Velocity THEN
            Phase := 3;  // Transition to jerk-out
            Profile_Time := 0;
        ELSIF Distance_Remaining < Decel_Distance THEN
            Phase := 4;  // Skip to deceleration
            Profile_Time := 0;
        END_IF;

    3: // Jerk-Out (Decreasing Acceleration)
        Profile_Time := Profile_Time + Cycle_Time;
        Current_Accel := Max_Accel - (Max_Jerk * Profile_Time);

        IF Current_Accel <= 0 THEN
            Phase := 5;  // Constant speed
            Current_Accel := 0;
        END_IF;

    5: // Constant Speed Travel
        Current_Velocity := Max_Velocity;

        IF Distance_Remaining < Decel_Distance THEN
            Phase := 6;  // Start deceleration
            Profile_Time := 0;
        END_IF;

    6: // Deceleration Jerk-In
        Profile_Time := Profile_Time + Cycle_Time;
        Current_Accel := -Max_Jerk * Profile_Time;

        IF ABS(Current_Accel) >= Max_Accel THEN
            Phase := 7;  // Constant deceleration
            Current_Accel := -Max_Accel;
        END_IF;

    7: // Constant Deceleration
        Current_Velocity := Current_Velocity + (Current_Accel * Cycle_Time);

        IF Current_Velocity <= Leveling_Speed THEN
            Phase := 8;  // Final positioning
            Current_Velocity := Leveling_Speed;
        END_IF;

    8: // Final Leveling Positioning
        Position_Error := Target_Position - Current_Position;

        IF ABS(Position_Error) < 5.0 THEN  // Within 5mm tolerance
            Current_Velocity := 0;
            Speed_Reference := 0;
            Phase := 0;  // Return to standby
            Apply_Brake;
        ELSE
            // Proportional control for final approach
            Current_Velocity := Position_Error * 0.5;  // P-gain
            Current_Velocity := LIMIT(-100.0, Current_Velocity, 100.0);
        END_IF;

END_CASE;

// Update position based on velocity
Current_Position := Current_Position + (Current_Velocity * Cycle_Time);

// Convert velocity to VFD speed reference (0-10V = 0-100%)
Speed_Reference := (Current_Velocity / Max_Velocity) * 10.0;
VFD_Analog_Output := Speed_Reference;

Chapter 5: Door Control System Programming

Door Opening and Closing Sequences

Door opening initiation occurs when the car stops at floor level with all safety conditions satisfied, triggering the door operator to begin the opening sequence at programmed door speed. Programming includes initial acceleration, constant speed travel, and deceleration as doors approach fully open position.

Open door timing maintains doors in the fully open position for a programmed dwell time (typically 3-8 seconds) that allows passenger loading and unloading. Advanced systems adjust dwell time based on car load changes, detecting passenger traffic and extending time when loading is occurring.

Door closing sequence begins after dwell time expires, commanding the door operator to close at normal closing speed while monitoring safety devices for obstruction detection. Programming must ensure smooth acceleration, maintain consistent closing speed, and provide controlled deceleration as doors approach the fully closed position.

Door lock verification confirms that all door interlocks are engaged before permitting car movement, checking interlock status through safety-rated monitoring circuits. Modern systems verify coded signals from intelligent interlocks that prevent simple jumper wire bypasses of safety systems.

Nudging Mode and Obstruction Handling

Nudging mode activates when doors remain open beyond maximum time limits (typically 20-30 seconds) due to passenger interference or boarding activity, closing doors with reduced force and continuous buzzer or tone to encourage passengers to clear the doorway. This mode maintains service availability while protecting passengers from excessive force.

Obstruction detection through light curtains, door edge sensors, or motor torque monitoring immediately reverses door closing when passengers or objects are detected in the doorway. Programming must respond within 100 milliseconds to prevent injury while distinguishing between genuine obstructions and normal door resistance.

Re-opening cycles count the number of consecutive door re-openings triggered by obstructions, implementing progressive delays or service timeout after excessive re-openings to prevent indefinite delay caused by persistent obstructions or vandalism. Typical systems allow 3-5 re-opening attempts before extended timeout.

Force limiting systems continuously monitor door motor current or torque to detect resistance during closing, limiting maximum force to safe levels that prevent injury. Electronic force limiting provides more precise control than mechanical clutches while enabling diagnostic monitoring of door system performance.

Light Curtain Integration Programming

Beam monitoring continuously checks all light curtain transmitter/receiver pairs to detect beam interruption during door closing sequence. Programming must process all beam inputs (typically 8-32 beams) and trigger re-opening if any beam is broken.

Diagnostic capabilities identify individual failed beams or light curtain system faults through continuous monitoring of receiver signal strength and communication status. Programming distinguishes between obstructions (partial beam breaks) and system failures (complete loss of communication) to provide appropriate responses.

Selective beam blanking allows programming to ignore specific beams under certain conditions, such as blanking lower beams when debris on door sill triggers false obstructions. This feature maintains service availability while requiring careful application to avoid compromising safety.

Fire service override disables light curtain operation during firefighter emergency mode, allowing doors to close despite obstructions as required by fire service protocols. This override requires key switch activation and clear indication that normal safety protections are suspended.

Complete Door Control Example

// Door Control Programming - Function Block Diagram Representation

Network 1: Door Opening Command
|----[ ]----[ ]----[ ]----( )----|
|   At_      Safety_ Dwell_  Open_Door
|   Floor    OK      Timer_  Command
|   Level            Done

Network 2: Light Curtain Monitoring
|----[≥1]----------[NOT]---( )----|
|   Any_Beam        Door_    Door_Close
|   Interrupted     Closing  Obstruction
|   (OR of all      Active
|   curtain beams)

Network 3: Door Obstruction Response
|----[ ]----[ ]----( )----|
|   Door_    Door_   Reverse_to
|   Close_   Obstr.  Full_Open
|   Active

Network 4: Nudging Mode Activation
|----[ ]----[TON]---( )----|
|   Doors_   30s     Nudging_Mode
|   Open     Timer   (Reduced force)

Network 5: Door Closed Verification
|----[ ]----[ ]----( )----|
|   Door_    All_    Ready_for
|   Fully_   Inter-  Car_Travel
|   Closed   locks_
|           Engaged

Network 6: Force Limiting Monitor
|----[>]----( )----|
|   Door_    Force_Limit  Stop_and
|   Motor_   Exceeded     Reverse
|   Current  (>8.0A)

Network 7: Re-Opening Counter
|----[ ]----|CTU|----[ ]----( )----|
|   Door_    Count  Count Door_Service
|   Reopen   Reopen  >5    Timeout_30s

Chapter 6: Safety Systems and Programming

Overspeed Detection and Emergency Braking

Overspeed monitoring continuously compares actual car speed from encoder feedback to maximum permitted speed for current operating mode (normal travel, leveling, inspection mode). Programming implements multiple overspeed thresholds: warning level (105-110% rated speed), intervention level (115-120%), and emergency level (125%+).

Electronic overspeed detection supplements mechanical governor systems, providing earlier intervention and diagnostic capabilities while maintaining mechanical governor as final backup protection. PLC programming triggers progressively severe responses as speed thresholds are exceeded, from warning alarms to immediate emergency brake application.

Emergency brake activation through safety-rated outputs immediately de-energizes brake release circuits, allowing spring-applied brakes to engage and stop car movement. Programming must verify brake application through position feedback and activate backup braking systems if primary brakes fail to stop the car.

Overspeed recovery procedures verify that car speed has returned to safe levels and all safety conditions are satisfied before permitting automatic service resumption. Many jurisdictions require manual technician inspection and reset after overspeed events before returning elevators to passenger service.

Door Zone Safety and Interlocks

Door zone position monitoring restricts door opening to designated door zones (typically ±200mm from floor level) through position-based interlocks that prevent door operation when car is between floors. This protection prevents passengers from accessing open hoistway when car is not properly positioned.

Interlock monitoring circuits continuously verify that all landing doors and car doors are properly closed and locked before permitting car movement. Safety-rated PLC inputs monitor interlock switch status through series-connected safety chains or individual monitored circuits with diagnostic capabilities.

Door bypass capabilities for rescue operations allow controlled door opening outside normal door zones under strict safety supervision for emergency evacuation of trapped passengers. Programming requires multiple confirmation steps, key switch activation, and very slow car movement to ensure passenger safety.

Platform/sill gap monitoring verifies acceptable alignment between car platform and landing sill before permitting passenger boarding, preventing dangerous gaps that could cause tripping or entrapment. Excessive gaps trigger alarms and may prevent door opening until proper releveling occurs.

Load Monitoring and Overload Protection

Load measurement systems continuously monitor car weight through load cells or pressure sensors, providing real-time load data for capacity monitoring, dispatching optimization, and safety protection. PLC programming converts sensor signals to weight or passenger count estimates.

Overload detection prevents car travel when measured load exceeds rated capacity (typically 100-125% of rated load depending on safety margins). Programming provides clear indication to passengers through buzzers, lights, or voice messages requesting that excess passengers exit the car.

Full load indication at 80-100% of rated capacity signals dispatching systems to bypass hall calls and return directly to main floors for efficiency, while informing building management systems of heavy traffic conditions that may require additional elevator service.

Anti-nuisance algorithms prevent false overload indications from passenger movement, jumping, or temporary load spikes through filtered measurements and time delays that distinguish genuine overload from transient disturbances.

Fire Service Mode Programming

Phase I fire service recall activates automatically when building fire alarm systems signal elevator recall, commanding all elevators to return non-stop to the designated fire recall floor (typically main lobby). Programming cancels all car calls and hall calls, provides continuous car position indication, and opens doors at recall floor.

Firefighter controls in Phase II fire service provide manual car and door operation through key switches and maintained push buttons in the car, overriding normal automatic control while maintaining critical safety protections such as overspeed detection and brake monitoring.

Fire service priority ensures that fire service activation takes absolute precedence over all other elevator operations including VIP service, independent service, and normal passenger service. Programming provides clear indication when fire service is active and prevents mode cancellation without proper key switch operations.

Fire service code compliance requires strict adherence to ASME A17.1, EN 81-73, or local fire code requirements for elevator emergency operation. Programming must implement all required features, indicators, and safety overrides exactly as specified in applicable standards.

Safety Chain Monitoring and Diagnostics

Continuous safety circuit monitoring tracks the status of all safety devices including door interlocks, limit switches, governor contacts, brake monitors, and emergency stop switches. Safety PLCs verify circuit continuity and proper switch status before permitting operation.

Fault isolation diagnostics identify specific failed safety devices through individual monitoring rather than simple series circuit monitoring, enabling rapid troubleshooting and service restoration. Modern systems monitor each safety device separately and provide detailed fault location information.

Safety function testing implements automated or semi-automated testing of safety circuits to verify proper operation during maintenance procedures. Programming guides technicians through systematic testing of door interlocks, brake operation, overspeed detection, and other critical safety functions.

Compliance documentation automatically generates logs of safety system tests, faults, and interventions to support regulatory inspections and safety audits. Programming maintains detailed records with timestamps, fault descriptions, and resolution actions.

Safety Programming Example

// Safety System Monitoring - Safety PLC Logic

SAFETY_PROGRAM Elevator_Safety_Monitoring
VAR
    // Safety Inputs (Dual Channel)
    Door_Interlock_CH1 : BOOL;
    Door_Interlock_CH2 : BOOL;
    Safety_Brake_Released_CH1 : BOOL;
    Safety_Brake_Released_CH2 : BOOL;
    Overspeed_Governor_OK_CH1 : BOOL;
    Overspeed_Governor_OK_CH2 : BOOL;

    // Safety Outputs (Dual Channel)
    Brake_Release_Output_CH1 : BOOL;
    Brake_Release_Output_CH2 : BOOL;
    Drive_Enable_Output : BOOL;

    // Safety Status
    Safety_Chain_OK : BOOL;
    Emergency_Stop_Active : BOOL;
    Safe_to_Move : BOOL;

    // Diagnostic
    Interlock_Discrepancy : BOOL;
    Brake_Monitor_Fault : BOOL;
END_VAR

// Dual Channel Door Interlock Monitoring
Safety_Chain_OK := Door_Interlock_CH1 AND Door_Interlock_CH2;

// Detect channel discrepancy (potential wiring fault)
Interlock_Discrepancy := Door_Interlock_CH1 XOR Door_Interlock_CH2;

IF Interlock_Discrepancy THEN
    Emergency_Stop_Active := TRUE;
    Safety_Chain_OK := FALSE;
END_IF;

// Overspeed Governor Monitoring (Both Channels Must Be OK)
Overspeed_OK := Overspeed_Governor_OK_CH1 AND Overspeed_Governor_OK_CH2;

IF NOT Overspeed_OK THEN
    Emergency_Stop_Active := TRUE;
    // Immediate brake application
    Brake_Release_Output_CH1 := FALSE;
    Brake_Release_Output_CH2 := FALSE;
END_IF;

// Brake Feedback Verification
IF (Brake_Release_Output_CH1 OR Brake_Release_Output_CH2) THEN
    // If brake release is commanded, verify brake actually released
    IF NOT (Safety_Brake_Released_CH1 AND Safety_Brake_Released_CH2) THEN
        Brake_Monitor_Fault := TRUE;
        Emergency_Stop_Active := TRUE;
    END_IF;
END_IF;

// Safe to Move Determination (All Conditions Must Be Satisfied)
Safe_to_Move := Safety_Chain_OK
                AND Overspeed_OK
                AND NOT Emergency_Stop_Active
                AND NOT Brake_Monitor_Fault
                AND Doors_Fully_Closed
                AND In_Normal_Operating_Zone;

// Drive Enable Output (Both conditions required)
Drive_Enable_Output := Safe_to_Move AND Drive_Request_From_Control;

// Brake Release Control (Dual Channel Output)
IF Safe_to_Move AND Drive_Enable_Output THEN
    Brake_Release_Output_CH1 := TRUE;
    Brake_Release_Output_CH2 := TRUE;
ELSE
    Brake_Release_Output_CH1 := FALSE;
    Brake_Release_Output_CH2 := FALSE;
END_IF;

END_SAFETY_PROGRAM

Chapter 7: Practical Application - Complete 10-Floor Passenger Elevator

System Architecture Overview

This practical example demonstrates a complete PLC program for a 10-floor traction elevator system serving a commercial office building. The system includes gearless permanent magnet motor with VFD control, center-opening car doors, hall call stations at each floor, and comprehensive safety monitoring meeting ASME A17.1 requirements.

Control system architecture uses a Siemens S7-1500F safety PLC for safety-critical functions integrated with S7-1500 standard PLC for call management and optimization. The system communicates with a SINAMICS G120 VFD via PROFINET for motor control and includes distributed I/O for floor-level inputs and indicators.

Power system specifications: 480VAC three-phase building power supplies the elevator machine through safety-rated contactors controlled by PLC safety outputs. Drive regenerative capability returns braking energy to building electrical system during deceleration, reducing energy consumption by approximately 25% compared to resistive braking.

Elevator performance specifications: 500kg (10 persons) rated capacity, 1.75 m/s rated speed, 2.5m floor height, 10 floors serving basement through 9th floor, estimated traffic handling of 15% population capacity in 5-minute peak periods.

Complete I/O List and Addressing

Digital Inputs (Safety-Rated):

• I124.0-I124.9: Landing door interlocks floors B-9 (dual channel)
• I125.0: Car door interlock (dual channel)
• I125.1: Overspeed governor contact
• I125.2: Safety brake monitor
• I125.3: Bottom final limit
• I125.4: Top final limit
• I125.5: Car emergency stop button
• I125.6: Pit emergency stop
• I125.7: Machine room emergency stop

Digital Inputs (Standard):

• I100.0-I100.9: Floor position sensors B-9
• I101.0-I101.9: Car call buttons floors B-9
• I102.0-I102.8: Hall UP call buttons B-8
• I103.0-I103.8: Hall DOWN call buttons 1-9
• I104.0: Door fully open limit
• I104.1: Door fully closed limit
• I104.2-I104.9: Light curtain beams 1-8
• I105.0: Fire service Phase I key
• I105.1: Fire service Phase II key
• I105.2: Independent service key

Analog Inputs:

• IW200: Absolute encoder position (0-10V = 0-25000mm)
• IW202: Load cell weight measurement (4-20mA = 0-800kg)
• IW204: VFD actual speed feedback

Digital Outputs (Safety-Rated):

• Q124.0: Main contactor control (dual channel)
• Q124.1: Brake release (dual channel)
• Q124.2: Safety circuit monitoring

Digital Outputs (Standard):

• Q100.0: Door open command
• Q100.1: Door close command
• Q101.0-Q101.9: Car call indicators B-9
• Q102.0-Q102.8: Hall UP indicators B-8
• Q103.0-Q103.8: Hall DOWN indicators 1-9
• Q104.0-Q104.9: Floor position indicators (car)
• Q105.0: Overload buzzer
• Q105.1: Nudging buzzer
• Q105.2-Q105.4: Direction arrows (up/down/available)

Analog Outputs:

• QW200: VFD speed reference (0-10V)
• QW202: VFD torque limit

Main Control Sequence and State Machine

State 0 - Idle: Elevator at floor with doors open, no active calls. Wait for car call or hall call registration before transitioning to door closing sequence.

State 1 - Door Closing: Close doors and verify all interlocks engaged. Monitor for obstructions and handle re-opening if required. Transition to travel state when doors confirmed closed and locked.

State 2 - Travel Setup: Calculate motion profile based on target floor distance, maximum speed, acceleration limits, and car load. Verify all safety conditions and release brake. Transition to acceleration when brake release confirmed.

State 3 - Acceleration: Follow S-curve acceleration profile to rated speed or lower speed for short floors. Monitor position and velocity feedback. Transition to constant speed or deceleration as appropriate.

State 4 - Constant Speed: Maintain rated speed while monitoring for deceleration point. Calculate optimal deceleration initiation based on remaining distance and current velocity.

State 5 - Deceleration: Follow S-curve deceleration profile to leveling speed. Monitor position accuracy and adjust if needed to hit leveling zone entry.

State 6 - Leveling: Fine position control to stop at floor level within tolerance. Reduce speed to 0.1 m/s and use encoder feedback for precision positioning.

State 7 - Stopped: Verify position at floor level, apply brake, wait for brake engagement confirmation. Transition to door opening when safe.

State 8 - Door Opening: Open doors and start dwell timer. Monitor for additional calls and determine next target floor. Return to idle if no more calls, otherwise transition to door closing.

Emergency States:

• State 90 - Emergency Stop: Triggered by safety system activation. Controlled emergency deceleration and brake application.
• State 91 - Fire Service Phase I: Automatic recall to designated floor.
• State 92 - Fire Service Phase II: Manual firefighter control mode.
• State 99 - Fault Mode: System fault detected, require service technician reset.

State Machine Implementation

// Main Elevator Control State Machine
FUNCTION_BLOCK FB_Elevator_Control
VAR_INPUT
    Safety_OK : BOOL;           // From safety PLC
    Fire_Service_Active : BOOL;
    Current_Floor : INT;        // 0-9 for B-9
END_VAR

VAR_OUTPUT
    Door_Command : INT;         // 0=none, 1=open, 2=close
    VFD_Speed_Ref : REAL;
    Brake_Request : BOOL;
    System_Status : STRING;
END_VAR

VAR
    State : INT := 0;
    Car_Calls : ARRAY[0..9] OF BOOL;
    Hall_Calls_UP : ARRAY[0..8] OF BOOL;
    Hall_Calls_DN : ARRAY[1..9] OF BOOL;
    Target_Floor : INT;
    Direction : INT;            // 0=down, 1=up
    Dwell_Timer : TON;
END_VAR

// Fire Service Override
IF Fire_Service_Active AND State < 90 THEN
    State := 91;  // Fire service recall
END_IF;

// Main State Machine
CASE State OF
    0: // Idle - Doors Open, No Calls
        System_Status := 'IDLE';
        Door_Command := 1;  // Keep doors open
        VFD_Speed_Ref := 0;
        Brake_Request := TRUE;

        // Check for any calls
        IF ANY_Car_Calls OR ANY_Hall_Calls THEN
            Target_Floor := Calculate_Next_Floor();
            State := 1;  // Begin door closing
        END_IF;

    1: // Door Closing
        System_Status := 'CLOSING DOORS';
        Door_Command := 2;  // Close doors

        IF Doors_Fully_Closed AND All_Interlocks_OK THEN
            State := 2;  // Prepare for travel
            Setup_Motion_Profile();
        ELSIF Door_Obstruction_Detected THEN
            State := 10;  // Handle obstruction
        END_IF;

    2: // Travel Setup
        System_Status := 'PREPARING TO MOVE';

        IF Safety_OK AND Brake_Request THEN
            Brake_Request := FALSE;  // Release brake
            Wait_For_Brake_Release();

            IF Brake_Released_Confirmed THEN
                State := 3;  // Start acceleration
                Motion_Timer := 0;
            END_IF;
        END_IF;

    3: // Acceleration Phase
        System_Status := 'ACCELERATING';

        // Calculate S-curve acceleration profile
        VFD_Speed_Ref := Calculate_Profile_Speed(Motion_Timer);
        Motion_Timer := Motion_Timer + Cycle_Time;

        IF Current_Speed >= Target_Speed THEN
            State := 4;  // Constant speed
        ELSIF Distance_To_Floor < Decel_Required THEN
            State := 5;  // Skip to deceleration
        END_IF;

    4: // Constant Speed Travel
        System_Status := 'TRAVELING';
        VFD_Speed_Ref := Rated_Speed;

        // Monitor for deceleration point
        IF Distance_To_Floor <= Deceleration_Distance THEN
            State := 5;
            Motion_Timer := 0;
        END_IF;

    5: // Deceleration Phase
        System_Status := 'DECELERATING';

        VFD_Speed_Ref := Calculate_Decel_Speed(Distance_To_Floor);

        IF Distance_To_Floor < 100 THEN  // Entering leveling zone
            State := 6;
        END_IF;

    6: // Final Leveling
        System_Status := 'LEVELING';

        Position_Error := Target_Position - Current_Position;

        IF ABS(Position_Error) > 5.0 THEN
            // Proportional leveling control
            VFD_Speed_Ref := Position_Error * 0.5;  // Simple P control
        ELSE
            // Within tolerance, stop
            VFD_Speed_Ref := 0;
            State := 7;
        END_IF;

    7: // Stopped, Apply Brake
        System_Status := 'STOPPED';
        VFD_Speed_Ref := 0;
        Brake_Request := TRUE;

        IF Brake_Applied_Confirmed THEN
            State := 8;  // Open doors
        END_IF;

    8: // Door Opening
        System_Status := 'OPENING DOORS';
        Door_Command := 1;

        IF Doors_Fully_Open THEN
            Dwell_Timer(IN:=TRUE, PT:=T#5s);

            IF Dwell_Timer.Q THEN
                Dwell_Timer(IN:=FALSE);

                // Clear served calls
                Car_Calls[Current_Floor] := FALSE;
                IF Direction = 1 THEN
                    Hall_Calls_UP[Current_Floor] := FALSE;
                ELSE
                    Hall_Calls_DN[Current_Floor] := FALSE;
                END_IF;

                // Check for more calls
                IF Calculate_Next_Floor() >= 0 THEN
                    State := 1;  // More calls, close doors
                ELSE
                    State := 0;  // Return to idle
                END_IF;
            END_IF;
        END_IF;

    10: // Door Obstruction Handling
        System_Status := 'DOOR OBSTRUCTION';
        Door_Command := 1;  // Re-open doors
        Reopen_Counter := Reopen_Counter + 1;

        IF Doors_Fully_Open THEN
            IF Reopen_Counter >= 5 THEN
                State := 99;  // Service required
                System_Status := 'EXCESSIVE REOPENS - SERVICE REQUIRED';
            ELSE
                State := 1;  // Try closing again
                Obstruction_Timer(IN:=TRUE, PT:=T#3s);
            END_IF;
        END_IF;

    90: // Emergency Stop
        System_Status := 'EMERGENCY STOP';
        VFD_Speed_Ref := 0;  // Immediate stop command
        Brake_Request := TRUE;
        Door_Command := 0;

        // Require manual reset from service technician
        IF Safety_OK AND Service_Reset_Key THEN
            State := 0;
        END_IF;

    91: // Fire Service Phase I - Recall
        System_Status := 'FIRE SERVICE RECALL';
        Target_Floor := Fire_Recall_Floor;

        // Similar to normal travel but non-stop
        // (Implementation similar to states 2-8)

    99: // Fault State
        System_Status := 'SYSTEM FAULT - SERVICE REQUIRED';
        VFD_Speed_Ref := 0;
        Brake_Request := TRUE;
        Door_Command := 0;

        // Log fault details
        // Require service technician intervention

END_CASE;

END_FUNCTION_BLOCK

Chapter 8: Best Practices for Elevator PLC Programming

Safety Code Compliance and Standards

ASME A17.1 Safety Code for Elevators and Escalators (North America) establishes comprehensive requirements for elevator design, construction, operation, inspection, testing, maintenance, alteration, and repair. PLC programming must implement all required safety functions, interlocks, emergency operations, and protective devices exactly as specified in applicable code sections.

EN 81 Safety Rules for Lifts (Europe and International) provides similar safety requirements with some variations in specific implementations and testing procedures. Programmers must understand which standard applies to their jurisdiction and ensure complete compliance with all safety requirements.

ISO 25745 Energy Performance Standards guide energy-efficient elevator design and programming, establishing measurement methods and efficiency classifications. Programming optimization for energy reduction must not compromise safety or code compliance.

Third-party safety certification through organizations such as TÜV, UL, or equivalent certification bodies validates that safety PLC programming meets applicable standards. This certification process requires detailed documentation, systematic testing, and independent verification of safety function implementation.

Redundancy and Fail-Safe Design Principles

Dual-channel safety monitoring implements redundant sensing and verification of all critical safety functions to detect single-point failures before they compromise safety. Programming compares redundant channel inputs and triggers safe shutdown if discrepancies indicate potential failures.

Fail-safe defaults ensure that system failures result in safe conditions rather than hazardous states. Power loss, communication failures, or component faults should automatically trigger brake application, door closing inhibit, and drive disable through de-energize-to-safe output design.

Watchdog timer implementation monitors PLC program execution and triggers emergency shutdown if the control program stops executing properly due to processor faults, infinite loops, or other software failures. Safety PLCs include certified watchdog functions with hardware-based monitoring.

Graceful degradation strategies allow elevator systems to continue limited operation when non-critical components fail rather than complete system shutdown. Example: One light curtain beam failure allows continued operation with reduced safety margin rather than complete service loss, while maintaining adequate passenger protection.

Diagnostic and Troubleshooting Features

Real-time status monitoring provides service technicians with clear indication of current system state, active calls, door position, car location, drive status, and safety circuit conditions through HMI displays or diagnostic software. Programming should make all relevant operating parameters visible for troubleshooting.

Fault logging systems automatically record all safety activations, system faults, abnormal conditions, and service interventions with timestamps and detailed fault descriptions. These logs support troubleshooting, regulatory compliance, and predictive maintenance programs.

Built-in diagnostics test individual components and subsystems through automated or technician-initiated test sequences that verify proper operation of doors, interlocks, brakes, position sensors, and other critical components. Programming guides technicians through systematic testing procedures.

Remote monitoring capabilities enable service organizations to access elevator performance data, fault logs, and operational statistics through secure network connections, reducing service response times and enabling proactive maintenance interventions before failures occur.

Maintenance Mode Programming

Inspection operation mode allows technicians to control elevator at reduced speed (typically 0.3 m/s or less) using maintained push buttons on top of car or in pit for maintenance and inspection activities. This mode bypasses normal call management while maintaining critical safety protections.

Access control for maintenance modes requires key switches, code entry, or other security measures to prevent unauthorized access to maintenance functions that bypass normal operating limitations. Programming should clearly indicate when maintenance modes are active.

Test mode capabilities enable systematic testing of safety functions, door operation, motion control, and other system features through structured test sequences. Programming may implement semi-automated test procedures that verify proper operation and generate test reports.

Service interval tracking monitors operating hours, trip counts, door cycles, and other usage metrics to schedule preventive maintenance activities. Programming can alert service organizations when maintenance intervals approach and track maintenance completion.

Ride Comfort Optimization

Jerk minimization through proper S-curve profile tuning provides smooth, comfortable acceleration changes that prevent passenger discomfort. Programming parameters for jerk limits, acceleration rates, and profile shaping should be tunable based on building usage, passenger preferences, and equipment characteristics.

Vibration reduction strategies adjust motion profiles to avoid resonant frequencies of building structure, elevator components, or guide rail irregularities that create uncomfortable vibrations. Advanced systems use accelerometers and adaptive algorithms to minimize vibration automatically.

Floor approach optimization ensures smooth, accurate leveling that prevents jarring stops or multiple positioning adjustments. Programming should include adaptive learning that improves leveling accuracy over time by compensating for system variations.

Door operation tuning balances door cycle time against noise and smoothness, adjusting acceleration, speed, and closing force to provide quick service without harsh door operation. Different door timing may be appropriate for different traffic conditions (light traffic vs. peak periods).

Frequently Asked Questions About Elevator PLC Programming

What PLC is used for elevator control?

Elevator control systems typically use safety-rated PLCs certified to SIL2 or SIL3 standards such as Siemens S7-1500F Safety PLCs, Allen-Bradley GuardLogix controllers, Schneider Electric Preventa safety systems, or specialized elevator controllers from manufacturers like Wittur, Montanari, or Selcom. Standard industrial PLCs from Mitsubishi, Omron, and other manufacturers also serve elevator applications when combined with separate certified safety modules for critical functions.

Safety certification requirements mandate that PLCs controlling passenger elevators meet specific safety standards (IEC 61508, ISO 13849) with certified hardware and software that prevent dangerous failures from compromising passenger safety. Many elevator manufacturers develop proprietary PLC-based controllers optimized for elevator applications with pre-certified safety functions and standardized programming templates.

How do elevators know which floor to go to?

Elevators determine destination floors through call management systems that register and prioritize car calls (buttons pressed inside the car) and hall calls (up/down buttons at landings). The PLC control program maintains call registers storing active calls and implements dispatching algorithms that select the next target floor based on car position, direction of travel, and optimization strategies.

Simple simplex elevators serve calls sequentially in direction of travel (all up calls from bottom to top, then all down calls from top to bottom), while sophisticated group elevator systems use complex algorithms considering wait time prediction, car loading, traffic patterns, and energy optimization to assign calls to specific cars and determine optimal stopping sequences.

Modern destination dispatch systems ask passengers to enter their destination floor at hall call stations before boarding, allowing the dispatching algorithm to group passengers traveling to similar floors in the same car and optimize travel sequences for reduced wait times and energy consumption.

What is elevator group control?

Elevator group control coordinates multiple elevators serving the same floors to optimize overall system performance through intelligent call assignment, coordinated dispatching, and traffic pattern adaptation. The group control algorithm analyzes all active calls, car positions, loading levels, and travel directions to assign each hall call to the elevator that can provide the best service based on optimization objectives.

Advanced group control systems predict passenger arrival patterns based on historical traffic data, time of day, and building occupancy to pre-position cars at floors where demand is expected. During morning up-peak traffic, the system may dispatch empty cars to the lobby automatically to minimize wait times as passenger traffic builds.

Sophisticated implementations include features such as load-based dispatching that considers car capacity, adaptive sector assignment that divides the building into zones during peak periods, and energy optimization that minimizes total system energy consumption while maintaining acceptable service quality.

How does door safety work in elevators?

Elevator door safety systems use multiple redundant protection methods to prevent passenger injury during door operation. Light curtains project infrared beams across the door opening and trigger immediate door reversal if any beam is interrupted during closing, detecting passengers or objects in the doorway. Door edge sensors or pressure-sensitive edges provide backup obstruction detection if light curtain systems fail.

Electronic force limiting continuously monitors door motor current and limits maximum closing force to safe levels (typically 10-15 pounds force), automatically reversing doors if resistance exceeds limits. This protection works even if light curtains and door edges fail to detect obstructions.

Door interlocks prevent elevator movement unless all landing doors and car doors are fully closed and mechanically locked, eliminating the possibility of car movement with open doors. Modern coded interlocks prevent simple bypass attempts and provide diagnostic feedback to the control system.

Programming implements multiple layers of protection including light curtain monitoring with individual beam failure detection, force limiting with adjustable thresholds, re-opening counters to prevent indefinite delay, and nudging mode for persistent obstructions.

What is fire service mode?

Fire service mode provides dedicated elevator control for firefighter emergency operations according to strict safety standards (ASME A17.1 or EN 81-73). Phase I fire service activates automatically when building fire alarm signals are received or through manual key switch activation at the designated fire recall floor, commanding all elevators to return non-stop to the recall floor with doors open and all calls cancelled.

Phase II fire service allows firefighters to take manual control of a specific elevator car using key switches and maintained push buttons inside the car. In this mode, normal automatic operation is suspended and firefighters control car movement and door operation directly, with certain safety protections (such as overspeed detection) remaining active while others (door interlocks, call management) are bypassed.

Programming must implement fire service with absolute priority over all other modes, provide continuous visual indication of fire service status, prevent mode cancellation without proper key switch operations, and maintain detailed operational requirements specified in fire safety codes.

Fire service mode enables firefighters to access upper floors for evacuation and firefighting operations when stairways may be compromised by smoke or fire, providing critical emergency access in high-rise buildings.

How is elevator position measured?

Modern elevator position measurement uses absolute or incremental encoders mounted on the motor shaft or drive sheave, providing high-resolution digital feedback of car position throughout the hoistway. Absolute encoders provide position information immediately upon power-up without homing, using multi-turn counting that tracks total rotation over the full hoistway height.

Encoder resolution typically ranges from 1,024 to 65,536 pulses per motor revolution, translating to sub-millimeter position accuracy when combined with sheave diameter calculations. The PLC counts encoder pulses and calculates actual car position using the relationship between sheave rotation and cable/belt travel distance.

Backup position verification uses fixed floor position sensors (magnetic, inductive, or optical) mounted in the hoistway at each floor to confirm encoder position accuracy and provide redundant position information for safety functions. The control program continuously compares encoder-based position to floor sensor positions and triggers faults if significant discrepancies occur.

Some systems use laser distance measurement, ultrasonic sensors, or cable-mounted position systems as alternatives or supplements to encoder-based positioning, particularly in retrofit applications or specialized elevator configurations.

What safety standards apply to elevator PLCs?

Elevator PLC safety systems must comply with IEC 61508 (Functional Safety of Electrical/Electronic/Programmable Electronic Safety-Related Systems) at Safety Integrity Level 2 or 3, establishing requirements for hardware reliability, software development processes, and systematic capability to prevent dangerous failures.

ISO 13849 (Safety of Machinery - Safety-Related Parts of Control Systems) provides additional safety requirements for control system design, implementation, and validation, specifying required Performance Levels and validation procedures for safety functions.

Elevator-specific safety standards including ASME A17.1 (North America), EN 81-1/81-2 (Europe), and national/regional codes establish detailed requirements for elevator safety functions, protective devices, emergency operations, and testing procedures that PLC programming must implement exactly as specified.

Third-party safety certification through organizations such as TÜV Rheinland, UL (Underwriters Laboratories), or equivalent certification bodies validates that PLC hardware and software implementations meet applicable safety standards through independent testing and verification.

How do you program S-curve motion profiles?

S-curve motion profile programming calculates position, velocity, and acceleration setpoints at each control cycle to provide smooth acceleration changes (controlled jerk) that improve passenger comfort. The profile divides motion into distinct phases: jerk-in (increasing acceleration), constant acceleration, jerk-out (decreasing acceleration), constant velocity, deceleration jerk-in, constant deceleration, deceleration jerk-out, and final positioning.

Implementation typically uses time-based or position-based profile generation algorithms that calculate current phase parameters based on elapsed time, distance traveled, and remaining distance to target. Programming must account for maximum velocity, maximum acceleration, maximum jerk limits, and distance available to ensure the profile completes exactly at the target position.

Load-dependent profile adjustment modifies acceleration and jerk limits based on measured car load to maintain consistent passenger comfort. Heavy loads require reduced acceleration to achieve the same jerk levels as lighter loads, requiring real-time profile parameter calculation.

Advanced implementations use mathematical equations (typically third-order polynomials) to generate smooth continuous profiles, or use lookup tables with interpolation for computational efficiency in less powerful PLCs. The profile generator updates the VFD speed reference every control cycle (typically 10-20ms) to maintain smooth control throughout the motion sequence.

What is nudging mode in elevators?

Nudging mode activates when elevator doors remain open beyond maximum time limits (typically 20-30 seconds) due to passenger interference, persistent obstructions, or high boarding activity. In this mode, the door operator attempts to close doors with reduced force while sounding continuous buzzers or tones to alert passengers to clear the doorway.

Programming implements nudging mode after normal door dwell time expires and several re-opening attempts have occurred, providing clear audible warning while maintaining reduced closing force to prevent passenger injury. Doors close more slowly in nudging mode with very limited force that stops immediately on any obstruction.

Most elevator codes require that nudging mode eventually succeed in closing doors to prevent indefinite service interruption, allowing slightly higher closing force in nudging mode than normal operation while remaining well below injury thresholds. Some implementations use progressive nudging with gradually increasing force over multiple attempts.

Service timeout features limit total time in nudging mode before triggering service alerts, preventing complete service loss from vandalism or equipment malfunctions while maintaining passenger safety. After excessive nudging time, the system may take the elevator out of service and notify maintenance personnel.

How do light curtains integrate with PLCs?

Light curtain integration connects transmitter and receiver modules to PLC digital inputs, with each receiver output indicating beam status (made/broken) for its corresponding infrared beam. Modern light curtains typically include 8-32 individual beams spaced vertically across the door opening, providing comprehensive obstruction detection coverage.

PLC programming monitors all light curtain input channels, triggering immediate door reversal if any beam is interrupted during door closing operation. Response time from beam interruption to door reversal command must be less than 100 milliseconds to prevent passenger contact with closing doors.

Advanced light curtain systems include diagnostic communication through serial interfaces or industrial networks, providing detailed status information including individual beam signal strength, alignment quality, environmental interference detection, and component health monitoring. Programming uses this diagnostic data to distinguish between genuine obstructions and system faults.

Intelligent light curtain integration implements features such as selective beam blanking (ignoring specific beams under defined conditions), sensitivity adjustment based on ambient light conditions, and sequential scanning to reduce electrical noise susceptibility. Safety validation ensures that all light curtain monitoring meets applicable safety standards and provides certified safety performance.

Conclusion: Building Safe and Efficient Elevator Control Systems

Elevator PLC programming combines sophisticated motion control algorithms, comprehensive safety monitoring, intelligent call management, and precise door operation to create transportation systems that safely and efficiently move millions of passengers daily in buildings worldwide. Success requires deep understanding of elevator mechanical systems, rigorous safety standards compliance, and systematic programming approaches that ensure reliable operation under all conditions.

The evolution toward intelligent building integration, energy optimization, and predictive maintenance continues to expand the role of PLC programming in modern elevator systems. Future elevator control will increasingly incorporate machine learning for traffic prediction, digital twin technology for system optimization, and IoT connectivity for comprehensive building automation integration.

Whether programming simple hydraulic elevators or complex high-rise traction systems, the fundamental principles remain constant: safety first, systematic approach to complex control sequences, comprehensive testing and validation, and continuous monitoring for faults and performance degradation. Following these principles and the detailed guidance in this comprehensive guide enables development of elevator control systems that meet the extremely high safety and reliability standards required for passenger transportation applications.

Continue developing your elevator control programming expertise through hands-on experience with actual elevator systems, systematic study of applicable safety codes and standards, and collaboration with experienced elevator technicians and engineers who understand the critical importance of every line of code in these safety-critical applications.