Choosing a Sequencing Logic Without Sacrificing Adaptability to Varied Loads

Lift sequencing logic is the brain of any multi-car elevator system. It decides which car goes where when someone presses a button. Get it wrong, and you get long waits, bunching, high energy bills. Get it right? Smooth rides, happy tenants. But the problem is: most sequencing logics are designed for a narrow load range. They shine during the morning rush, then choke when traffic mixes—say, lunchtime or after-school. This article is a how-to for choosing a logic that stays adaptable when loads vary wildly. No fluff. Just a workflow you can apply to your building or project.

Who Needs This and What Goes Wrong Without It

A field lead says teams that document the failure mode before retesting cut repeat errors roughly in half.

Building types that struggle with fixed logic

Not every building needs the same sequencing brain. A 40-story office tower with uniform 9-to-5 traffic can tolerate—actually prefers—rigid order: express up in the morning, local down in the evening, repeat. But throw that same fixed logic at a mixed-use complex with residential, retail, and a school, or a hospital where load surges unpredictably, and the whole scheme cracks. I have seen this split facilities: one crew thrives on predictability; the other stalls, stuck with long waits, or burns energy cycling empty cars. The audience for adaptable sequencing is any building whose load changes hour-to-hour—hotels, hospitals, mixed-use towers, university campuses. If your traffic includes a surprise event or a shift change, fixed sequencing is a liability, not a plan.

Symptoms of poor sequencing: bunching, long waits, energy spikes

Bunching. That is the first visible symptom—three cars arrive at the lobby within 12 seconds, then none for 90 seconds. Wrong order. Next comes the wait—a passenger stands idle for eight minutes because the logic assumed even interfloor traffic, but today a maintenance crew moved floor-by-floor for 20 minutes. The standard 90-second interval becomes a purgatory. Energy spikes are subtler: the system runs all six cars during a low-demand period because the logic cannot consolidate calls. That sounds fine until the seam blows out on your monthly utility bill—a 15% spike from unnecessary starts and stops. Most teams skip this: they assume the sequence on paper is the sequence performed.

Real cost of ignoring adaptability

The catch is tangible. Ignoring adaptability costs you operational efficiency. When sequencing logic is rigid, returns spike—not from overuse in the classic sense, but from wasted motion. Cars run half-empty. Wait times jump. Tenants complain. I fixed this once for a 12-story hotel where guests waited up to 6 minutes during checkout hours. The logic was fixed: cars always returned to ground after a trip. We swapped to a 'load-aware' rule: cars parked at the last drop-off floor unless the lobby queue exceeded 4 calls. No hardware change. Average wait dropped 35% in one month. That is the cost of ignoring adaptability: not a dramatic crash, but a slow leak of satisfaction you only notice when you plug it.

Fixed sequencing treats every building like a scripted play. The traffic is improv, not Shakespeare.

— conversation with a lift engineer who rebuilt his logic after three consecutive bunching complaints

Worth flagging—the alternative is not chaos. No one is advocating random dispatching. But the line between adaptable logic and no logic is thinner than most admit: a few anchor rules fixed, the rest flexible within a bracket of load or time. That small shift prevents the quiet failure of a plan that looks perfect on a spreadsheet but crumples under real traffic.

Prerequisites: What You Must Know Before Choosing a Logic

Understanding Your Building's Traffic Patterns

Before you touch any logic parameter, you need a brutally honest picture of how people actually move through your building. Not the idealized version from the architect's brochure — the real grind. I have watched teams waste weeks tuning a sequencing algorithm only to discover their morning peak is actually two micro-peaks separated by fifteen minutes of near-silence. That changes everything. Walk the lobby during arrival hours. Count heads, not just elevator button presses. The tricky part is that interfloor traffic often hides in plain sight: that mid-morning surge from the 4th-floor cafeteria to the 12th-floor sales wing looks like random noise on a raw data dump, but it is a predictable pattern that will shred a logic optimized for express-zone only traffic. Watch for the ≤ eight-second door dwell that riders hate but seldom report — those small stalls cascade into 20% longer round trips during peak. One rhetorical question worth asking yourself: would your current data capture a janitorial crew moving floor-by-floor at 7 PM, or would it treat them as a series of unrelated single calls?

