Team Nova:

Crisna Maria Soby

•

AFSIDHA M J

•

Aiswarya Achu

Published August 6, 2026

Smart Restroom Occupancy Monitor

A smart, privacy-friendly system that shows real time rest room availability using a Time-of-Flight sensor

BeginnerFull instructions provided10 hours55

Things used in this project

Hardware components

ProtoCentral Electronics ProtoCentral VL53L0X Laser ToF Sensor breakout board

Seeed Studio Grove - OLED Display 0.66" (SSD1306)- IIC - 3.3V/5V

Seeed Studio Grove - Round Force Sensor (FSR402)

Breadboard (generic)

LED (generic)

LED, Green

Resistor 10k ohm

Resistor 221 ohm

Jumper wires (generic)

USB Cable, USB Type C Plug

Seeed Studio XIAO ESP32S3 Sense

Software apps and online services

Arduino IDE

Seeed Studio SenseCraft AI

Hand tools and fabrication machines

Seeed Studio Fusion PCB/PCBA

Story

Inspiration

The idea for this project came from a common experience that many people face in public places. Users often have no idea whether a restroom stall is occupied until they reach the door, leading to unnecessary waiting and congestion. At the same time, maintenance teams depend on routine inspections instead of actual restroom usage, making it difficult to know when cleaning or restocking is really needed.

We wanted to design a smarter solution that improves convenience for users while also helping facility managers maintain hygiene more efficiently. Privacy was one of our biggest priorities, so rather than using cameras, we chose a Time-of-Flight sensor that detects presence without capturing any images.

How the System Works

Occupancy Detection

The VL53L0X Time-of-Flight sensor continuously measures the distance between itself and objects inside the restroom.

When someone enters and the measured distance becomes less than 600 mm, the system identifies the restroom as occupied. The OLED display immediately changes to "OCCUPIED", and the red LED turns on while the green LED turns off.

Once the person leaves and the measured distance increases beyond the threshold, the system updates the display to "VACANT" and switches the LEDs accordingly.

displaying occupied

displaying vacant

Restroom Usage Counter

Every time the restroom changes from Vacant to Occupied, the system records one usage.

This information can later help facility managers:

Schedule cleaning based on actual usage.
Understand restroom traffic.
Identify peak usage hours.

Instead of cleaning on fixed schedules, maintenance can become more efficient and data driven.

Soap Dispenser Monitoring

To improve hygiene management, an FSR sensor is placed beneath the soap dispenser button.

Each time the dispenser is pressed:

One soap usage is recorded.
The usage counter increases.
When the predefined limit is reached, the system generates a "RESTOCK SOAP" alert.

Although this method estimates soap consumption rather than measuring the exact amount remaining, it provides a simple and low-cost way to remind maintenance staff before the dispenser becomes empty.

Working flow

User enters restroom ➡️ VL53L0X ToF sensor detects occupancy.

XIAO ESP32 processes the distance data ➡️ Restroom status changes to "Occupied".

OLED display updates in real time ➡️ Red LED indicates the stall is occupied.

User leaves the restroom ➡️ ToF sensor detects the stall is vacant.

ESP32 updates the occupancy status ➡️ OLED displays "Available" and Green LED turns ON.

Each Vacant → Occupied transition is counted ➡️ Restroom usage counter is incremented.

FSR monitors soap dispenser usage ➡️ Soap usage level is updated continuously.

Soap usage reaches the configured threshold ➡️ "RESTOCK SOAP" alert is displayed for maintenance staff.

serial monitoring display

Hardware Components

The prototype consists of the following hardware:

Seeed Studio XIAO ESP32S3
VL53L0X Time-of-Flight Distance Sensor
SSD1306 0.96-inch OLED Display
Force Sensitive Resistor (FSR)
Red LED
Green LED
220 Ω resistors
10 kΩ resistor
Breadboard
Jumper wires
USB cable

Each component was selected to keep the system compact, affordable, and energy efficient.

Software Used

The project was developed using the Arduino ecosystem.

Software and libraries include:

Arduino IDE
ESP32 Board Package
Adafruit SSD1306 Library
Adafruit GFX Library
Adafruit VL53L0X Library
Wire Library

These libraries simplify communication with the display and sensors, allowing the ESP32S3 to process sensor data efficiently.

System Architecture

The project is organized into four simple layers.

Sensor Layer

The sensors collect information from the environment.

The VL53L0X detects whether the restroom is occupied.
The FSR detects soap dispenser presses.

