Team Bumblebee:

•

•

•

Published August 2, 2025

Guide Dog for visually impaired people

A guide dog/rover for visually impaired people with obstacle detection and location tracking and plenty of room for future prospects.

IntermediateWork in progress59

Things used in this project

Hardware components

DFRobot FireBeetle ESP32 IOT Microcontroller (Supports Wi-Fi & Bluetooth)

Jumper wires (generic)

Ultrasonic Sensor - HC-SR04 (Generic)

SparkFun Dual H-Bridge motor drivers L298

DC motor (generic)

SG90 Micro-servo motor

Digilent IR Proximity Sensor

Battery, 3.7 V

LED (generic)

Software apps and online services

Arduino IDE

Microsoft VS Code

Bambu studio

Hand tools and fabrication machines

Soldering iron (generic)

Story

Problem Statement

Visually impaired individuals face significant challenges in navigating independently. Trained guide dogs are a traditional solution, but they require 2+ years of specialized training and involve high costs for food, healthcare, and maintenance. Furthermore, dogs can be distracted, fall sick, or have a limited working lifespan. This makes guide dogs inaccessible to many people worldwide.

Proposed Solution

This project introduces an autonomous robotic guide rover built using an ESP32 microcontroller. Unlike trained dogs, the rover requires no training period, works consistently without fatigue, and has lower long-term costs. Equipped with an HC-SR04 ultrasonic sensor and IR sensors, the rover detects obstacles in real time and chooses the safest direction to move. Additional modules like a servo motor, buzzer, and OLED display enhance usability and interaction.

The rover is built using an ESP32 Dev Module, IR sensors, Servo motor, Buzzer, L298N motor driver, and an HC-SR04 ultrasonic sensor to detect and avoid obstacles in its path. The rover intelligently navigates around objects by scanning both left and right sides, choosing the best direction based on real-time distance data. Trained guide dogs require significant time, effort, and resources to prepare for assisting visually impaired individuals. It can take up to two years of specialized training for a dog to reliably navigate complex environments, respond to commands, and handle unpredictable situations. Additionally, guide dogs come with ongoing costs for food, healthcare, and maintenance, which can be a financial burden over time. In contrast, a robotic guide system like this one offers several advantages: it requires no training period, can operate consistently without fatigue, and eliminates recurring expenses related to pet care. It also avoids issues like distraction, illness, or limited working lifespan that affect living animals, making it a more accessible and scalable solution in the long run.

How It Works

The ultrasonic sensor continuously measures the distance ahead.
The IR sensors widen the detection range on the left, right, and rear.
If the front is clear - the rover moves forward.
If an obstacle is detected - the rover stops and checks left/right paths.
Based on sensor input - it turns left, right, or makes a U-turn.
A rear IR sensor ensures the person is not left behind (stops if the person is too far).
The servo motor can perform actions like pulling a string.
The buzzer gives audible alerts when danger is detected.
The OLED display shows friendly feedback like “Hi!” or a smiley.

1 / 2 • robotic guide rover

Features
Obstacle detection and avoidance.
Real-time decision making.
Expandable with Bluetooth, GPS module, AI camera.
Low-cost components.
Uses PWM motor control via L298N.

Components Explanation

1. ESP32 Dev Module

The “brain” of the rover.
Handles all logic, sensor data processing, and motor control.
Provides Wi-Fi/Bluetooth for future upgrades like mobile app integration.

2. L298N Dual H-Bridge Motor Driver

Controls two DC motors independently.
Receives signals from the ESP32 to move forward, reverse, left, or right.
Provides PWM speed control.

3. HC-SR04 Ultrasonic Sensor

Measures distance to objects in front.
Prevents collisions by triggering stop/avoidance maneuvers.
Effective for 2 cm – 400 cm (ideal for obstacle avoidance).

4. IR Sensors (Left, Right, Rear)

Left & Right: Detect close-range side obstacles that ultrasonic might miss.
Rear: Detects whether the person being guided is close. If the person falls behind (>30 cm), the rover stops.