Traffic profiling isn't about having more data. It's about knowing which 15% of that data predicts where your sequencing will choke.

— Senior field technician, high-rise retrofit project

Car Specifications: Speed, Capacity, Door Times

Most teams skip this: they treat every car as a uniform transport unit. That hurts. A 1600 kg car with 2.5 m/s travel speed and 4-second door open time behaves fundamentally differently from a 1250 kg car doing 4 m/s with fast-opening doors. The sequencing logic that works beautifully for the fast car will leave the slower one perpetually late, triggering phantom hall calls as the system tries to compensate. Write down your contract speed, rated load, and — critically — the actual measured door cycle time, not the manufacturer's optimistic spec. I have seen a 1.2-second gap between rated and real door performance flip a zone-dispatch logic from efficient to chaotic. Do not assume symmetry either. The A car might have different acceleration curves than the B car after a decade of wear; your logic must tolerate that variance or you will burn maintenance hours chasing ghost faults.

Peak-Hour Intervals and Interfloor Traffic

The standard five-minute interval report is a lie. Not malicious — just too coarse. A sequencing logic that handles average density well can collapse when the true interval drops to 90 seconds for a four-minute stretch. That compression is where adaptability gets tested. Pull five-second resolution traffic logs if you can; if not, stand in the lobby with a stopwatch and mark every arrival burst. The real failure mode emerges when interfloor traffic constitutes more than 30% of total calls during what you thought was a 'down peak.' That mix fools directional-dominant logics into sending empty cars to the lobby while six people wait on floor 8. One building I worked with had a 9:45 AM ritual: half the legal team rode down two floors to grab coffee, then rode back up. That looked like reverse traffic on paper but acted like chaotic local hall calling. Your prerequisites must include a manual sniff test for these invisible patterns — no algorithm corrects for data you never collected.

Core Workflow: Four Steps to Select an Adaptable Logic

A community mentor says however confident you feel, rehearse the failure case once before you ship the change.

Step 1: Define your load profiles

Start by admitting you don't know what tomorrow's traffic looks like. Nobody does. But you can categorize what has already hit your system. Pull three distinct snapshots: the daily grind (steady 200 requests/second), the calendar spike (Black Friday or patch-Tuesday surge), and the weird outlier — that random 3 AM bot swarm that nearly took you down last quarter. Label these profiles by arrival pattern, not just volume. Is the traffic Poisson-distributed, or does it clump? I have seen teams skip this step and then wonder why their elegant round-robin logic collapses under a sudden batch of long-lived connections. Wrong profiles = wrong logic. Build a table of load shapes, not just peak numbers.

The tricky part is resisting the urge to copy a sequencing logic from a blog post. You need raw data: export one week of request timestamps, measure inter-arrival times, and look for correlation. Burstiness — that's your enemy. A logic that shines in a lab with uniform 10 ms gaps will punish you when 400 requests arrive in the same millisecond. Most teams skip this: they jump to simulation without understanding what their actual load does.

Step 2: Simulate candidate logics against each profile

Now you run the candidates — least-connections, round-robin, weighted random, maybe a two-level adaptive queue — against those load shapes. Not out of a textbook. Reproduce your exact infrastructure: same database connection pool limits, same background GC pauses, same network jitter you can't fix. Simulation must punish your logic with real-world friction. I once watched a team waste two days because their simulation used zero-latency channels and then their production logic fell over under 15 ms of variance. The catch is simulating at scale takes time; shortcut with a micro-benchmark first to kill obviously bad candidates.

One rhetorical question: does your candidate logic degrade gracefully or cliff-dive? A logic that stays predictable at 60% capacity but jams at 70% is a trap. You want a curve, not a wall. Worth flagging—simulating the 'weird outlier' profile often reveals hidden priority inversions. A random pick that works fine under steady state can starve short requests when a fat batch of long writes hits the same backend.