Processing Layer

The XIAO ESP32S3 receives sensor data, processes it, updates counters, and controls the output devices.

Output Layer

The processed information is presented through:

OLED display
Green LED for VACANT
Red LED for OCCUPIED
Serial Monitor for debugging and logging

Future IoT Layer

Since the ESP32S3 includes built-in Wi-Fi, the system can later connect to:

Cloud dashboards
Mobile applications
Maintenance notifications
Real-time analytics

Construction Process

The prototype was built in several simple steps.

Connect the OLED display using the I²C interface.
Connect the VL53L0X sensor to the same I²C bus.
Connect the red and green LEDs through 220 Ω resistors.
Build the FSR voltage divider using a 10 kΩ resistor.
Upload the Arduino program.
Test occupancy detection.
Verify soap usage counting.
Mount the hardware inside a demonstration enclosure.

Key Features

Our system offers several useful features:

Privacy-friendly occupancy detection
Real-time restroom availability
OLED status display
LED occupancy indicators
Automatic usage counting
Soap dispenser monitoring
Restock alerts
Compact design
Low power consumption
Ready for IoT expansion

Advantages

Compared to conventional restroom management, our system provides several benefits.

Reduces unnecessary waiting.
Improves user convenience.
Supports better restroom hygiene.
Optimizes maintenance schedules.
Helps prevent soap shortages.
Uses inexpensive hardware.
Is easy to install and maintain.
Can be expanded with additional smart features.

Sustainability

Our project also supports sustainable facility management.

By using actual restroom usage instead of fixed schedules, cleaning resources can be used more efficiently. Soap wastage is reduced because maintenance staff receive timely refill reminders. The system also consumes very little power thanks to the energy-efficient ESP32S3.

Most importantly, our design protects user privacy by avoiding cameras entirely while still providing reliable occupancy detection.

Applications

The system can be deployed in many public facilities, including:

Restaurants
Hotels
Shopping malls
Airports
Railway stations
Colleges
Universities
Hospitals
Office buildings
Smart city infrastructure

Challenges We Faced

During development, we encountered several technical challenges.

The occupancy threshold required careful calibration to ensure accurate detection. We also needed to prevent multiple soap counts from a single dispenser press. Since both the OLED display and ToF sensor communicate over I²C, proper integration was essential. Another challenge was updating the OLED smoothly without affecting sensor performance. Finally, we tested the system under different environmental conditions to ensure reliable occupancy detection.

Future Improvements

This prototype can be extended with several advanced features, including:

Cloud-based monitoring dashboard
Mobile application
Push notifications for maintenance staff
Real-time analytics
Multiple restroom stall monitoring
AI-based prediction of peak usage
Load-cell-based soap level measurement
Integration with smart building management systems
Battery backup
Solar-powered operation
Tissue and paper towel monitoring

These additions would transform the prototype into a complete smart restroom management solution.

Conclusion

The Smart Restroom Occupancy & Hygiene Monitoring System shows how affordable embedded technology can solve everyday problems in public facilities. By combining occupancy detection, restroom usage tracking, and soap dispenser monitoring into a single compact platform, the system improves user convenience while helping maintenance teams make better decisions based on real-time data.

Built around the Seed Studio XIAO ESP32S3, the project is energy efficient, privacy-friendly, and ready for future IoT integration. With its modular design and low implementation cost, it has the potential to enhance restroom management in restaurants, shopping malls, hospitals, educational institutions, airports, offices, and future smart city infrastructure.

Smart Restroom Occupancy Monitor - Circuit Connection Diagram

This schematic illustrates the hardware connections of the Smart Restroom Occupancy & Hygiene Monitoring System. It shows the wiring between the Seeed Studio XIAO ESP32S3, VL53L0X Time-of-Flight sensor, SSD1306 OLED display, status LEDs, and the required power and I²C connections used in the prototype.Connect the components according to the wiring diagram. Upload the provided Arduino sketch to the Seeed Studio XIAO ESP32S3 using the Arduino IDE. After powering the system, the VL53L0X sensor detects restroom occupancy, the OLED displays the current status, and the LEDs indicate availability in real time.

Code

Smart Restroom Occupancy & Hygiene Monitoring System

C/C++

