System Design LLDCase Studies

Elevator System Design

LevelAdvanced

Duration120 mins

TopicCase Studies

3 / 6

State Management Design

The Beating Heart: State Machines in Elevator Systems

If entities are the nouns of our system, state machines are the verbs—they define how entities behave and transition over time. For an elevator system, state management is particularly critical because:

Safety depends on it: An elevator with doors open should never move
User experience depends on it: Passengers expect predictable, responsive behavior
Correctness requires it: Invalid state transitions lead to bugs that are hard to trace

In this page, we design comprehensive state machines for elevator behavior and implement them using the State Pattern, one of the most elegant solutions for managing complex state transitions in object-oriented systems.

What You Will Master

By the end of this page, you will be able to:

• Design finite state machines that model real-world behavior faithfully • Identify states, events, transitions, and guards in a domain • Implement the State Pattern with context, state interface, and concrete states • Handle edge cases through guard conditions and error states • Test state machines systematically

Finite State Machines Fundamentals

A Finite State Machine (FSM) is a mathematical model of computation with:

Finite set of states: All possible conditions the system can be in
Events (inputs): Triggers that can cause state changes
Transitions: Rules defining how events cause state changes
Initial state: The starting state of the system
Final states (optional): Terminal states where processing ends

Why FSMs for Elevators?

Elevators are perfect candidates for FSM modeling because:

The number of possible states is finite and well-defined
State transitions follow strict rules (can't move with doors open)
External events trigger state changes (button press, floor arrival)
Current behavior depends entirely on current state

Components of Our FSM:

FSM Components for Elevator System
Component	Description	Examples
States	Discrete conditions of the elevator	IDLE, MOVING_UP, MOVING_DOWN, STOPPED, DOORS_OPENING, DOORS_OPEN, DOORS_CLOSING, MAINTENANCE
Events	Triggers that can cause transitions	BUTTON_PRESSED, FLOOR_REACHED, DOOR_OPEN_COMPLETE, DOOR_CLOSE_COMPLETE, TIMER_EXPIRED, EMERGENCY
Transitions	State changes in response to events	(IDLE, BUTTON_PRESSED) → MOVING_UP, (MOVING_UP, FLOOR_REACHED) → DOORS_OPENING
Guards	Conditions that must be true for transition	Doors not obstructed, Floor is valid destination
Actions	Operations executed during transitions	Start motor, Stop motor, Notify controller

State Explosion Problem:

One challenge is state explosion—the combinatorial growth of states when modeling multiple aspects. An elevator has:

Movement state (idle, up, down)
Door state (open, opening, closed, closing)
Operational state (normal, maintenance, emergency)

Naively combining these gives 4 × 4 × 3 = 48 states! We'll use hierarchical state machines and orthogonal states to manage complexity.

The Statechart Advantage

UML statecharts (Harel statecharts) extend basic FSMs with hierarchical states and parallel regions. An elevator can be in (MOVING.UP, DOORS.CLOSED) simultaneously—two orthogonal regions updated independently. This keeps complexity manageable.

Elevator Movement State Machine

Let's design the primary state machine governing elevator movement. This focuses on the vertical position and direction of the elevator car.

Movement States:

IDLE: Elevator stationary, no pending requests, awaiting commands
MOVING_UP: Elevator traveling upward between floors
MOVING_DOWN: Elevator traveling downward between floors
STOPPED_AT_FLOOR: Elevator has reached a target floor
MAINTENANCE: Elevator out of service

Movement Events:

REQUEST_UP: Destination above current floor
REQUEST_DOWN: Destination below current floor
FLOOR_SENSOR_TRIGGERED: Elevator detects arrival at a floor
ALL_REQUESTS_SERVED: No more destinations in queue
ENTER_MAINTENANCE: Administrative command
EXIT_MAINTENANCE: Administrative command

State Transition Diagram:

Converting Mermaid diagram...

Transition Rules in Detail:

IDLE → MOVING_UP:

Event: Request received for floor above current
Guard: Doors must be closed
Action: Start motor in UP direction, update direction state

MOVING_UP → STOPPED_AT_FLOOR:

Event: Floor sensor detects we've reached a floor
Guard: This floor is in our destination queue
Action: Stop motor, trigger door opening sequence

MOVING_UP → MOVING_UP (self-transition):

Event: Floor sensor detects we've passed a floor
Guard: This floor is NOT in our destination queue
Action: Update current floor, continue moving

This is a critical distinction—elevators don't stop at every floor, only at destinations.

Movement State Implementation
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
// Movement state enumeration
enum MovementState {
  IDLE = 'IDLE',
  MOVING_UP = 'MOVING_UP',
  MOVING_DOWN = 'MOVING_DOWN',
  STOPPED_AT_FLOOR = 'STOPPED_AT_FLOOR',
  MAINTENANCE = 'MAINTENANCE'
}
 
// Transition table approach (data-driven)
interface Transition {
  from: MovementState;
  event: string;
  guard?: (context: ElevatorContext) => boolean;
  to: MovementState;
  action?: (context: ElevatorContext) => void;
}
 
const movementTransitions: Transition[] = [
  // From IDLE
  {
    from: MovementState.IDLE,
    event: 'REQUEST_UP',
    guard: (ctx) => ctx.doorsAreClosed() && ctx.hasRequestAbove(),
    to: MovementState.MOVING_UP,
    action: (ctx) => ctx.startMotorUp()
  },
  {
    from: MovementState.IDLE,
    event: 'REQUEST_DOWN',
    guard: (ctx) => ctx.doorsAreClosed() && ctx.hasRequestBelow(),
    to: MovementState.MOVING_DOWN,
    action: (ctx) => ctx.startMotorDown()
  },
  {
    from: MovementState.IDLE,
    event: 'ENTER_MAINTENANCE',
    to: MovementState.MAINTENANCE,
    action: (ctx) => ctx.disableButtons()
  },
  
  // From MOVING_UP
  {
    from: MovementState.MOVING_UP,
    event: 'FLOOR_REACHED',
    guard: (ctx) => ctx.shouldStopAtCurrentFloor(),
    to: MovementState.STOPPED_AT_FLOOR,
    action: (ctx) => {
      ctx.stopMotor();
      ctx.triggerDoorOpen();
    }
  },
  {
    from: MovementState.MOVING_UP,
    event: 'FLOOR_REACHED',
    guard: (ctx) => !ctx.shouldStopAtCurrentFloor(),
    to: MovementState.MOVING_UP, // Self-transition
    action: (ctx) => ctx.updateCurrentFloor()
  },
  
  // From MOVING_DOWN
  {
    from: MovementState.MOVING_DOWN,
    event: 'FLOOR_REACHED',
    guard: (ctx) => ctx.shouldStopAtCurrentFloor(),
    to: MovementState.STOPPED_AT_FLOOR,
    action: (ctx) => {
      ctx.stopMotor();
      ctx.triggerDoorOpen();
    }
  },
  
  // From STOPPED_AT_FLOOR
  {
    from: MovementState.STOPPED_AT_FLOOR,
    event: 'DOORS_CLOSED',
    guard: (ctx) => ctx.hasMoreRequestsInCurrentDirection(),
    to: MovementState.MOVING_UP, // or MOVING_DOWN based on context
    action: (ctx) => ctx.continueInDirection()
  },
  {
    from: MovementState.STOPPED_AT_FLOOR,
    event: 'DOORS_CLOSED',
    guard: (ctx) => !ctx.hasMoreRequests(),
    to: MovementState.IDLE,
  },
  
  // From MAINTENANCE
  {
    from: MovementState.MAINTENANCE,
    event: 'EXIT_MAINTENANCE',
    to: MovementState.IDLE,
    action: (ctx) => ctx.enableButtons()
  },
];

Door State Machine

The door state machine operates as an orthogonal region to movement—doors have their own states independent of (but coordinated with) movement.

Door States:

CLOSED: Doors fully closed, elevator can move
OPENING: Doors in process of opening (mechanical transition)
OPEN: Doors fully open, passengers can enter/exit
CLOSING: Doors in process of closing

Door Events:

DOOR_OPEN_COMMAND: Signal to begin opening sequence
DOOR_OPEN_COMPLETE: Physical doors reached open position
DOOR_TIMER_EXPIRED: Dwell time complete, begin closing
DOOR_CLOSE_COMPLETE: Physical doors reached closed position
DOOR_OBSTRUCTED: Obstruction detected during closing
DOOR_OPEN_BUTTON: Passenger pressed door open button
DOOR_CLOSE_BUTTON: Passenger pressed door close button

Converting Mermaid diagram...

Critical Safety Constraint:

The door and movement state machines must coordinate. The fundamental safety invariant:

Movement is only allowed when doors are CLOSED.

This is enforced by making the doorsAreClosed() guard a precondition for any movement transition.

Door Dwell Time Logic:

When doors reach OPEN state:

Start a timer (typically 3-5 seconds)
If timer expires, transition to CLOSING
If 'door open' button pressed, reset timer
If 'door close' button pressed, immediately transition to CLOSING (skip timer)

Door State Implementation
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
enum DoorState {
  CLOSED = 'CLOSED',
  OPENING = 'OPENING',
  OPEN = 'OPEN',
  CLOSING = 'CLOSING'
}
 
class DoorStateMachine {
  private state: DoorState = DoorState.CLOSED;
  private dwellTimer: NodeJS.Timeout | null = null;
  private readonly dwellDuration: number = 3000; // 3 seconds
  
  constructor(
    private readonly onStateChange: (newState: DoorState) => void,
    private readonly onFullyClosed: () => void
  ) {}
  
  getCurrentState(): DoorState {
    return this.state;
  }
  
  // Event handlers
  handleOpenCommand(): void {
    if (this.state === DoorState.CLOSED) {
      this.transitionTo(DoorState.OPENING);
      // Simulate door mechanism (in real system, this is hardware)
      setTimeout(() => this.handleOpenComplete(), 1500);
    }
  }
  
  private handleOpenComplete(): void {
    if (this.state === DoorState.OPENING) {
      this.transitionTo(DoorState.OPEN);
      this.startDwellTimer();
    }
  }
  
  handleCloseButtonPressed(): void {
    if (this.state === DoorState.OPEN) {
      this.cancelDwellTimer();
      this.startClosing();
    }
  }
  
  handleOpenButtonPressed(): void {
    if (this.state === DoorState.OPEN) {
      this.resetDwellTimer();
    } else if (this.state === DoorState.CLOSING) {
      this.transitionTo(DoorState.OPENING);
      setTimeout(() => this.handleOpenComplete(), 1500);
    }
  }
  
  handleObstructionDetected(): void {
    if (this.state === DoorState.CLOSING) {
      // Safety: reopen doors
      this.transitionTo(DoorState.OPENING);
      setTimeout(() => this.handleOpenComplete(), 1500);
    }
  }
  
  private startClosing(): void {
    this.transitionTo(DoorState.CLOSING);
    setTimeout(() => this.handleCloseComplete(), 1500);
  }
  
  private handleCloseComplete(): void {
    if (this.state === DoorState.CLOSING) {
      this.transitionTo(DoorState.CLOSED);
      this.onFullyClosed();
    }
  }
  
  private startDwellTimer(): void {
    this.dwellTimer = setTimeout(() => {
      if (this.state === DoorState.OPEN) {
        this.startClosing();
      }
    }, this.dwellDuration);
  }
  
  private resetDwellTimer(): void {
    this.cancelDwellTimer();
    this.startDwellTimer();
  }
  
  private cancelDwellTimer(): void {
    if (this.dwellTimer) {
      clearTimeout(this.dwellTimer);
      this.dwellTimer = null;
    }
  }
  
  private transitionTo(newState: DoorState): void {
    console.log(`Door: ${this.state} → ${newState}`);
    this.state = newState;
    this.onStateChange(newState);
  }
  
  isClosed(): boolean {
    return this.state === DoorState.CLOSED;
  }
}

Real-World Safety Considerations

In production elevator software, the safety invariants are implemented with hardware interlocks, not just software guards. The door-movement coordination has redundant safety systems. Our software model shows the logical design; certified elevator systems add multiple physical layers.

The State Pattern Implementation

While we could implement state machines with switch statements and conditionals, the State Pattern provides a cleaner, more extensible approach. It encapsulates state-specific behavior in dedicated classes.

State Pattern Structure:

Context: The object whose behavior varies by state (Elevator)
State Interface: Defines the behavior contract for all states
Concrete States: Implementations for each possible state

Benefits of State Pattern:

Single Responsibility: Each state class handles only that state's logic
Open/Closed: Add new states without modifying existing code
Eliminates conditionals: No massive switch statements
Explicit state transitions: State classes control their own transitions
Testability: Each state can be tested in isolation

State Pattern Implementation
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
// State interface - defines behavior for all elevator states
interface IElevatorState {
  // State identity
  getName(): string;
  
  // Event handlers
  onRequestReceived(context: ElevatorContext, request: Request): void;
  onFloorReached(context: ElevatorContext, floor: Floor): void;
  onDoorsOpened(context: ElevatorContext): void;
  onDoorsClosed(context: ElevatorContext): void;
  onEmergency(context: ElevatorContext): void;
  
  // State queries
  canMove(): boolean;
  canOpenDoors(): boolean;
}
 
// Context - the Elevator that uses states
class ElevatorContext {
  private state: IElevatorState;
  private currentFloor: Floor;
  private direction: Direction = Direction.IDLE;
  private destinationQueue: Request[] = [];
  private doorStateMachine: DoorStateMachine;
  
  constructor(initialFloor: Floor) {
    this.currentFloor = initialFloor;
    this.state = new IdleState();
    this.doorStateMachine = new DoorStateMachine(
      (newState) => this.onDoorStateChange(newState),
      () => this.onDoorsFullyClosed()
    );
  }
  
  // State transition
  setState(newState: IElevatorState): void {
    console.log(`Elevator: ${this.state.getName()} → ${newState.getName()}`);
    this.state = newState;
  }
  
  // Forward events to current state
  handleRequest(request: Request): void {
    this.state.onRequestReceived(this, request);
  }
  
  handleFloorArrival(floor: Floor): void {
    this.currentFloor = floor;
    this.state.onFloorReached(this, floor);
  }
  
  // Motor control (abstracted hardware)
  startMotor(direction: Direction): void {
    this.direction = direction;
    console.log(`Motor started: ${direction}`);
  }
  
  stopMotor(): void {
    console.log('Motor stopped');
    // Motor physically stops
  }
  
  // Door delegation
  openDoors(): void {
    this.doorStateMachine.handleOpenCommand();
  }
  
  private onDoorStateChange(doorState: DoorState): void {
    if (doorState === DoorState.OPEN) {
      this.state.onDoorsOpened(this);
    }
  }
  
  private onDoorsFullyClosed(): void {
    this.state.onDoorsClosed(this);
  }
  
  // Queue management
  addDestination(request: Request): void {
    this.destinationQueue.push(request);
    this.sortDestinations();
  }
  
  getNextDestination(): Request | null {
    return this.destinationQueue[0] ?? null;
  }
  
  removeCurrentDestination(): void {
    this.destinationQueue.shift();
  }
  
  hasDestinations(): boolean {
    return this.destinationQueue.length > 0;
  }
  
  shouldStopAtFloor(floor: Floor): boolean {
    return this.destinationQueue.some(
      r => r.floor.equals(floor)
    );
  }
  
  private sortDestinations(): void {
    // Sort by current direction using SCAN algorithm
    // Details in scheduling section
  }
  
  // Queries
  getCurrentFloor(): Floor {
    return this.currentFloor;
  }
  
  getDirection(): Direction {
    return this.direction;
  }
  
  doorsAreClosed(): boolean {
    return this.doorStateMachine.isClosed();
  }
}

Concrete State Implementations:

Now let's implement each concrete state:

Concrete States
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
// IDLE State - elevator stationary, awaiting requests
class IdleState implements IElevatorState {
  getName(): string { return 'IDLE'; }
  
  onRequestReceived(context: ElevatorContext, request: Request): void {
    context.addDestination(request);
    
    const current = context.getCurrentFloor().getFloorNumber();
    const target = request.floor.getFloorNumber();
    
    if (target > current) {
      context.startMotor(Direction.UP);
      context.setState(new MovingUpState());
    } else if (target < current) {
      context.startMotor(Direction.DOWN);
      context.setState(new MovingDownState());
    } else {
      // Already at requested floor
      context.openDoors();
      context.setState(new StoppedAtFloorState());
    }
  }
  
  onFloorReached(context: ElevatorContext, floor: Floor): void {
    // Shouldn't happen in IDLE state
  }
  
  onDoorsOpened(context: ElevatorContext): void {
    // Doors might open in IDLE for various reasons
  }
  
  onDoorsClosed(context: ElevatorContext): void {
    // Remain in IDLE
  }
  
  onEmergency(context: ElevatorContext): void {
    context.setState(new MaintenanceState());
  }
  
  canMove(): boolean { return true; }
  canOpenDoors(): boolean { return true; }
}
 
// MOVING_UP State - elevator traveling upward
class MovingUpState implements IElevatorState {
  getName(): string { return 'MOVING_UP'; }
  
  onRequestReceived(context: ElevatorContext, request: Request): void {
    // Add to queue, will be handled when we reach it
    context.addDestination(request);
  }
  
  onFloorReached(context: ElevatorContext, floor: Floor): void {
    if (context.shouldStopAtFloor(floor)) {
      context.stopMotor();
      context.openDoors();
      context.setState(new StoppedAtFloorState());
    }
    // Otherwise, continue moving (state unchanged)
  }
  
  onDoorsOpened(context: ElevatorContext): void {
    // Invalid - doors shouldn't open while moving
    throw new Error('Safety violation: doors opened while moving');
  }
  
  onDoorsClosed(context: ElevatorContext): void {
    // Doors should already be closed while moving
  }
  
  onEmergency(context: ElevatorContext): void {
    context.stopMotor();
    context.setState(new MaintenanceState());
  }
  
  canMove(): boolean { return true; }
  canOpenDoors(): boolean { return false; }
}
 
// MOVING_DOWN State - elevator traveling downward
class MovingDownState implements IElevatorState {
  getName(): string { return 'MOVING_DOWN'; }
  
  onRequestReceived(context: ElevatorContext, request: Request): void {
    context.addDestination(request);
  }
  
  onFloorReached(context: ElevatorContext, floor: Floor): void {
    if (context.shouldStopAtFloor(floor)) {
      context.stopMotor();
      context.openDoors();
      context.setState(new StoppedAtFloorState());
    }
  }
  
  onDoorsOpened(context: ElevatorContext): void {
    throw new Error('Safety violation: doors opened while moving');
  }
  
  onDoorsClosed(context: ElevatorContext): void {}
  
  onEmergency(context: ElevatorContext): void {
    context.stopMotor();
    context.setState(new MaintenanceState());
  }
  
  canMove(): boolean { return true; }
  canOpenDoors(): boolean { return false; }
}
 
// STOPPED_AT_FLOOR State - elevator at a floor with doors operating
class StoppedAtFloorState implements IElevatorState {
  getName(): string { return 'STOPPED_AT_FLOOR'; }
  
  onRequestReceived(context: ElevatorContext, request: Request): void {
    context.addDestination(request);
  }
  
  onFloorReached(context: ElevatorContext, floor: Floor): void {
    // We're stopped, shouldn't receive this event
  }
  
  onDoorsOpened(context: ElevatorContext): void {
    // Now passengers can enter/exit
    // Remove this floor from destination queue
    context.removeCurrentDestination();
  }
  
  onDoorsClosed(context: ElevatorContext): void {
    // Doors closed, decide next action
    if (!context.hasDestinations()) {
      context.setState(new IdleState());
      return;
    }
    
    const current = context.getCurrentFloor().getFloorNumber();
    const next = context.getNextDestination()!.floor.getFloorNumber();
    
    if (next > current) {
      context.startMotor(Direction.UP);
      context.setState(new MovingUpState());
    } else if (next < current) {
      context.startMotor(Direction.DOWN);
      context.setState(new MovingDownState());
    } else {
      // Next destination is current floor (edge case)
      context.openDoors();
    }
  }
  
  onEmergency(context: ElevatorContext): void {
    context.setState(new MaintenanceState());
  }
  
  canMove(): boolean { return false; }
  canOpenDoors(): boolean { return true; }
}
 
// MAINTENANCE State - elevator out of service
class MaintenanceState implements IElevatorState {
  getName(): string { return 'MAINTENANCE'; }
  
  onRequestReceived(context: ElevatorContext, request: Request): void {
    // Ignore requests in maintenance mode
    console.log('Request ignored: elevator in maintenance');
  }
  
  onFloorReached(context: ElevatorContext, floor: Floor): void {}
  onDoorsOpened(context: ElevatorContext): void {}
  onDoorsClosed(context: ElevatorContext): void {}
  
  onEmergency(context: ElevatorContext): void {
    // Already in maintenance/emergency state
  }
  
  // Administrative action to exit maintenance
  exitMaintenance(context: ElevatorContext): void {
    context.setState(new IdleState());
  }
  
  canMove(): boolean { return false; }
  canOpenDoors(): boolean { return true; }
}

State Transition Validation

Robust state machines enforce invariants—conditions that must always be true—and validate transitions before they occur.

Key Invariants:

System Invariants

•INV-1: Elevator can only move when doors are CLOSED
•INV-2: Doors can only open when elevator is STOPPED
•INV-3: Current floor always matches a valid floor number
•INV-4: Direction is UP only if moving upward, DOWN only if moving downward
•INV-5: Emergency state can be entered from any state

Transition Validation Implementation:

Transition Validation
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
// Transition validator - ensures all invariants hold
class TransitionValidator {
  // Valid transitions defined as (fromState, event) → toState
  private readonly validTransitions: Map<string, Set<string>> = new Map([
    ['IDLE', new Set(['MOVING_UP', 'MOVING_DOWN', 'STOPPED_AT_FLOOR', 'MAINTENANCE'])],
    ['MOVING_UP', new Set(['STOPPED_AT_FLOOR', 'MOVING_UP', 'MAINTENANCE'])],
    ['MOVING_DOWN', new Set(['STOPPED_AT_FLOOR', 'MOVING_DOWN', 'MAINTENANCE'])],
    ['STOPPED_AT_FLOOR', new Set(['IDLE', 'MOVING_UP', 'MOVING_DOWN', 'MAINTENANCE'])],
    ['MAINTENANCE', new Set(['IDLE'])],
  ]);
  
  validateTransition(
    from: IElevatorState, 
    to: IElevatorState,
    context: ElevatorContext
  ): ValidationResult {
    const fromName = from.getName();
    const toName = to.getName();
    
    // Check if transition is in valid set
    const validTargets = this.validTransitions.get(fromName);
    if (!validTargets || !validTargets.has(toName)) {
      return {
        valid: false,
        error: `Invalid transition: ${fromName} → ${toName}`
      };
    }
    
    // Check invariants based on target state
    if (toName === 'MOVING_UP' || toName === 'MOVING_DOWN') {
      if (!context.doorsAreClosed()) {
        return {
          valid: false,
          error: 'INV-1 violation: Cannot move with doors open'
        };
      }
    }
    
    if (toName === 'STOPPED_AT_FLOOR') {
      // Valid, moving to stopped is always allowed
    }
    
    return { valid: true };
  }
}
 
interface ValidationResult {
  valid: boolean;
  error?: string;
}
 
// Enhanced context with validation
class ValidatedElevatorContext extends ElevatorContext {
  private validator: TransitionValidator = new TransitionValidator();
  
  setState(newState: IElevatorState): void {
    const result = this.validator.validateTransition(
      this.getState(), 
      newState, 
      this
    );
    
    if (!result.valid) {
      console.error(`Transition rejected: ${result.error}`);
      // In production, might throw or log to monitoring
      return;
    }
    
    super.setState(newState);
  }
}

Defense in Depth

Notice we validate transitions both in the concrete states (by throwing on invalid events) AND in the context (by checking before applying). This defense-in-depth catches bugs at multiple layers. In safety-critical systems, this redundancy is essential.

Testing State Machines

State machines are highly testable because they have well-defined inputs (events) and outputs (state transitions, actions). Here are strategies for comprehensive testing:

Test Categories:

Individual State Tests: Test each state's response to each event
Transition Tests: Verify correct state changes
Sequence Tests: Test realistic event sequences (scenarios)
Invariant Tests: Verify invariants never violated
Edge Case Tests: Empty queues, repeated events, concurrent events

State Machine Tests
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
describe('Elevator State Machine', () => {
  let context: ElevatorContext;
  
  beforeEach(() => {
    const groundFloor = new Floor(0, 'Ground');
    context = new ElevatorContext(groundFloor);
  });
  
  describe('Idle State', () => {
    it('should transition to MOVING_UP on upward request', () => {
      const floor5Request = Request.createCabCall(new Floor(5));
      context.handleRequest(floor5Request);
      
      expect(context.getState().getName()).toBe('MOVING_UP');
      expect(context.getDirection()).toBe(Direction.UP);
    });
    
    it('should transition to MOVING_DOWN on downward request', () => {
      // First move to floor 10
      context = new ElevatorContext(new Floor(10));
      
      const floor2Request = Request.createCabCall(new Floor(2));
      context.handleRequest(floor2Request);
      
      expect(context.getState().getName()).toBe('MOVING_DOWN');
      expect(context.getDirection()).toBe(Direction.DOWN);
    });
    
    it('should stay IDLE for same-floor request with door cycle', () => {
      const groundRequest = Request.createCabCall(new Floor(0));
      context.handleRequest(groundRequest);
      
      expect(context.getState().getName()).toBe('STOPPED_AT_FLOOR');
      // Doors will open, then close, returning to IDLE
    });
  });
  
  describe('Moving State', () => {
    it('should stop at destination floor', () => {
      const floor5Request = Request.createCabCall(new Floor(5));
      context.handleRequest(floor5Request);
      
      // Simulate arriving at floor 5
      context.handleFloorArrival(new Floor(5));
      
      expect(context.getState().getName()).toBe('STOPPED_AT_FLOOR');
    });
    
    it('should not stop at non-destination floors', () => {
      const floor5Request = Request.createCabCall(new Floor(5));
      context.handleRequest(floor5Request);
      
      // Pass through floors 1-4
      for (let i = 1; i < 5; i++) {
        context.handleFloorArrival(new Floor(i));
        expect(context.getState().getName()).toBe('MOVING_UP');
      }
    });
    
    it('should add requests to queue while moving', () => {
      context.handleRequest(Request.createCabCall(new Floor(10)));
      expect(context.getState().getName()).toBe('MOVING_UP');
      
      // Add another request while moving
      context.handleRequest(Request.createCabCall(new Floor(5)));
      
      // Should still be moving, but floor 5 is now in queue
      expect(context.hasDestinations()).toBe(true);
    });
  });
  
  describe('Safety Invariants', () => {
    it('should never move with doors open', () => {
      context.handleRequest(Request.createCabCall(new Floor(5)));
      context.handleFloorArrival(new Floor(5));
      
      // Now in STOPPED_AT_FLOOR with doors opening
      // Attempt to receive a new request and move
      context.handleRequest(Request.createCabCall(new Floor(10)));
      
      // Should remain stopped until doors close
      expect(context.getState().getName()).toBe('STOPPED_AT_FLOOR');
    });
    
    it('should enter maintenance from any state', () => {
      // From IDLE
      context.handleEmergency();
      expect(context.getState().getName()).toBe('MAINTENANCE');
      
      // Reset and test from MOVING
      context = new ElevatorContext(new Floor(0));
      context.handleRequest(Request.createCabCall(new Floor(10)));
      context.handleEmergency();
      expect(context.getState().getName()).toBe('MAINTENANCE');
    });
  });
  
  describe('Complete Scenarios', () => {
    it('should handle full passenger journey', () => {
      // Passenger at floor 3 wants floor 15
      context.handleRequest(Request.createHallCall(new Floor(3), Direction.UP));
      
      expect(context.getState().getName()).toBe('MOVING_UP');
      
      // Arrive at floor 3
      context.handleFloorArrival(new Floor(3));
      expect(context.getState().getName()).toBe('STOPPED_AT_FLOOR');
      
      // Passenger enters, presses 15
      context.handleRequest(Request.createCabCall(new Floor(15)));
      
      // Doors close (simulated callback)
      context.simulateDoorsClosed();
      expect(context.getState().getName()).toBe('MOVING_UP');
      
      // Arrive at floor 15
      context.handleFloorArrival(new Floor(15));
      expect(context.getState().getName()).toBe('STOPPED_AT_FLOOR');
      
      // Doors close, no more requests
      context.simulateDoorsClosed();
      expect(context.getState().getName()).toBe('IDLE');
    });
  });
});

Test Coverage Strategy

For state machines, aim for 100% transition coverage: every defined transition should be exercised by at least one test. Additionally, test that invalid transitions are rejected or handled gracefully.

Summary and Path Forward

State Management Mastered:

We've designed comprehensive state machines that govern elevator behavior:

Key Accomplishments

•Movement State Machine: IDLE, MOVING_UP, MOVING_DOWN, STOPPED_AT_FLOOR, MAINTENANCE with clear transition rules
•Door State Machine: Orthogonal region handling CLOSED, OPENING, OPEN, CLOSING with timer and obstruction logic
•State Pattern Implementation: Context, state interface, and concrete state classes for extensible design
•Transition Validation: Guards and validators ensuring invariants like 'no movement with doors open'
•Testing Strategy: Comprehensive tests for individual states, transitions, sequences, and invariants

What's Next:

With static entities (previous page) and dynamic behavior (this page) established, we now turn to optimization. The next page covers:

Scheduling algorithms (FCFS, SCAN, LOOK) that determine which requests to serve first
Strategy Pattern implementation for swappable algorithms
Trade-off analysis comparing algorithm performance in different scenarios

The scheduling algorithm is where elevator system design becomes truly interesting—it's the difference between a system that merely works and one that delights users with minimal wait times.

State Design Complete

You now understand how to model complex temporal behavior using finite state machines and the State Pattern. This foundation applies far beyond elevators—any system with distinct modes of operation (orders, workflows, connection states) benefits from explicit state modeling.

3 / 6

Loading learning content...

System Design LLDCase Studies

Elevator System Design

LevelAdvanced

Duration120 mins

TopicCase Studies

3 / 6

State Management Design

The Beating Heart: State Machines in Elevator Systems

Safety depends on it: An elevator with doors open should never move
User experience depends on it: Passengers expect predictable, responsive behavior
Correctness requires it: Invalid state transitions lead to bugs that are hard to trace

What You Will Master

By the end of this page, you will be able to:

Finite State Machines Fundamentals

A Finite State Machine (FSM) is a mathematical model of computation with:

Finite set of states: All possible conditions the system can be in
Events (inputs): Triggers that can cause state changes
Transitions: Rules defining how events cause state changes
Initial state: The starting state of the system
Final states (optional): Terminal states where processing ends

Why FSMs for Elevators?

Elevators are perfect candidates for FSM modeling because:

The number of possible states is finite and well-defined
State transitions follow strict rules (can't move with doors open)
External events trigger state changes (button press, floor arrival)
Current behavior depends entirely on current state

Components of Our FSM:

FSM Components for Elevator System
Component	Description	Examples
States	Discrete conditions of the elevator	IDLE, MOVING_UP, MOVING_DOWN, STOPPED, DOORS_OPENING, DOORS_OPEN, DOORS_CLOSING, MAINTENANCE
Events	Triggers that can cause transitions	BUTTON_PRESSED, FLOOR_REACHED, DOOR_OPEN_COMPLETE, DOOR_CLOSE_COMPLETE, TIMER_EXPIRED, EMERGENCY
Transitions	State changes in response to events	(IDLE, BUTTON_PRESSED) → MOVING_UP, (MOVING_UP, FLOOR_REACHED) → DOORS_OPENING
Guards	Conditions that must be true for transition	Doors not obstructed, Floor is valid destination
Actions	Operations executed during transitions	Start motor, Stop motor, Notify controller

State Explosion Problem:

One challenge is state explosion—the combinatorial growth of states when modeling multiple aspects. An elevator has:

Movement state (idle, up, down)
Door state (open, opening, closed, closing)
Operational state (normal, maintenance, emergency)

Naively combining these gives 4 × 4 × 3 = 48 states! We'll use hierarchical state machines and orthogonal states to manage complexity.

The Statechart Advantage

Elevator Movement State Machine

Let's design the primary state machine governing elevator movement. This focuses on the vertical position and direction of the elevator car.

Movement States:

IDLE: Elevator stationary, no pending requests, awaiting commands
MOVING_UP: Elevator traveling upward between floors
MOVING_DOWN: Elevator traveling downward between floors
STOPPED_AT_FLOOR: Elevator has reached a target floor
MAINTENANCE: Elevator out of service

Movement Events:

REQUEST_UP: Destination above current floor
REQUEST_DOWN: Destination below current floor
FLOOR_SENSOR_TRIGGERED: Elevator detects arrival at a floor
ALL_REQUESTS_SERVED: No more destinations in queue
ENTER_MAINTENANCE: Administrative command
EXIT_MAINTENANCE: Administrative command

State Transition Diagram:

Converting Mermaid diagram...

Transition Rules in Detail:

IDLE → MOVING_UP:

Event: Request received for floor above current
Guard: Doors must be closed
Action: Start motor in UP direction, update direction state

MOVING_UP → STOPPED_AT_FLOOR:

Event: Floor sensor detects we've reached a floor
Guard: This floor is in our destination queue
Action: Stop motor, trigger door opening sequence

MOVING_UP → MOVING_UP (self-transition):

Event: Floor sensor detects we've passed a floor
Guard: This floor is NOT in our destination queue
Action: Update current floor, continue moving

This is a critical distinction—elevators don't stop at every floor, only at destinations.

Movement State Implementation
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
// Movement state enumeration
enum MovementState {
  IDLE = 'IDLE',
  MOVING_UP = 'MOVING_UP',
  MOVING_DOWN = 'MOVING_DOWN',
  STOPPED_AT_FLOOR = 'STOPPED_AT_FLOOR',
  MAINTENANCE = 'MAINTENANCE'
}
 
// Transition table approach (data-driven)
interface Transition {
  from: MovementState;
  event: string;
  guard?: (context: ElevatorContext) => boolean;
  to: MovementState;
  action?: (context: ElevatorContext) => void;
}
 
const movementTransitions: Transition[] = [
  // From IDLE
  {
    from: MovementState.IDLE,
    event: 'REQUEST_UP',
    guard: (ctx) => ctx.doorsAreClosed() && ctx.hasRequestAbove(),
    to: MovementState.MOVING_UP,
    action: (ctx) => ctx.startMotorUp()
  },
  {
    from: MovementState.IDLE,
    event: 'REQUEST_DOWN',
    guard: (ctx) => ctx.doorsAreClosed() && ctx.hasRequestBelow(),
    to: MovementState.MOVING_DOWN,
    action: (ctx) => ctx.startMotorDown()
  },
  {
    from: MovementState.IDLE,
    event: 'ENTER_MAINTENANCE',
    to: MovementState.MAINTENANCE,
    action: (ctx) => ctx.disableButtons()
  },
  
  // From MOVING_UP
  {
    from: MovementState.MOVING_UP,
    event: 'FLOOR_REACHED',
    guard: (ctx) => ctx.shouldStopAtCurrentFloor(),
    to: MovementState.STOPPED_AT_FLOOR,
    action: (ctx) => {
      ctx.stopMotor();
      ctx.triggerDoorOpen();
    }
  },
  {
    from: MovementState.MOVING_UP,
    event: 'FLOOR_REACHED',
    guard: (ctx) => !ctx.shouldStopAtCurrentFloor(),
    to: MovementState.MOVING_UP, // Self-transition
    action: (ctx) => ctx.updateCurrentFloor()
  },
  
  // From MOVING_DOWN
  {
    from: MovementState.MOVING_DOWN,
    event: 'FLOOR_REACHED',
    guard: (ctx) => ctx.shouldStopAtCurrentFloor(),
    to: MovementState.STOPPED_AT_FLOOR,
    action: (ctx) => {
      ctx.stopMotor();
      ctx.triggerDoorOpen();
    }
  },
  
  // From STOPPED_AT_FLOOR
  {
    from: MovementState.STOPPED_AT_FLOOR,
    event: 'DOORS_CLOSED',
    guard: (ctx) => ctx.hasMoreRequestsInCurrentDirection(),
    to: MovementState.MOVING_UP, // or MOVING_DOWN based on context
    action: (ctx) => ctx.continueInDirection()
  },
  {
    from: MovementState.STOPPED_AT_FLOOR,
    event: 'DOORS_CLOSED',
    guard: (ctx) => !ctx.hasMoreRequests(),
    to: MovementState.IDLE,
  },
  
  // From MAINTENANCE
  {
    from: MovementState.MAINTENANCE,
    event: 'EXIT_MAINTENANCE',
    to: MovementState.IDLE,
    action: (ctx) => ctx.enableButtons()
  },
];

Door State Machine

The door state machine operates as an orthogonal region to movement—doors have their own states independent of (but coordinated with) movement.

Door States:

CLOSED: Doors fully closed, elevator can move
OPENING: Doors in process of opening (mechanical transition)
OPEN: Doors fully open, passengers can enter/exit
CLOSING: Doors in process of closing

Door Events:

DOOR_OPEN_COMMAND: Signal to begin opening sequence
DOOR_OPEN_COMPLETE: Physical doors reached open position
DOOR_TIMER_EXPIRED: Dwell time complete, begin closing
DOOR_CLOSE_COMPLETE: Physical doors reached closed position
DOOR_OBSTRUCTED: Obstruction detected during closing
DOOR_OPEN_BUTTON: Passenger pressed door open button
DOOR_CLOSE_BUTTON: Passenger pressed door close button

Converting Mermaid diagram...

Critical Safety Constraint:

The door and movement state machines must coordinate. The fundamental safety invariant:

Movement is only allowed when doors are CLOSED.

This is enforced by making the doorsAreClosed() guard a precondition for any movement transition.

Door Dwell Time Logic:

When doors reach OPEN state:

Start a timer (typically 3-5 seconds)
If timer expires, transition to CLOSING
If 'door open' button pressed, reset timer
If 'door close' button pressed, immediately transition to CLOSING (skip timer)

Door State Implementation
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
enum DoorState {
  CLOSED = 'CLOSED',
  OPENING = 'OPENING',
  OPEN = 'OPEN',
  CLOSING = 'CLOSING'
}
 
class DoorStateMachine {
  private state: DoorState = DoorState.CLOSED;
  private dwellTimer: NodeJS.Timeout | null = null;
  private readonly dwellDuration: number = 3000; // 3 seconds
  
  constructor(
    private readonly onStateChange: (newState: DoorState) => void,
    private readonly onFullyClosed: () => void
  ) {}
  
  getCurrentState(): DoorState {
    return this.state;
  }
  
  // Event handlers
  handleOpenCommand(): void {
    if (this.state === DoorState.CLOSED) {
      this.transitionTo(DoorState.OPENING);
      // Simulate door mechanism (in real system, this is hardware)
      setTimeout(() => this.handleOpenComplete(), 1500);
    }
  }
  
  private handleOpenComplete(): void {
    if (this.state === DoorState.OPENING) {
      this.transitionTo(DoorState.OPEN);
      this.startDwellTimer();
    }
  }
  
  handleCloseButtonPressed(): void {
    if (this.state === DoorState.OPEN) {
      this.cancelDwellTimer();
      this.startClosing();
    }
  }
  
  handleOpenButtonPressed(): void {
    if (this.state === DoorState.OPEN) {
      this.resetDwellTimer();
    } else if (this.state === DoorState.CLOSING) {
      this.transitionTo(DoorState.OPENING);
      setTimeout(() => this.handleOpenComplete(), 1500);
    }
  }
  
  handleObstructionDetected(): void {
    if (this.state === DoorState.CLOSING) {
      // Safety: reopen doors
      this.transitionTo(DoorState.OPENING);
      setTimeout(() => this.handleOpenComplete(), 1500);
    }
  }
  
  private startClosing(): void {
    this.transitionTo(DoorState.CLOSING);
    setTimeout(() => this.handleCloseComplete(), 1500);
  }
  
  private handleCloseComplete(): void {
    if (this.state === DoorState.CLOSING) {
      this.transitionTo(DoorState.CLOSED);
      this.onFullyClosed();
    }
  }
  
  private startDwellTimer(): void {
    this.dwellTimer = setTimeout(() => {
      if (this.state === DoorState.OPEN) {
        this.startClosing();
      }
    }, this.dwellDuration);
  }
  
  private resetDwellTimer(): void {
    this.cancelDwellTimer();
    this.startDwellTimer();
  }
  
  private cancelDwellTimer(): void {
    if (this.dwellTimer) {
      clearTimeout(this.dwellTimer);
      this.dwellTimer = null;
    }
  }
  
  private transitionTo(newState: DoorState): void {
    console.log(`Door: ${this.state} → ${newState}`);
    this.state = newState;
    this.onStateChange(newState);
  }
  
  isClosed(): boolean {
    return this.state === DoorState.CLOSED;
  }
}

Real-World Safety Considerations

The State Pattern Implementation

State Pattern Structure:

Context: The object whose behavior varies by state (Elevator)
State Interface: Defines the behavior contract for all states
Concrete States: Implementations for each possible state

Benefits of State Pattern:

Single Responsibility: Each state class handles only that state's logic
Open/Closed: Add new states without modifying existing code
Eliminates conditionals: No massive switch statements
Explicit state transitions: State classes control their own transitions
Testability: Each state can be tested in isolation

State Pattern Implementation
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
// State interface - defines behavior for all elevator states
interface IElevatorState {
  // State identity
  getName(): string;
  
  // Event handlers
  onRequestReceived(context: ElevatorContext, request: Request): void;
  onFloorReached(context: ElevatorContext, floor: Floor): void;
  onDoorsOpened(context: ElevatorContext): void;
  onDoorsClosed(context: ElevatorContext): void;
  onEmergency(context: ElevatorContext): void;
  
  // State queries
  canMove(): boolean;
  canOpenDoors(): boolean;
}
 
// Context - the Elevator that uses states
class ElevatorContext {
  private state: IElevatorState;
  private currentFloor: Floor;
  private direction: Direction = Direction.IDLE;
  private destinationQueue: Request[] = [];
  private doorStateMachine: DoorStateMachine;
  
  constructor(initialFloor: Floor) {
    this.currentFloor = initialFloor;
    this.state = new IdleState();
    this.doorStateMachine = new DoorStateMachine(
      (newState) => this.onDoorStateChange(newState),
      () => this.onDoorsFullyClosed()
    );
  }
  
  // State transition
  setState(newState: IElevatorState): void {
    console.log(`Elevator: ${this.state.getName()} → ${newState.getName()}`);
    this.state = newState;
  }
  
  // Forward events to current state
  handleRequest(request: Request): void {
    this.state.onRequestReceived(this, request);
  }
  
  handleFloorArrival(floor: Floor): void {
    this.currentFloor = floor;
    this.state.onFloorReached(this, floor);
  }
  
  // Motor control (abstracted hardware)
  startMotor(direction: Direction): void {
    this.direction = direction;
    console.log(`Motor started: ${direction}`);
  }
  
  stopMotor(): void {
    console.log('Motor stopped');
    // Motor physically stops
  }
  
  // Door delegation
  openDoors(): void {
    this.doorStateMachine.handleOpenCommand();
  }
  
  private onDoorStateChange(doorState: DoorState): void {
    if (doorState === DoorState.OPEN) {
      this.state.onDoorsOpened(this);
    }
  }
  
  private onDoorsFullyClosed(): void {
    this.state.onDoorsClosed(this);
  }
  
  // Queue management
  addDestination(request: Request): void {
    this.destinationQueue.push(request);
    this.sortDestinations();
  }
  
  getNextDestination(): Request | null {
    return this.destinationQueue[0] ?? null;
  }
  
  removeCurrentDestination(): void {
    this.destinationQueue.shift();
  }
  
  hasDestinations(): boolean {
    return this.destinationQueue.length > 0;
  }
  
  shouldStopAtFloor(floor: Floor): boolean {
    return this.destinationQueue.some(
      r => r.floor.equals(floor)
    );
  }
  
  private sortDestinations(): void {
    // Sort by current direction using SCAN algorithm
    // Details in scheduling section
  }
  
  // Queries
  getCurrentFloor(): Floor {
    return this.currentFloor;
  }
  
  getDirection(): Direction {
    return this.direction;
  }
  
  doorsAreClosed(): boolean {
    return this.doorStateMachine.isClosed();
  }
}

Concrete State Implementations:

Now let's implement each concrete state:

Concrete States
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
// IDLE State - elevator stationary, awaiting requests
class IdleState implements IElevatorState {
  getName(): string { return 'IDLE'; }
  
  onRequestReceived(context: ElevatorContext, request: Request): void {
    context.addDestination(request);
    
    const current = context.getCurrentFloor().getFloorNumber();
    const target = request.floor.getFloorNumber();
    
    if (target > current) {
      context.startMotor(Direction.UP);
      context.setState(new MovingUpState());
    } else if (target < current) {
      context.startMotor(Direction.DOWN);
      context.setState(new MovingDownState());
    } else {
      // Already at requested floor
      context.openDoors();
      context.setState(new StoppedAtFloorState());
    }
  }
  
  onFloorReached(context: ElevatorContext, floor: Floor): void {
    // Shouldn't happen in IDLE state
  }
  
  onDoorsOpened(context: ElevatorContext): void {
    // Doors might open in IDLE for various reasons
  }
  
  onDoorsClosed(context: ElevatorContext): void {
    // Remain in IDLE
  }
  
  onEmergency(context: ElevatorContext): void {
    context.setState(new MaintenanceState());
  }
  
  canMove(): boolean { return true; }
  canOpenDoors(): boolean { return true; }
}
 
// MOVING_UP State - elevator traveling upward
class MovingUpState implements IElevatorState {
  getName(): string { return 'MOVING_UP'; }
  
  onRequestReceived(context: ElevatorContext, request: Request): void {
    // Add to queue, will be handled when we reach it
    context.addDestination(request);
  }
  
  onFloorReached(context: ElevatorContext, floor: Floor): void {
    if (context.shouldStopAtFloor(floor)) {
      context.stopMotor();
      context.openDoors();
      context.setState(new StoppedAtFloorState());
    }
    // Otherwise, continue moving (state unchanged)
  }
  
  onDoorsOpened(context: ElevatorContext): void {
    // Invalid - doors shouldn't open while moving
    throw new Error('Safety violation: doors opened while moving');
  }
  
  onDoorsClosed(context: ElevatorContext): void {
    // Doors should already be closed while moving
  }
  
  onEmergency(context: ElevatorContext): void {
    context.stopMotor();
    context.setState(new MaintenanceState());
  }
  
  canMove(): boolean { return true; }
  canOpenDoors(): boolean { return false; }
}
 
// MOVING_DOWN State - elevator traveling downward
class MovingDownState implements IElevatorState {
  getName(): string { return 'MOVING_DOWN'; }
  
  onRequestReceived(context: ElevatorContext, request: Request): void {
    context.addDestination(request);
  }
  
  onFloorReached(context: ElevatorContext, floor: Floor): void {
    if (context.shouldStopAtFloor(floor)) {
      context.stopMotor();
      context.openDoors();
      context.setState(new StoppedAtFloorState());
    }
  }
  
  onDoorsOpened(context: ElevatorContext): void {
    throw new Error('Safety violation: doors opened while moving');
  }
  
  onDoorsClosed(context: ElevatorContext): void {}
  
  onEmergency(context: ElevatorContext): void {
    context.stopMotor();
    context.setState(new MaintenanceState());
  }
  
  canMove(): boolean { return true; }
  canOpenDoors(): boolean { return false; }
}
 
// STOPPED_AT_FLOOR State - elevator at a floor with doors operating
class StoppedAtFloorState implements IElevatorState {
  getName(): string { return 'STOPPED_AT_FLOOR'; }
  
  onRequestReceived(context: ElevatorContext, request: Request): void {
    context.addDestination(request);
  }
  
  onFloorReached(context: ElevatorContext, floor: Floor): void {
    // We're stopped, shouldn't receive this event
  }
  
  onDoorsOpened(context: ElevatorContext): void {
    // Now passengers can enter/exit
    // Remove this floor from destination queue
    context.removeCurrentDestination();
  }
  
  onDoorsClosed(context: ElevatorContext): void {
    // Doors closed, decide next action
    if (!context.hasDestinations()) {
      context.setState(new IdleState());
      return;
    }
    
    const current = context.getCurrentFloor().getFloorNumber();
    const next = context.getNextDestination()!.floor.getFloorNumber();
    
    if (next > current) {
      context.startMotor(Direction.UP);
      context.setState(new MovingUpState());
    } else if (next < current) {
      context.startMotor(Direction.DOWN);
      context.setState(new MovingDownState());
    } else {
      // Next destination is current floor (edge case)
      context.openDoors();
    }
  }
  
  onEmergency(context: ElevatorContext): void {
    context.setState(new MaintenanceState());
  }
  
  canMove(): boolean { return false; }
  canOpenDoors(): boolean { return true; }
}
 
// MAINTENANCE State - elevator out of service
class MaintenanceState implements IElevatorState {
  getName(): string { return 'MAINTENANCE'; }
  
  onRequestReceived(context: ElevatorContext, request: Request): void {
    // Ignore requests in maintenance mode
    console.log('Request ignored: elevator in maintenance');
  }
  
  onFloorReached(context: ElevatorContext, floor: Floor): void {}
  onDoorsOpened(context: ElevatorContext): void {}
  onDoorsClosed(context: ElevatorContext): void {}
  
  onEmergency(context: ElevatorContext): void {
    // Already in maintenance/emergency state
  }
  
  // Administrative action to exit maintenance
  exitMaintenance(context: ElevatorContext): void {
    context.setState(new IdleState());
  }
  
  canMove(): boolean { return false; }
  canOpenDoors(): boolean { return true; }
}

State Transition Validation

Robust state machines enforce invariants—conditions that must always be true—and validate transitions before they occur.

Key Invariants:

System Invariants

•INV-1: Elevator can only move when doors are CLOSED
•INV-2: Doors can only open when elevator is STOPPED
•INV-3: Current floor always matches a valid floor number
•INV-4: Direction is UP only if moving upward, DOWN only if moving downward
•INV-5: Emergency state can be entered from any state

Transition Validation Implementation:

Transition Validation
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
// Transition validator - ensures all invariants hold
class TransitionValidator {
  // Valid transitions defined as (fromState, event) → toState
  private readonly validTransitions: Map<string, Set<string>> = new Map([
    ['IDLE', new Set(['MOVING_UP', 'MOVING_DOWN', 'STOPPED_AT_FLOOR', 'MAINTENANCE'])],
    ['MOVING_UP', new Set(['STOPPED_AT_FLOOR', 'MOVING_UP', 'MAINTENANCE'])],
    ['MOVING_DOWN', new Set(['STOPPED_AT_FLOOR', 'MOVING_DOWN', 'MAINTENANCE'])],
    ['STOPPED_AT_FLOOR', new Set(['IDLE', 'MOVING_UP', 'MOVING_DOWN', 'MAINTENANCE'])],
    ['MAINTENANCE', new Set(['IDLE'])],
  ]);
  
  validateTransition(
    from: IElevatorState, 
    to: IElevatorState,
    context: ElevatorContext
  ): ValidationResult {
    const fromName = from.getName();
    const toName = to.getName();
    
    // Check if transition is in valid set
    const validTargets = this.validTransitions.get(fromName);
    if (!validTargets || !validTargets.has(toName)) {
      return {
        valid: false,
        error: `Invalid transition: ${fromName} → ${toName}`
      };
    }
    
    // Check invariants based on target state
    if (toName === 'MOVING_UP' || toName === 'MOVING_DOWN') {
      if (!context.doorsAreClosed()) {
        return {
          valid: false,
          error: 'INV-1 violation: Cannot move with doors open'
        };
      }
    }
    
    if (toName === 'STOPPED_AT_FLOOR') {
      // Valid, moving to stopped is always allowed
    }
    
    return { valid: true };
  }
}
 
interface ValidationResult {
  valid: boolean;
  error?: string;
}
 
// Enhanced context with validation
class ValidatedElevatorContext extends ElevatorContext {
  private validator: TransitionValidator = new TransitionValidator();
  
  setState(newState: IElevatorState): void {
    const result = this.validator.validateTransition(
      this.getState(), 
      newState, 
      this
    );
    
    if (!result.valid) {
      console.error(`Transition rejected: ${result.error}`);
      // In production, might throw or log to monitoring
      return;
    }
    
    super.setState(newState);
  }
}

Defense in Depth

Testing State Machines

State machines are highly testable because they have well-defined inputs (events) and outputs (state transitions, actions). Here are strategies for comprehensive testing:

Test Categories:

Individual State Tests: Test each state's response to each event
Transition Tests: Verify correct state changes
Sequence Tests: Test realistic event sequences (scenarios)
Invariant Tests: Verify invariants never violated
Edge Case Tests: Empty queues, repeated events, concurrent events

State Machine Tests
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
describe('Elevator State Machine', () => {
  let context: ElevatorContext;
  
  beforeEach(() => {
    const groundFloor = new Floor(0, 'Ground');
    context = new ElevatorContext(groundFloor);
  });
  
  describe('Idle State', () => {
    it('should transition to MOVING_UP on upward request', () => {
      const floor5Request = Request.createCabCall(new Floor(5));
      context.handleRequest(floor5Request);
      
      expect(context.getState().getName()).toBe('MOVING_UP');
      expect(context.getDirection()).toBe(Direction.UP);
    });
    
    it('should transition to MOVING_DOWN on downward request', () => {
      // First move to floor 10
      context = new ElevatorContext(new Floor(10));
      
      const floor2Request = Request.createCabCall(new Floor(2));
      context.handleRequest(floor2Request);
      
      expect(context.getState().getName()).toBe('MOVING_DOWN');
      expect(context.getDirection()).toBe(Direction.DOWN);
    });
    
    it('should stay IDLE for same-floor request with door cycle', () => {
      const groundRequest = Request.createCabCall(new Floor(0));
      context.handleRequest(groundRequest);
      
      expect(context.getState().getName()).toBe('STOPPED_AT_FLOOR');
      // Doors will open, then close, returning to IDLE
    });
  });
  
  describe('Moving State', () => {
    it('should stop at destination floor', () => {
      const floor5Request = Request.createCabCall(new Floor(5));
      context.handleRequest(floor5Request);
      
      // Simulate arriving at floor 5
      context.handleFloorArrival(new Floor(5));
      
      expect(context.getState().getName()).toBe('STOPPED_AT_FLOOR');
    });
    
    it('should not stop at non-destination floors', () => {
      const floor5Request = Request.createCabCall(new Floor(5));
      context.handleRequest(floor5Request);
      
      // Pass through floors 1-4
      for (let i = 1; i < 5; i++) {
        context.handleFloorArrival(new Floor(i));
        expect(context.getState().getName()).toBe('MOVING_UP');
      }
    });
    
    it('should add requests to queue while moving', () => {
      context.handleRequest(Request.createCabCall(new Floor(10)));
      expect(context.getState().getName()).toBe('MOVING_UP');
      
      // Add another request while moving
      context.handleRequest(Request.createCabCall(new Floor(5)));
      
      // Should still be moving, but floor 5 is now in queue
      expect(context.hasDestinations()).toBe(true);
    });
  });
  
  describe('Safety Invariants', () => {
    it('should never move with doors open', () => {
      context.handleRequest(Request.createCabCall(new Floor(5)));
      context.handleFloorArrival(new Floor(5));
      
      // Now in STOPPED_AT_FLOOR with doors opening
      // Attempt to receive a new request and move
      context.handleRequest(Request.createCabCall(new Floor(10)));
      
      // Should remain stopped until doors close
      expect(context.getState().getName()).toBe('STOPPED_AT_FLOOR');
    });
    
    it('should enter maintenance from any state', () => {
      // From IDLE
      context.handleEmergency();
      expect(context.getState().getName()).toBe('MAINTENANCE');
      
      // Reset and test from MOVING
      context = new ElevatorContext(new Floor(0));
      context.handleRequest(Request.createCabCall(new Floor(10)));
      context.handleEmergency();
      expect(context.getState().getName()).toBe('MAINTENANCE');
    });
  });
  
  describe('Complete Scenarios', () => {
    it('should handle full passenger journey', () => {
      // Passenger at floor 3 wants floor 15
      context.handleRequest(Request.createHallCall(new Floor(3), Direction.UP));
      
      expect(context.getState().getName()).toBe('MOVING_UP');
      
      // Arrive at floor 3
      context.handleFloorArrival(new Floor(3));
      expect(context.getState().getName()).toBe('STOPPED_AT_FLOOR');
      
      // Passenger enters, presses 15
      context.handleRequest(Request.createCabCall(new Floor(15)));
      
      // Doors close (simulated callback)
      context.simulateDoorsClosed();
      expect(context.getState().getName()).toBe('MOVING_UP');
      
      // Arrive at floor 15
      context.handleFloorArrival(new Floor(15));
      expect(context.getState().getName()).toBe('STOPPED_AT_FLOOR');
      
      // Doors close, no more requests
      context.simulateDoorsClosed();
      expect(context.getState().getName()).toBe('IDLE');
    });
  });
});

Test Coverage Strategy

Summary and Path Forward

State Management Mastered:

We've designed comprehensive state machines that govern elevator behavior:

Key Accomplishments

•Movement State Machine: IDLE, MOVING_UP, MOVING_DOWN, STOPPED_AT_FLOOR, MAINTENANCE with clear transition rules
•Door State Machine: Orthogonal region handling CLOSED, OPENING, OPEN, CLOSING with timer and obstruction logic
•State Pattern Implementation: Context, state interface, and concrete state classes for extensible design
•Transition Validation: Guards and validators ensuring invariants like 'no movement with doors open'
•Testing Strategy: Comprehensive tests for individual states, transitions, sequences, and invariants

What's Next:

With static entities (previous page) and dynamic behavior (this page) established, we now turn to optimization. The next page covers:

Scheduling algorithms (FCFS, SCAN, LOOK) that determine which requests to serve first
Strategy Pattern implementation for swappable algorithms
Trade-off analysis comparing algorithm performance in different scenarios

The scheduling algorithm is where elevator system design becomes truly interesting—it's the difference between a system that merely works and one that delights users with minimal wait times.

State Design Complete

3 / 6