Home System Design Elevator System Low-Level Design (LLD)

Elevator System Low-Level Design (LLD)

Vending Machine - Low Level Design

Role of Artificial Intelligence(AI) in System Design

Elevator System is one of the famous Low-Level Design(LLD) problems being asked in interviews. We are here going to discuss this problem along with its requirements, use-cases diagram, class diagram and implementation.


Important Topics for Elevator System Low-Level Design (LLD)

  • Requirements of Elevator System Low-Level Design (LLD)
  • Use-Case Diagram of Elevator System Low-Level Design (LLD)
  • Class Diagram of Elevator System Low-Level Design (LLD)
  • Relationship between classes
  • Implementation of the Elevator System Low-Level Design (LLD)
  • Performance Optimization of Elevator System Low-Level Design (LLD)

Requirements of Elevator System Low-Level Design (LLD)

  1. Elevators and Floors: The system shall include 3 elevator cars. The elevators will service a building that has up to 15 floors.
  2. Elevator Movement: Elevators shall be capable of moving up, moving down, or remaining idle.
  3. Elevator Door Operation: Elevator doors shall open only when the elevator is idle and not in motion.
  4. Floor Access: Each elevator shall be capable of stopping at every floor in the building.
  5. Outside Control Panel: An external panel with up and down buttons shall be available on each floor to call an elevator.
  6. Inside Control Panel: Inside each elevator, a control panel with buttons for all floors and door operation (open/close) shall be provided.
  7. Displays: Each elevator shall have internal and external displays. External displays shall indicate the current floor and the direction of movement. Internal displays shall show the current floor, the direction of movement, and the elevator’s capacity.
  8. Floor Panels and Displays: Each floor shall have a panel with buttons for calling elevators and displays indicating the status of each elevator.
  9. Passenger Directions: The system shall accommodate multiple passengers going to different floors and in different directions simultaneously.
  10. Elevator System Control: The system shall manage elevator movement, door operations, and monitor elevator statuses.
  11. Smart Dispatch System: Upon a passenger calling for an elevator, the system shall intelligently assign the most suitable elevator based on its current location and trajectory.
  12. Capacity: Each elevator shall have a maximum capacity of eight people or 680 kilograms.
  13. Maximum Number of Elevators: The building shall be equipped with up to three elevators to service all floors.

Use-Case Diagram of Elevator System Low-Level Design (LLD)

Below is the use case diagram for the Elevator Low-Level Design(LLD)

Class Diagram of Elevator System Low-Level Design (LLD)

1. Enums are being used in this problem:

2. Button interface and its Implementation Classes:

3. Display, Door and Floor classes:

4. Panel and its implementation classes:

5. Elevator and Elevator System Classes:

Note: We will implement Singleton Design Pattern in ElevatorSystem class, as we want to insure to have only one object in the system.

Relationship between classes

Solid diamond arrow representing composition and hollow diamond representing aggregation.

Implementation of the Elevator System Low-Level Design (LLD)

1. Project Folder Structure

Project Folder structure


2. Direction.java

Java 
public enum Direction {
    UP, DOWN, IDLE;
}

3. DoorAction.java

Java 
public enum DoorAction {
    OPEN,CLOSE;
}

4. ElevatorNumber.java

Java 
public enum ElevatorNumber {
    ELEVATOR_NUMBER1,ELEVATOR_NUMBER2,ELEVATOR_NUMBER3;
}

5. FloorNumber.java

Java 
public enum FloorNumber {
    FLOOR_NUMBER1,FLOOR_NUMBER2,FLOOR_NUMBER3,FLOOR_NUMBER4,FLOOR_NUMBER5,FLOOR_NUMBER6,FLOOR_NUMBER7,FLOOR_NUMBER8,FLOOR_NUMBER9,FLOOR_NUMBER10,FLOOR_NUMBER11,FLOOR_NUMBER12,FLOOR_NUMBER13,FLOOR_NUMBER14,FLOOR_NUMBER15;
}

6. Button.java

Java 
public interface Button {
    boolean isPressed();
    boolean press();
}

7. Pannel.java

Java 
public interface Pannel {

}

8. Display.java

Java 
import enums.Direction;
import enums.FloorNumber;

public class Display {
    private FloorNumber floorNumber;
    private Direction direction;
    private Integer weight;

    public Display(FloorNumber floorNumber, Direction direction, Integer weight) {
        this.floorNumber = floorNumber;

        this.direction = direction;
        this.weight = weight;
    }

    public Display() {
    }

    public FloorNumber getFloorNumber() {
        return floorNumber;
    }

    public void setFloorNumber(FloorNumber floorNumber) {
        this.floorNumber = floorNumber;
    }