5. DC Motors (with Wheels)

Provides movement to the rover.
Controlled through L298N driver and powered by an external battery.

6. Servo Motor

Can be used for pulling a string or moving attachments.
Demonstrates expandability for assistive tasks.

7. Buzzer

Gives audio feedback in case of danger or when the rover halts.
Simple but effective alert system.

8. OLED Display (SSD1306)

Provides visual feedback like “Hi!” or a smiley face.
Positioned at the head of the rover for a more engaging demo.

9. Power Supply (Li-ion / 12V Pack)

Powers both the ESP32 and the motors via the L298N module.
Ensures portability and independence from wired sources.

Software Setup

Arduino IDE Installation

Install the latest version of Arduino IDE.
Add the ESP32 Board Package via the Boards Manager (using the Espressif URL).

Library Dependencies

Adafruit_GFX and Adafruit_SSD1306 → For OLED display.
ESP32Servo → For controlling the servo motor.
Wire → For I2C communication with the OLED.

Code Upload

Connect ESP32 via USB cable.
Select Board: ESP32 Dev Module.
Select the correct COM Port.
Upload the provided code to the ESP32.

Testing

Open Serial Monitor at 115200 baud to check sensor readings.
Verify motors respond correctly to forward, left, and right commands.
Confirm buzzer and OLED work as expected.

Applications

Assistive navigation for visually impaired individuals.
Educational robotics projects.
Expo demonstration of autonomous navigation.
Base platform for delivery or patrolling robots.

Market Impact & Future Vision

Accessibility Gap: Millions of visually impaired individuals struggle with mobility. Guide dogs are expensive (up to $50,000 over their lifetime) and not accessible to everyone. This rover offers a low-cost, scalable alternative.
Affordability: Built from off-the-shelf electronics, the cost is a fraction of training a guide dog, making it feasible for large-scale adoption.
Consistency: Unlike animals, the rover doesn’t tire, get sick, or lose focus. It provides reliable assistance 24/7.
Scalability: Units can be mass-produced and distributed to underserved regions, addressing the global shortage of guide dogs.

Future Implementations

GPS Navigation: Adding a GPS module would allow the rover to follow predefined routes or assist with navigation in outdoor environments, helping the user reach specific destinations with greater autonomy.

AI-Based Camera Vision: Incorporating an AI-enabled camera would enable the system to recognize obstacles, traffic signs, and human gestures. This would allow smarter decision-making, obstacle avoidance, and even pedestrian signal detection for crossing roads safely.

Bluetooth Audio Output: A Bluetooth module can be used to transmit real-time audio commands to a wireless earpiece worn by the user. This allows the system to give clear verbal instructions or alerts (e.g., “Obstacle ahead, ” “Turn left, ” etc.) without relying on visual cues.

Mobile App Integration: A dedicated smartphone app can allow users or caregivers to remotely monitor the rover’s status, location, and battery level. It can also offer manual control features, speed adjustment etc. Caregivers can receive alerts in case of an emergency or if the rover stops unexpectedly.

1 / 2 • front view

Body Design

We have used a Bambu Lab 3D Printer to 3D print the body of our rover. We first created a design containing various parts of the rover and assembled it all together to obtain the final build.

3d printing the model

Schematics

Code

Guide rover for visually impaired people

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

// OLED setup
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

// Motor pins
#define IN1 14
#define IN2 15
#define ENA 12
#define IN3 32
#define IN4 33
#define ENB 13

// IR sensors
#define IR_LEFT 19
#define IR_RIGHT 23
#define IR_REAR 22

// Ultrasonic
#define TRIG_PIN 5
#define ECHO_PIN 18

// Servo (optional string/tail)
#define SERVO_PIN 25
Servo stringServo;

// Buzzer
#define BUZZER_PIN 4