Step 3: Measure KPIs (wait time, energy, bunching)

Wait time is obvious. Energy consumption — less so but critical if you run on spot instances or battery-backed edges. Bunching is the silent killer: a sequencing logic that dispatches tasks in tight clusters will amplify queue lengths and spike tail latency. Measure the covariance between inter-departure times. Low variance sounds good until you realize no variance means zero flexibility; your logic has become a metronome that ignores real-world arrival bursts. Why pick a logic that burns power evenly when the load is lumpy?

That sounds fine until you notice the trade-off: minimizing wait time often increases bunching, and spreading tasks smoothly can raise total energy if you keep cores idling less efficiently. You cannot optimize all three. Pick your primary KPI based on the load profile that matters most. For a real-time bidding system, wait time dominates. For a drone-fleet controller, energy eats everything. Write your loss function before you look at simulation results — otherwise you'll cherry-pick the logic that happens to excel in a test you didn't design.

Step 4: Select and build a fallback strategy

Choose the best performer across your top two load profiles, then embed a fallback that activates when a third profile suddenly appears. I mean code-level fallback — not a manual toggle. A simple hedge: if average wait time exceeds 2× your baseline for 10 seconds, switch to a conservative sequencing (e.g., round-robin with a max concurrency cap) until metrics recover. This isn't elegant, but it survives. Perfect adaptability is a myth; working adaptability is a fallback that triggers before the dashboard goes red.

Most teams build one logic and pray. Don't. Implement a watchdog that compares actual KPIs to your simulated projections — if they diverge by 30%, raise a hard alarm and fail over. Your logic should adapt its own selection once per minute, not once per deployment. This is the point where theory meets ops: you'll discover that your simulation missed a subtle dependency on garbage collection cycles or a third-party API that slows down unpredictably. That's fine. Your fallback is the patch that keeps the system alive until you re-run the workflow with updated load profiles.

— Preview of next step: Tools like wrk2 and custom queue simulation scripts, plus the environmental realities that kill most logics in production.

Tools, Setup, and Environment Realities

Simulation software: the cheap, the pro, and the trap

You need a way to test your sequencing logic before it touches live loads. Open-source options exist—OpenModelica, Scilab/Xcos, and Python with simpy for discrete-event simulation. They cost nothing in licensing but eat time in setup and debugging. I have seen teams burn two weeks wiring custom Python blocks only to discover their state machines miss a simple race condition that a commercial tool would have caught in the first hour.

Commercial platforms like Simulink Stateflow or ETAS ASCET give you prebuilt libraries for event-triggered logic—lift controllers, conveyor handshakes, multi-zone priority queues. The price tag stings: $3,000–$15,000 per seat, plus annual maintenance. What you buy is validation pace. A drag-and-drop transition from 'request_A_high' to 'assign_car_1' in 20 minutes versus three hours of debugging a custom event loop. The trade-off? Vendor lock-in. If your real-world loads later force a logic twist that the tool's library doesn't model, you hack around it or accept suboptimal behavior.

Budget pointer: start with open-source if your system has ≤4 lifts and ≤12 floors. Beyond that, the time spent on tool integration cancels the license savings. One client tried to scale a free-block simulation to 18 floors; the solver crashed on every eighth run. We moved them to a commercial tool—one week of migration, then stable runs. That hurts, but less than a mis-sequenced lobby during peak hours.

Controller APIs and integration: your logic's skin

The sequencing logic must talk to the real controller—PLC, embedded board, or cloud edge node. That means an API layer. Common patterns: OPC UA for industrial controllers, REST endpoints for cloud-connected systems, or raw Modbus TCP for older hardware. The critical question is not 'which protocol' but 'what latency does the API tolerate when logic needs to re-prioritize?'