    public Direction getDirection() {
        return direction;
    }

    public void setDirection(Direction direction) {
        this.direction = direction;
    }

    public Integer getWeight() {
        return weight;
    }

    public void setWeight(Integer weight) {
        this.weight = weight;
    }

}

9. Door.java

Java 
import enums.DoorAction;

public class Door {
    private DoorAction doorAction;

    public Door(DoorAction doorAction) {
        this.doorAction = doorAction;
    }

    public Door() {
    }

    public void openDoor(){
        doorAction = DoorAction.OPEN;
    }
    public void closeDoor(){
        doorAction = DoorAction.CLOSE;
    }
}

10. DoorButton.java

Java 
import enums.DoorAction;
import interfaces.Button;

public class DoorButton implements Button {
    private boolean status;

    private DoorAction doorAction;

    public DoorButton(boolean status, DoorAction doorAction) {
        this.status = status;
        this.doorAction = doorAction;
    }
    public DoorButton() {
    }

    public DoorAction getDoorAction() {
        return doorAction;
    }

    public void setDoorAction(DoorAction doorAction) {
        this.doorAction = doorAction;
    }



    public void setStatus(boolean status) {
        this.status = status;
    }

    @Override
    public boolean isPressed() {
        return status;
    }

    @Override
    public boolean press() {
        status=!status;
        return status;
    }    
}

11. ElevatorButton.java

Java 
import enums.FloorNumber;
import interfaces.Button;

public class ElevatorButton implements Button {
    private boolean status;

    private FloorNumber floorNumber;

    public ElevatorButton(boolean status, FloorNumber floorNumber) {
        this.status = status;
        this.floorNumber = floorNumber;
    }
    public ElevatorButton() {
    }

    public FloorNumber getFloorNumber() {
        return floorNumber;
    }

    public void setFloorNumber(FloorNumber floorNumber) {
        this.floorNumber = floorNumber;
    }



    public void setStatus(boolean status) {
        this.status = status;
    }

    @Override
    public boolean isPressed() {
        return status;
    }

    @Override
    public boolean press() {
        status=!status;
        return status;
    }
}

12. HallButton.java

Java 
import enums.Direction;
import interfaces.Button;

public class HallButton implements Button {
    private boolean status;

    private Direction direction;

    public HallButton(boolean status, Direction direction) {
        this.status = status;
        this.direction = direction;
    }
    public HallButton() {
    }

    public Direction getDirection() {
        return direction;
    }

    public void setDirection(Direction direction) {
        this.direction = direction;
    }



    public void setStatus(boolean status) {
        this.status = status;
    }

    @Override
    public boolean isPressed() {
        return status;
    }

    @Override
    public boolean press() {
        status=!status;
        return status;
    }
}

13. Elevator.java

Java 
import enums.Direction;
import enums.ElevatorNumber;
import enums.FloorNumber;

public class Elevator {
    private ElevatorNumber elevatorNumber;
    private Door door;
    private InsidePannel insidePannel;
    private Display display;
    private FloorNumber currentFloorNumber;
    private Direction currentDirection;

    public Elevator(ElevatorNumber elevatorNumber, Door door, InsidePannel insidePannel, Display display, FloorNumber currentFloorNumber, Direction currentDirection) {
        this.elevatorNumber = elevatorNumber;
        this.door = door;
        this.insidePannel = insidePannel;
        this.display = display;
        this.currentFloorNumber = currentFloorNumber;
        this.currentDirection = currentDirection;
    }

    public Elevator() {
    }

    public ElevatorNumber getElevatorNumber() {
        return elevatorNumber;
    }

    public void setElevatorNumber(ElevatorNumber elevatorNumber) {
        this.elevatorNumber = elevatorNumber;
    }

    public Door getDoor() {
        return door;
    }

    public void setDoor(Door door) {
        this.door = door;
    }

    public InsidePannel getInsidePannel() {
        return insidePannel;
    }

    public void setInsidePannel(InsidePannel insidePannel) {
        this.insidePannel = insidePannel;
    }

    public Display getDisplay() {
        return display;
    }

    public void setDisplay(Display display) {
        this.display = display;
    }

    public FloorNumber getCurrentFloorNumber() {
        return currentFloorNumber;
    }

    public void setCurrentFloorNumber(FloorNumber currentFloorNumber) {
        this.currentFloorNumber = currentFloorNumber;
    }

    public Direction getCurrentDirection() {
        return currentDirection;
    }

    public void setCurrentDirection(Direction currentDirection) {
        this.currentDirection = currentDirection;
    }

}

14. Floor.java

Java 
import enums.FloorNumber;