const int motorSpeed = 180;
const int safeDistance = 50; // cm

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

  // Motor setup
  pinMode(IN1, OUTPUT); pinMode(IN2, OUTPUT); pinMode(ENA, OUTPUT);
  pinMode(IN3, OUTPUT); pinMode(IN4, OUTPUT); pinMode(ENB, OUTPUT);

  // Sensors
  pinMode(IR_LEFT, INPUT);
  pinMode(IR_RIGHT, INPUT);
  pinMode(IR_REAR, INPUT);
  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);

  pinMode(BUZZER_PIN, OUTPUT);
  digitalWrite(BUZZER_PIN, LOW);

  stringServo.attach(SERVO_PIN);

  // OLED
  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println("OLED init failed");
    while (true);
  }
  display.setRotation(2);
  display.clearDisplay();

  // Centered "Hi!"
  display.setTextSize(2);
  display.setTextColor(SSD1306_WHITE);
  int16_t x, y;
  uint16_t w, h;
  display.getTextBounds("Hi!", 0, 0, &x, &y, &w, &h);
  display.setCursor((SCREEN_WIDTH - w) / 2, 0);
  display.println("Hi!");

  // Eyes
  display.fillCircle(60, 40, 2, SSD1306_WHITE);
  display.fillCircle(68, 40, 2, SSD1306_WHITE);

  // Smile
  display.drawLine(60, 52, 64, 56, SSD1306_WHITE);
  display.drawLine(64, 56, 68, 52, SSD1306_WHITE);

  display.display();

  stopMotors();
}

void loop() {
  int distance = getDistance();
  bool frontLeft = digitalRead(IR_LEFT) == LOW;
  bool frontRight = digitalRead(IR_RIGHT) == LOW;
  bool rearClear = digitalRead(IR_REAR) == HIGH;

  Serial.print("Ultrasonic Distance: ");
  Serial.print(distance);
  Serial.println(" cm");

  if (rearClear) {
    stopMotors();
    buzz();
    return;
  } else {
    noBuzz();
  }

  // Obstacle in front
  if (distance < safeDistance || frontLeft || frontRight) {
    if (frontLeft && !frontRight) {
      turnRight();
    } else if (!frontLeft && frontRight) {
      turnLeft();
    } else {
      stopMotors();
    }
  } else {
    moveForward();
  }

  delay(150);
}

// ========================== Functions ==========================

int getDistance() {
  digitalWrite(TRIG_PIN, LOW); delayMicroseconds(2);
  digitalWrite(TRIG_PIN, HIGH); delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);
  long duration = pulseIn(ECHO_PIN, HIGH, 300000);
  if (duration == 0) return 1000;
  return duration * 0.034 / 2;
}

void moveForward() {
  digitalWrite(IN1, LOW);  digitalWrite(IN2, HIGH);
  digitalWrite(IN3, LOW);  digitalWrite(IN4, HIGH);
  analogWrite(ENA, motorSpeed);
  analogWrite(ENB, motorSpeed);
}

void stopMotors() {
  digitalWrite(IN1, LOW);  digitalWrite(IN2, LOW);
  digitalWrite(IN3, LOW);  digitalWrite(IN4, LOW);
  analogWrite(ENA, 0); analogWrite(ENB, 0);
}

void turnLeft() {
  digitalWrite(IN1, LOW);  digitalWrite(IN2, HIGH);
  digitalWrite(IN3, HIGH); digitalWrite(IN4, LOW);
  analogWrite(ENA, motorSpeed);
  analogWrite(ENB, motorSpeed);
}

void turnRight() {
  digitalWrite(IN1, HIGH); digitalWrite(IN2, LOW);
  digitalWrite(IN3, LOW);  digitalWrite(IN4, HIGH);
  analogWrite(ENA, motorSpeed);
  analogWrite(ENB, motorSpeed);
}

void buzz() {
  digitalWrite(BUZZER_PIN, HIGH);
}

void noBuzz() {
  digitalWrite(BUZZER_PIN, LOW);
}

Guide Dog for visually impaired people