Most teams skip this: the controller's scan cycle or message queue introduces 50–200 ms delay between logic decision and actuator response. For lift dispatching, that delay is usually fine—unless your logic tries to reassign a car mid-floor. I have debugged a setup where the API call for 'cancel floor call' arrived 150 ms after the car had already stopped. The car opened doors to an empty landing. Embarrassing but not dangerous—still, it wasted 8 seconds per event across 14 cars in a two-hour rush.

What to check: does your controller allow overlay commands that pre-empt its internal scheduler? Some PLCs (Siemens S7-1500, for example) let you shadow the native dispatching with an external logic payload. Others require the external logic to act only as a recommendation—the controller keeps veto power. Worth flagging—if you choose a 'recommendation-only' API, your adaptability cap is the controller's built-in priority rules, not your custom logic.

'We thought we controlled the cars. Turned out we were just shouting suggestions into a closed system.' — field engineer, after a 16-hour commissioning

— Real conversation from a site walkthrough; the fix was a firmware upgrade to enable external override.

Real-time data feeds: what you actually need

For sequencing to adapt to varied loads, you need more than car position and button calls. The three essential signals: car load weight (or pressure sensor per car), door open/close duration per stop (to detect congestion patterns), and event timestamps—down to sub-second if you plan to detect bunching or short-turning patterns. Without load data, your 'adaptable' logic runs blind: it treats an empty car same as one packed with 18 passengers. That kills capacity.

Do you need real-time passenger counting via IR beams or stereo cameras? Not for basic adaptability. A simple load-cell threshold (≥80% = full, ≤20% = empty) gives you 80% of the benefit at 10% of the sensor cost. The catch: load cells drift. Calibrate monthly, or you start assigning cars to floors based on phantom weight from debris or shifted cables.

What usually breaks first is the data feed's timestamp alignment. The controller logs events in its own clock; your logic server runs on NTP. When the two drift apart by 3–5 seconds, sequential logic corrupts—cars get assigned before the previous passenger has fully boarded. We fixed this by inserting a shared time server on the controller subnet and forcing all feeds to log controller_time plus server_received_time as a pair. Not glamorous, but it stopped the intermittent mis-sequencing that had plagued the system for six months.

Variations for Different Constraints

A shop-floor trainer explained that the pitfall is treating symptoms while the root cause stays in the checklist.

Low-budget systems: simple heuristics that work

When hardware budgets shrink, the temptation is to dumb everything down—pick one lift, one sequence, and pray. That hurts. I have seen a six-pump system with $2,500 controllers try to mimic a full VFD-driven array; the sequencing logic thrashed so hard the contactors welded shut. What actually works on a shoestring is a dead-simple heuristic: minimum runtime before reassignment. You set a floor—say 45 seconds—and a ceiling: two starts per hour per unit. The logic doesn't care about load curves; it just rotates the least-run machine into duty and holds it there. That trades efficiency for mechanical longevity. The catch is that on a wildly variable load—think a repair shop where the air demand spikes from 10 cfm to 180 cfm in twenty seconds—this heuristic will lag. Pressure droops, then overshoots. Acceptable? For a facility that can tolerate ±5 psi, yes. For precision pneumatic controls, no. You are trading adaptability for reliability—and on a low-budget site, that trade usually keeps the plant running.

High-performance systems: dynamic zoning and predictive logic

The opposite problem: you have VFDs, networked controllers, and a budget that lets you buy real-time data. Most teams overshoot here—they think more data equals better logic. Wrong order. The mistake is building a sequencing algorithm that reacts to every pressure blip. That creates oscillation. What fixes it is dynamic zoning with a predictive overlay. You split the compressor array into two virtual groups: base-load units that run continuously at 70–90% capacity, and trim units that cycle on only when the predictive model says demand will exceed base output for more than three minutes. The predictive part is key—simple moving-average of the last 30 seconds of mass flow, not raw pressure. I have watched a food plant cut cycling events by 62% just by adding that 30-second window. The trade-off? Tuning the zone boundaries requires a commissioning run under load—skip that and the system will short-cycle the trim units on a Friday afternoon shift change. Worth flagging: high-performance logic also needs a fallback mode. When the network drops, the controller must regress to a fixed-sequence table, not sit idle. That seam between normal and degraded logic is where most commissioning failures hide.