Arduino firmware for the Smart Restroom Occupancy & Hygiene Monitoring System. The program reads data from the VL53L0X Time-of-Flight sensor to detect restroom occupancy, updates the OLED display and status LEDs, counts restroom usage, monitors soap dispenser usage through an FSR sensor, and generates maintenance alerts when the predefined threshold is reached.1. Install the ESP32 board package in the Arduino IDE.
2. Install the required libraries: Adafruit GFX, Adafruit SSD1306, Adafruit VL53L0X, and Wire.
3. Connect the hardware according to the circuit diagram.
4. Select the Seeed Studio XIAO ESP32S3 board and the correct COM port.
5. Upload the sketch to the board.
6. Power the system and monitor the OLED display and Serial Monitor for real-time occupancy and soap usage information.

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <Adafruit_VL53L0X.h>

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);
Adafruit_VL53L0X lox;

// LED Pins
const int RED_LED = D2;
const int GREEN_LED = D3;

// Distance threshold (mm)
const int threshold = 600;

// Cleaning alert after these many uses
const int CLEAN_LIMIT = 20;

int usageCount = 0;
bool occupied = false;

void setup() {

  Serial.begin(115200);

  Wire.begin();

  pinMode(RED_LED, OUTPUT);
  pinMode(GREEN_LED, OUTPUT);

  digitalWrite(RED_LED, LOW);
  digitalWrite(GREEN_LED, LOW);

  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    while (1);
  }

  display.clearDisplay();
  display.setTextSize(1);
  display.setCursor(0,0);
  display.println("Starting...");
  display.display();

  if (!lox.begin()) {

    display.clearDisplay();
    display.setCursor(0,0);
    display.println("Sensor Error");
    display.display();

    while (1);
  }

  delay(1000);
}

void loop() {

  VL53L0X_RangingMeasurementData_t measure;

  lox.rangingTest(&measure, false);

  if (measure.RangeStatus != 4) {

    int distance = measure.RangeMilliMeter;

    display.clearDisplay();

    display.setTextSize(2);
    display.setCursor(0,0);

    if (distance < threshold) {

      display.println("OCCUPIED");

      digitalWrite(RED_LED, HIGH);
      digitalWrite(GREEN_LED, LOW);

      if (!occupied) {
        occupied = true;
        usageCount++;
      }

    } else {

      display.println("VACANT");

      digitalWrite(RED_LED, LOW);
      digitalWrite(GREEN_LED, HIGH);

      occupied = false;
    }

    display.setTextSize(1);

    display.setCursor(0,30);
    display.print("Distance:");
    display.print(distance);
    display.println(" mm");

    display.print("Uses: ");
    display.println(usageCount);

    if (usageCount >= CLEAN_LIMIT) {

      display.println("Cleaning Needed!");

      Serial.println("***** ALERT *****");
      Serial.println("Cleaning Required");
      Serial.println("*****************");

    }

    display.display();

    Serial.print("Distance: ");
    Serial.print(distance);
    Serial.print(" mm   Uses: ");
    Serial.println(usageCount);

  }

  delay(200);
}

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <Adafruit_VL53L0X.h>

// ---------------- OLED CONFIG ----------------
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_ADDR    0x3C
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

// ---------------- ToF SENSOR ----------------
Adafruit_VL53L0X lox;
const int OCCUPANCY_THRESHOLD_MM = 600;   // distance below this = occupied

// ---------------- STATUS LEDs ----------------
const int RED_LED   = D2;   // Occupied indicator
const int GREEN_LED = D3;   // Vacant indicator

// ---------------- RESTROOM USAGE COUNTER ----------------
// Counts each new VACANT -> OCCUPIED transition (one "use")
unsigned long usageCount = 0;
bool wasOccupied = false;   // tracks previous occupancy state for edge detection

// ---------------- FSR SOAP LEVEL ----------------
const int FSR_PIN = A0;
// Adjust according to your sensor readings
const int FSR_MIN = 100;     // No pressure value
const int FSR_MAX = 3000;    // Maximum pressure value
const int SOAP_MAX = 20;
int soapCount = 0;

// ---------------- TIMING ----------------
const unsigned long LOOP_DELAY_MS = 200;