public class Floor {
    private FloorNumber floorNumber;
    private OutsidePannel outsidePannel;

    public FloorNumber getFloorNumber() {
        return floorNumber;
    }

    public void setFloorNumber(FloorNumber floorNumber) {
        this.floorNumber = floorNumber;
    }

    public OutsidePannel getOutsidePannel() {
        return outsidePannel;
    }

    public void setOutsidePannel(OutsidePannel outsidePannel) {
        this.outsidePannel = outsidePannel;
    }

    public Floor(FloorNumber floorNumber, OutsidePannel outsidePannel) {
        this.floorNumber = floorNumber;
        this.outsidePannel = outsidePannel;
    }
}

15. InsidePannel.java

Java 
import enums.DoorAction;
import enums.FloorNumber;
import interfaces.Pannel;

import java.util.ArrayList;
import java.util.List;

public class InsidePannel implements Pannel{
    private List<ElevatorButton> elevatorButtonList;
    private List<DoorButton> doorButtons;

    public InsidePannel() {
    elevatorButtonList=new ArrayList<>();
    doorButtons=new ArrayList<>();
        for (int i = 0; i <15 ; i++) {
            elevatorButtonList.add(new ElevatorButton(false, FloorNumber.values()[i]));
        }

        for (int i = 0; i <3 ; i++) {
            doorButtons.add(new DoorButton(false, DoorAction.values()[i]));
        }
    }

    public boolean pressFloorButton(int floorNumber) {
        return elevatorButtonList.get(floorNumber).press();
    }
    public boolean pressDoorButton(int doorNumber) {
        return doorButtons.get(doorNumber).press();
    }
}

16. OutsidePannel.java

Java 
import enums.Direction;
import interfaces.Pannel;

import java.util.ArrayList;
import java.util.List;

public class OutsidePannel implements Pannel {
    private List<HallButton> hallButtons;

    public OutsidePannel() {
        hallButtons = new ArrayList<>();
        hallButtons.add(new HallButton(false,Direction.UP));
        hallButtons.add(new HallButton(false,Direction.DOWN));
        hallButtons.add(new HallButton(false,Direction.IDLE));
    }

    public void moveUp(){

    }
    public void moveDown(){

    }
}

17. ElevatorSystem.java

Java 
import enums.Direction;
import enums.FloorNumber;

import java.util.*;

public class ElevatorSystem {
    private List<Elevator> elevators;
    private List<Floor> floors;



    private ElevatorSystem() {
    }

    public List<Elevator> getElevators() {
        return elevators;
    }

    public void setElevators(List<Elevator> elevators) {
        this.elevators = elevators;
    }

    public List<Floor> getFloors() {
        return floors;
    }

    public void setFloors(List<Floor> floors) {
        this.floors = floors;
    }
    private static volatile ElevatorSystem elevatorSystemInstance;


    public static ElevatorSystem getInstance() {
        if (elevatorSystemInstance == null) {
            synchronized (ElevatorSystem.class){
                if (elevatorSystemInstance == null) {
                    return elevatorSystemInstance = new ElevatorSystem();
                }
            }
        }
        return elevatorSystemInstance;
    }

    public Elevator requestElevator(Direction direction, Floor floor) {
        //TODO: returning elevator using smart dispatch, setting up the properties of the elevator
        return null;
    }

    public void openDoor(Elevator elevator) {
        elevator.getDoor().openDoor();

    }
    public void closeDoor(Elevator elevator) {
        elevator.getDoor().closeDoor();

    }
    public void selectFloor(FloorNumber floorNumber, Elevator elevator) {
      elevator.getInsidePannel().pressFloorButton(floorNumber.ordinal());
    }

}

Performance Optimization of Elevator System Low-Level Design (LLD)

1. Efficient Scheduling Algorithms

Implement efficient control algorithms like the Elevator Group Control System (EGCS) which include:

  • Single Elevator Optimization: Use algorithms like the Simplex method for single elevator optimization.
  • Multiple Elevator Coordination: Implement algorithms such as the Destination Control System (DCS) to manage traffic flow effectively.
  • Heuristic Approaches: Use heuristics or meta-heuristics (e.g., Genetic Algorithms, Simulated Annealing) for complex scenarios.

2. Intelligent Load Balancing

  • Dynamic Load Balancing: Distribute requests efficiently among multiple elevators to minimize wait and travel times.
  • Real-time Traffic Analysis: Use sensors and data analytics to predict traffic patterns and adjust elevator deployment dynamically.




Tags:
#System Design

Vending Machine - Low Level Design

Role of Artificial Intelligence(AI) in System Design

Contact Us

Categories
Learn the most popular programming languages in the world.