'We installed a predictive sequencer on a four-VFD bank and saw 18% kWH reduction—then a sensor drift caused the trim units to fire every 90 seconds for three days. The logic was smart. The sensor was dumb.'

— conversation with a plant engineer, after root-cause showed the predictive filter was not cross-checked against the pressure transducer's rate-of-change

Retrofitting vs. new installation

Retrofitting an existing compressor room is a different animal than building from scratch. On a greenfield site you can design the sequencing logic around a clean electrical topology—each motor has its own breaker, the PLC has a dedicated comms bus. Retrofits hand you a rat's nest. The most common constraint: you cannot rewire the motor control centers without shutting down production for a week. That means you are stuck with existing start/stop signals running through old relay logic. The workaround is to install a soft-start sequencer panel that taps into the existing pressure switches and runs parallel to the old controls. The trick is building a dry-contact interlock matrix that prevents the old relay logic from fighting the new sequencer. I have seen two controllers simultaneously call for the same lag pump—locked rotor in 1.4 seconds. On new installations you have the luxury of designing the sequence logic to match the actual pipe geometry. Example: if the header is undersized, your logic should never stage two high-cfm units simultaneously—the pressure drop across the pipe will steal all the efficiency. Retrofits rarely have that data; you have to infer from pressure drop measurements at different load points. One practical heuristic: on a retrofit, bias the sequence to favor the smallest machine first and the least-efficient machine last. That buys you time to fix the pipework later.

Pitfalls, Debugging, and What to Check When It Fails

Overfitting to one traffic profile

The most common mistake I see is tuning the sequencing logic against a single traffic snapshot—say, lunch rush in a 12-stop bank—then deploying it into mixed residential, office, and school loads. That sounds fine until a morning peak with 80% ground-floor entries hits a logic optimized for even interfloor distribution. The result? Elevator doors open on empty floors while packed cabs sail past waiting passengers. What usually breaks first is the reversal algorithm: a car that stubbornly continues upward because its direction was set when the car was full, ignoring a heavy down-peak call at the next floor. We fixed this by feeding the logic three distinct day-fragments (low, medium, high imbalance) during validation, not just one 'representative' load.

'A logic that works perfectly at 2 PM can fail catastrophically at 8:15 AM. Your tuning set must reflect the building's actual pulse, not your simulation's convenience.'

— comment from a lift engineer after a hospital retrofit went sideways

Ignoring door dwell times and passenger transfer

Door performance looks like a detail—until it sinks the entire sequencing. Plenty of teams simulate dwell as a flat 3-second add-on per stop. Real buildings? Wheelchairs, strollers, hesitant passengers, or a single delivery cart can stretch a stop to 12 seconds. That changes everything: a logic that batches stops aggressively to reduce trips will instead create a single long stop that delays everyone behind it. Worse, if your logic reassigns calls based on predicted arrival times, the delta between modelled and actual dwell corrupts the decision tree. I have watched a well-intentioned 'zone collect' algorithm reassign a hall call three times in 90 seconds because each projected arrival fell apart under real dwell variance. Debug this by measuring actual door-closed-to-door-opened intervals on site, then feed those real dwell distributions into your model—not the idealised ones. The pitfall is assuming lift mechanics are the bottleneck; often the humans stepping through the doors are.

Common simulation mistakes and how to catch them

A simulation is a story you tell yourself about the building. Most stories miss a chapter. The catch is that garbage-in-garbage-out hides behind pretty graphs. One frequent error: using uniform arrival rates across all floors when any real building has entrance floors with five times the traffic of upper floors. Another: assuming all passengers press their destination immediately upon boarding— in practice people jab the panel, miss, correct, or forget. The simulation logic then overestimates how quickly calls register, skewing the sequencing response.