void setup() {
  Serial.begin(115200);
  delay(500);

  Wire.begin();

  pinMode(RED_LED, OUTPUT);
  pinMode(GREEN_LED, OUTPUT);
  digitalWrite(RED_LED, LOW);
  digitalWrite(GREEN_LED, LOW);

  pinMode(FSR_PIN, INPUT);

  Serial.println("========================================");
  Serial.println(" SMART RESTROOM MONITORING SYSTEM");
  Serial.println("========================================");

  // ---- OLED INIT ----
  if (!display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR)) {
    Serial.println("OLED init FAILED");
    while (1) { delay(10); }
  }
  display.clearDisplay();
  display.setTextSize(2);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(10, 20);
  display.println("Starting...");
  display.display();

  // ---- ToF SENSOR INIT ----
  if (!lox.begin()) {
    Serial.println("VL53L0X NOT FOUND!");
    display.clearDisplay();
    display.setTextSize(2);
    display.setCursor(0, 5);
    display.println("TOF ERROR");
    display.display();
    while (1) { delay(10); }
  }
  Serial.println("VL53L0X Ready");
  Serial.println("Soap Level Sensor Ready");
  Serial.println("----------------------------------------");

  delay(800);
}

void loop() {
  handleOccupancy();
  handleSoapDispenser();
  delay(LOOP_DELAY_MS);
}

// ============================================================
// Reads the ToF sensor, updates OLED + LEDs with occupancy status,
// and counts a restroom "use" on every VACANT -> OCCUPIED edge
// ============================================================
void handleOccupancy() {
  VL53L0X_RangingMeasurementData_t measure;
  lox.rangingTest(&measure, false);

  display.clearDisplay();
  display.setTextSize(2);
  display.setTextColor(SSD1306_WHITE);

  if (measure.RangeStatus != 4) {  // valid reading
    int distance = measure.RangeMilliMeter;
    bool isOccupied = (distance < OCCUPANCY_THRESHOLD_MM);

    Serial.print("Distance: ");
    Serial.print(distance);
    Serial.println(" mm");

    if (isOccupied) {
      // ---- OCCUPIED ----
      digitalWrite(RED_LED, HIGH);
      digitalWrite(GREEN_LED, LOW);

      display.setCursor(0, 10);
      display.println("OCCUPIED");

      Serial.println("Status: OCCUPIED");

      // Detect a fresh entry (edge: was vacant, now occupied)
      if (!wasOccupied) {
        usageCount++;
        Serial.print("New Use Detected! Total Uses: ");
        Serial.println(usageCount);
      }
    } else {
      // ---- VACANT ----
      digitalWrite(RED_LED, LOW);
      digitalWrite(GREEN_LED, HIGH);

      display.setCursor(0, 10);
      display.println("VACANT");

      Serial.println("Status: VACANT");
    }

    wasOccupied = isOccupied;

    // Print running usage count every cycle
    Serial.print("Restroom Uses: ");
    Serial.println(usageCount);

  } else {
    // ---- SENSOR OUT OF RANGE / INVALID ----
    digitalWrite(RED_LED, LOW);
    digitalWrite(GREEN_LED, LOW);

    display.setCursor(0, 20);
    display.println("NO DATA");

    Serial.println("Status: Out of Range");
  }

  // Show usage count on OLED (bottom-left, small text)
  display.setTextSize(1);
  display.setCursor(0, 45);
  display.print("Uses: ");
  display.println(usageCount);

  // Show soap restock warning on the same screen if triggered
  if (soapCount >= SOAP_MAX) {
    display.setCursor(0, 55);
    display.println("RESTOCK SOAP!");
  }

  display.display();
}

// ============================================================
// Reads FSR and converts force into soap count (0-20)
// ============================================================
void handleSoapDispenser() {
  int fsrValue = analogRead(FSR_PIN);

  // Convert analog value to soap count
  soapCount = map(fsrValue, FSR_MIN, FSR_MAX, 0, SOAP_MAX);

  // Limit range
  if (soapCount < 0) {
    soapCount = 0;
  }
  if (soapCount > SOAP_MAX) {
    soapCount = SOAP_MAX;
  }

  Serial.print("FSR Force: ");
  Serial.print(fsrValue);
  Serial.print("   Soap Count: ");
  Serial.print(soapCount);
  Serial.println("/20");

  if (soapCount >= SOAP_MAX) {
    Serial.println("** RESTOCK SOAP **");
  }
}> OCCUPIED transition (one "use")
unsigned long usageCount = 0;
bool wasOccupied = false;   // tracks previous occupancy state for edge detection

// ---------------- FSR SOAP LEVEL ----------------
const int FSR_PIN = A0;
// Adjust according to your sensor readings
const int FSR_MIN = 100;     // No pressure value
const int FSR_MAX = 3000;    // Maximum pressure value
const int SOAP_MAX = 20;
int soapCount = 0;

// ---------------- TIMING ----------------
const unsigned long LOOP_DELAY_MS = 200;