Debugging method I trust: run the sim with all calls pre-recorded from a manual dispatching day, then compare each car's stop sequence against what your logic produces. If the sequences diverge inside the first five stops, the sequencing logic is overriding dwell or transfer time in ways you did not intend. The second check—force a 5-minute flat simulation with zero passenger variance and see if the logic still behaves rationally. If it cycles or deadheads without cause under perfect conditions, it will fail under chaos. Most teams skip this: they test only under load, never under trivial load. That is the moment a hidden state machine bug lives for. Fix the logic first on the easy case, then stress-test it with the messy human data. Doing it backwards loses a day every time.

Frequently Asked Questions (Prose Answers)

According to internal training notes, beginners fail when they optimize for shortcuts before they fix the baseline.

Can I switch logic mid-day?

Technically, yes. Wisely? Rarely. I have watched teams rebuild their entire sequencing engine during lunch because a load spike hit and the pre-selected logic—say, strict global round-robin—started piling tasks onto a node that was already gasping. They swapped to a smallest-queue-first heuristic with a cooling window, and the backlog cleared. But that fix created a new problem: mid-day switching introduces a grace period where half the in-flight tasks obey the old rules and the new ones follow different criteria. The seam between them blows out if your scheduler doesn't drain active leases first. If you must flip logic during production hours, do it with a gradual rollout—10% of new tasks, then 30%, then full—and watch your completion latency like a hawk. The catch is that most teams skip the dry run and regret it.

What about machine learning for sequencing?

Machine learning sounds like the obvious answer to adaptability—let a model learn load patterns and predict the next optimal order. The tricky part is that ML introduces two failure modes most people don't anticipate: cold start and concept drift. When you deploy a fresh model, it has no history of your queue shapes, so for the first few hours it guesses worse than a simple least-concurrency heuristic. I have seen a team burn three days training a classifier on historical load only to discover that the next week's traffic pattern—a flash sale with unusual product mix—fell outside the training distribution. The model kept re-ordering tasks for orders that never came. That said, if your loads are repetitive and you have months of labeled data, a lightweight online learner can beat static rules. But you must also build a fallback: when model confidence drops below a threshold, revert to a monotonic priority-plus-age logic. No model should ever be the sole decision maker.

What usually breaks first is the feedback loop. The model sees completed tasks, not queued tasks—so it optimizes for what already finished, not what is stuck. Worth flagging—one production incident we fixed by adding a simple watchdog: if any task waited longer than twice the median queue time, the model was overridden and that task jumped the line. Imperfect, but it saved the day.

How often should I reassess my logic?

Not on a calendar schedule. Calendar-based reassessment is the reason most sequencing logic rots—teams review it quarterly, pick a new heuristic from a blog post, and move on. The real answer is: reassess when your load profile visibly shifts. That could be after a product launch, after migrating to a new cloud region, or when error rates for a specific task type double. I recommend setting a single observable metric—p95 task wait time per priority bucket—and when it deviates by more than 25% from the previous week's baseline, trigger a short audit. The audit doesn't need to be a full re-evaluation. Just check: is the current logic still aligning with queue depth? Has the mix of short-lived versus long-lived tasks changed? Most teams over-invest in the initial choice and under-invest in the moment the logic quietly stops fitting.

'We swapped from deadline-aware to FIFO after a three-minute outage. Never ran a comparison. Regretted it for two months.'

— senior SRE, after a conference hallway conversation

One concrete next action: every time you deploy a sequencing change, set a reminder for three weeks later to re-examine the five longest-queued tasks. If they cluster under the same condition—same task type, same origin, same time of day—your logic likely has a blind spot. Fix that blind spot rather than swapping the whole system again. The goal is not a perfect permanent logic; it is a logic that you trust enough to adjust incrementally when the load inevitably changes.

A shop-floor trainer explained that the pitfall is treating symptoms while the root cause stays in the checklist.

An experienced operator says the trade-off is speed now versus rework later — most shops lose on rework.