void setup() {
  Serial.begin(115200);
  delay(500);

  Wire.begin();

  pinMode(RED_LED, OUTPUT);
  pinMode(GREEN_LED, OUTPUT);
  digitalWrite(RED_LED, LOW);
  digitalWrite(GREEN_LED, LOW);

  pinMode(FSR_PIN, INPUT);

  Serial.println("========================================");
  Serial.println(" SMART RESTROOM MONITORING SYSTEM");
  Serial.println("========================================");

  // ---- OLED INIT ----
  if (!display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR)) {
    Serial.println("OLED init FAILED");
    while (1) { delay(10); }
  }
  display.clearDisplay();
  display.setTextSize(2);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(10, 20);
  display.println("Starting...");
  display.display();

  // ---- ToF SENSOR INIT ----
  if (!lox.begin()) {
    Serial.println("VL53L0X NOT FOUND!");
    display.clearDisplay();
    display.setTextSize(2);
    display.setCursor(0, 5);
    display.println("TOF ERROR");
    display.display();
    while (1) { delay(10); }
  }
  Serial.println("VL53L0X Ready");
  Serial.println("Soap Level Sensor Ready");
  Serial.println("----------------------------------------");

  delay(800);
}

void loop() {
  handleOccupancy();
  handleSoapDispenser();
  delay(LOOP_DELAY_MS);
}

// ============================================================
// Reads the ToF sensor, updates OLED + LEDs with occupancy status,
// and counts a restroom "use" on every VACANT -> OCCUPIED edge
// ============================================================
void handleOccupancy() {
  VL53L0X_RangingMeasurementData_t measure;
  lox.rangingTest(&measure, false);

  display.clearDisplay();
  display.setTextSize(2);
  display.setTextColor(SSD1306_WHITE);

  if (measure.RangeStatus != 4) {  // valid reading
    int distance = measure.RangeMilliMeter;
    bool isOccupied = (distance < OCCUPANCY_THRESHOLD_MM);

    Serial.print("Distance: ");
    Serial.print(distance);
    Serial.println(" mm");

    if (isOccupied) {
      // ---- OCCUPIED ----
      digitalWrite(RED_LED, HIGH);
      digitalWrite(GREEN_LED, LOW);

      display.setCursor(0, 10);
      display.println("OCCUPIED");

      Serial.println("Status: OCCUPIED");

      // Detect a fresh entry (edge: was vacant, now occupied)
      if (!wasOccupied) {
        usageCount++;
        Serial.print("New Use Detected! Total Uses: ");
        Serial.println(usageCount);
      }
    } else {
      // ---- VACANT ----
      digitalWrite(RED_LED, LOW);
      digitalWrite(GREEN_LED, HIGH);

      display.setCursor(0, 10);
      display.println("VACANT");

      Serial.println("Status: VACANT");
    }

    wasOccupied = isOccupied;

    // Print running usage count every cycle
    Serial.print("Restroom Uses: ");
    Serial.println(usageCount);

  } else {
    // ---- SENSOR OUT OF RANGE / INVALID ----
    digitalWrite(RED_LED, LOW);
    digitalWrite(GREEN_LED, LOW);

    display.setCursor(0, 20);
    display.println("NO DATA");

    Serial.println("Status: Out of Range");
  }

  // Show usage count on OLED (bottom-left, small text)
  display.setTextSize(1);
  display.setCursor(0, 45);
  display.print("Uses: ");
  display.println(usageCount);

  // Show soap restock warning on the same screen if triggered
  if (soapCount >= SOAP_MAX) {
    display.setCursor(0, 55);
    display.println("RESTOCK SOAP!");
  }

  display.display();
}

// ============================================================
// Reads FSR and converts force into soap count (0-20)
// ============================================================
void handleSoapDispenser() {
  int fsrValue = analogRead(FSR_PIN);

  // Convert analog value to soap count
  soapCount = map(fsrValue, FSR_MIN, FSR_MAX, 0, SOAP_MAX);

  // Limit range
  if (soapCount < 0) {
    soapCount = 0;
  }
  if (soapCount > SOAP_MAX) {
    soapCount = SOAP_MAX;
  }

  Serial.print("FSR Force: ");
  Serial.print(fsrValue);
  Serial.print("   Soap Count: ");
  Serial.print(soapCount);
  Serial.println("/20");

  if (soapCount >= SOAP_MAX) {
    Serial.println("** RESTOCK SOAP **");
  }
}

Smart Restroom Occupancy Monitor