Absolutely . I can structure this as a complete final-year/academic IoT + AI project documentation, including the architecture, hardware, circuit/schematic, ESP32 firmware, n8n workflows, Telegram voice alerts, Google Sheets logging, ThingSpeak dashboard, AI-agent logic, webpage, testing, and future scope .

AI Smart Shoes for Blind People with Obstacle Prediction

Project Title

AI-Powered Smart Shoes for Blind People with Obstacle Detection, Prediction and Agentic IoT Voice Alerts using ESP32, n8n, Telegram, Google Sheets and ThingSpeak

1. Abstract

The proposed system is an AI-enabled assistive smart-shoe platform designed to help visually impaired people detect obstacles and receive timely audio notifications while walking.

Sensors mounted on the shoe continuously monitor the environment. An ESP32 collects sensor readings and determines the distance and approximate direction of nearby obstacles. Instead of relying only on a conventional buzzer, the system connects to an IoT automation platform using n8n.

The n8n workflow acts as an automation and AI-agent layer:

Sensors
   ↓
ESP32
   ↓
Wi-Fi
   ↓
n8n Webhook
   ↓
AI Agent
   ↓
Decision / Classification
   ↓
Telegram Voice Alert
   ↓
User

At the same time, measurements can be stored in Google Sheets for historical analysis and sent to ThingSpeak for graphical IoT visualization.

The system can classify situations such as:

No obstacle
Obstacle detected
Obstacle on the left
Obstacle on the right
Obstacle directly ahead
Very close obstacle
Repeated obstacle
Potentially dangerous situation

The important design principle is that the AI layer should supplement—not replace—the immediate local safety mechanism. A network connection or AI service should never be required for the shoe to provide its most basic nearby-obstacle warning.

2. Main Objectives

The project has several objectives:

Develop a wearable obstacle-detection system using ESP32.
Detect objects in front/left/right of the user.
Estimate obstacle distance.
Identify potentially dangerous obstacles.
Provide immediate local feedback.
Send sensor information to an IoT cloud/automation layer.
Use n8n to automate data processing.
Use an AI agent to interpret sensor events.
Send voice notifications through Telegram.
Record sensor information in Google Sheets.
Visualize sensor data using ThingSpeak.
Provide a web-based monitoring dashboard.
Maintain an event history for analysis.
Reduce unnecessary repeated notifications.
Build a scalable architecture that can later incorporate computer vision or more sophisticated prediction.

3. Proposed System Architecture

                    ┌─────────────────────────┐
                    │       SMART SHOE        │
                    │                         │
                    │  ┌───────────────────┐  │
                    │  │     ESP32         │  │
                    │  └───────┬───────────┘  │
                    │          │              │
                    │   ┌──────┼───────┐      │
                    │   ↓      ↓       ↓      │
                    │ HC-SR04  Left   Right   │
                    │ /ToF     Sensor Sensor  │
                    └──────────┬──────────────┘
                               │
                               │ Wi-Fi
                               ↓
                    ┌──────────────────────┐
                    │     n8n Webhook      │
                    └──────────┬───────────┘
                               │
                 ┌─────────────┼──────────────┐
                 ↓             ↓              ↓
          ┌────────────┐ ┌────────────┐ ┌──────────────┐
          │ AI Agent   │ │ Google     │ │ ThingSpeak   │
          │            │ │ Sheets     │ │ Dashboard    │
          └─────┬──────┘ └────────────┘ └──────────────┘
                │
                ↓
        ┌───────────────────┐
        │ Alert Decision    │
        │ Engine             │
        └─────────┬─────────┘
                  │
                  ↓
           ┌─────────────┐
           │  Telegram   │
           │ Voice Alert │
           └──────┬──────┘
                  │
                  ↓
              USER

4. Hardware Components

A practical prototype can use the following components.

Component	Purpose
ESP32 DevKit	Main microcontroller
Ultrasonic/ToF sensors	Obstacle-distance measurement
Left sensor	Detect left-side obstacles
Right sensor	Detect right-side obstacles
Front sensor	Detect obstacle ahead
Vibration motors	Silent/local tactile warning
Buzzer	Emergency local warning
Li-ion/Li-Po battery	Portable power
Battery charging/protection circuit	Safe charging
Voltage regulator	Stable supply
Push button	Emergency/control input
LED	Status indication
Shoe/strap enclosure	Physical mounting

Recommended sensor configuration

For a prototype:

                  USER
                   ↑
                   │
              FRONT SENSOR
                   │
             ┌─────┴─────┐
             │   SHOE    │
 LEFT SENSOR ←│  ESP32   │→ RIGHT SENSOR
             │           │
             └───────────┘

For a more advanced version, replace ultrasonic sensors with ToF sensors, because multiple ultrasonic sensors can interfere with each other if triggered simultaneously.

5. Why Three Sensors?

A single sensor can answer:

"Is something nearby?"

Three sensors allow the system to estimate:

"Where is the obstacle?"

For example:

             FRONT
               │
               │
          [Obstacle]
               │
       ┌───────┴───────┐
       │      👤       │
       │     USER      │
       │               │
    LEFT             RIGHT

Example readings:

Front = 55 cm
Left  = 180 cm
Right = 170 cm

The system interprets this as:

Obstacle direction = FRONT
Distance = 55 cm
Risk = HIGH

Another example:

Front = 180 cm
Left  = 45 cm
Right = 170 cm

Result:

Obstacle direction = LEFT
Distance = 45 cm
Risk = HIGH

6. Obstacle-Distance Classification

A simple initial rule system can be:

Distance > 200 cm
       ↓
     SAFE

100–200 cm
       ↓
    CAUTION

50–100 cm
       ↓
     WARNING

< 50 cm
       ↓
   DANGER

These values should be experimentally calibrated because sensor accuracy, walking speed, mounting position, floor conditions, and object shape affect the actual performance.

7. Local Safety Layer

This is extremely important.

Do not design the system so that:

Sensor → Internet → AI → Telegram → User

is the only safety path.

Instead:

              ┌───────────────┐
Sensor ──────→│ ESP32 LOCAL   │────→ Vibration/Buzzer
              │ SAFETY LOGIC  │
              └───────┬───────┘
                      │
                      ↓
                    Wi-Fi
                      ↓
                    n8n
                      ↓
                  AI Agent
                      ↓
                  Telegram

If Wi-Fi fails, the shoe should still detect nearby obstacles and activate its local warning.

8. ESP32 Pin Configuration

Example configuration:

Device	ESP32 GPIO
Front Trigger	GPIO 5
Front Echo	GPIO 18
Left Trigger	GPIO 19
Left Echo	GPIO 21
Right Trigger	GPIO 22
Right Echo	GPIO 23
Left vibration motor	GPIO 25
Right vibration motor	GPIO 26
Buzzer	GPIO 27
Status LED	GPIO 2
Emergency button	GPIO 4

Important: If using a classic HC-SR04 with a 5 V Echo output, do not connect Echo directly to an ESP32 GPIO. Use an appropriate voltage divider/level-shifting circuit.

9. Basic Schematic

                 +-------------------+
                 |      ESP32        |
                 |                   |
 FRONT TRIG -----| GPIO5             |
 FRONT ECHO -----| GPIO18            |
 LEFT TRIG ------| GPIO19            |
 LEFT ECHO ------| GPIO21            |
 RIGHT TRIG -----| GPIO22            |
 RIGHT ECHO -----| GPIO23            |
                 |                   |
 VIBRATION L ----| GPIO25            |
 VIBRATION R ----| GPIO26            |
 BUZZER ---------| GPIO27            |
 LED ------------| GPIO2             |
 BUTTON ---------| GPIO4             |
                 |                   |
                 +---------+---------+
                           |
                          GND

Power arrangement

       Li-ion Battery
             │
             ↓
     Protection / Charger
             │
             ↓
       Voltage Regulator
             │
       ┌─────┴──────┐
       ↓            ↓
     ESP32        Sensors
                    │
             ┌──────┴──────┐
             ↓             ↓
        Vibration       Buzzer

The exact battery/regulator arrangement should be selected according to the ESP32 board and sensors being used.

10. ESP32 Operating Logic

The ESP32 performs the following sequence:

START
  ↓
Initialize sensors
  ↓
Initialize Wi-Fi
  ↓
Read front distance
  ↓
Read left distance
  ↓
Read right distance
  ↓
Filter readings
  ↓
Determine closest obstacle
  ↓
Determine direction
  ↓
Calculate risk
  ↓
Activate local warning
  ↓
Send event to n8n
  ↓
Repeat

11. ESP32 Firmware

Below is a starting Arduino IDE implementation.

#include <WiFi.h>
#include <HTTPClient.h>

// -----------------------------
// Wi-Fi configuration
// -----------------------------
const char* WIFI_SSID = "YOUR_WIFI";
const char* WIFI_PASSWORD = "YOUR_PASSWORD";

// n8n webhook URL
const char* N8N_WEBHOOK =
    "https://YOUR_N8N_DOMAIN/webhook/smart-shoe";

// -----------------------------
// Sensor pins
// -----------------------------
#define FRONT_TRIG 5
#define FRONT_ECHO 18

#define LEFT_TRIG 19
#define LEFT_ECHO 21

#define RIGHT_TRIG 22
#define RIGHT_ECHO 23

// -----------------------------
// Output pins
// -----------------------------
#define VIB_LEFT 25
#define VIB_RIGHT 26
#define BUZZER 27
#define STATUS_LED 2

// -----------------------------
// Thresholds
// -----------------------------
const float DANGER_DISTANCE = 50.0;
const float WARNING_DISTANCE = 100.0;
const float CAUTION_DISTANCE = 200.0;


// Measure distance
float readDistance(int trigPin, int echoPin)
{
    digitalWrite(trigPin, LOW);
    delayMicroseconds(3);

    digitalWrite(trigPin, HIGH);
    delayMicroseconds(10);

    digitalWrite(trigPin, LOW);

    long duration = pulseIn(echoPin, HIGH, 30000);

    if (duration == 0)
        return 999.0;

    float distance = duration * 0.0343 / 2.0;

    return distance;
}


// Connect Wi-Fi
void connectWiFi()
{
    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);

    Serial.print("Connecting to Wi-Fi");

    while (WiFi.status() != WL_CONNECTED)
    {
        delay(500);
        Serial.print(".");
    }

    Serial.println();
    Serial.println("Wi-Fi connected");
    Serial.println(WiFi.localIP());
}


// Determine direction
String getDirection(float front, float left, float right)
{
    float minimum = min(front, min(left, right));

    if (minimum == front)
        return "FRONT";

    if (minimum == left)
        return "LEFT";

    return "RIGHT";
}


// Determine risk
String getRisk(float distance)
{
    if (distance <= DANGER_DISTANCE)
        return "DANGER";

    if (distance <= WARNING_DISTANCE)
        return "WARNING";

    if (distance <= CAUTION_DISTANCE)
        return "CAUTION";

    return "SAFE";
}


// Local warning
void localWarning(
    float front,
    float left,
    float right)
{
    digitalWrite(VIB_LEFT, LOW);
    digitalWrite(VIB_RIGHT, LOW);
    digitalWrite(BUZZER, LOW);

    float minimum = min(front, min(left, right));

    if (minimum <= DANGER_DISTANCE)
    {
        String direction = getDirection(front, left, right);

        digitalWrite(BUZZER, HIGH);

        if (direction == "LEFT")
            digitalWrite(VIB_LEFT, HIGH);

        else if (direction == "RIGHT")
            digitalWrite(VIB_RIGHT, HIGH);

        else
        {
            digitalWrite(VIB_LEFT, HIGH);
            digitalWrite(VIB_RIGHT, HIGH);
        }
    }
}


// Send data to n8n
void sendToN8N(
    float front,
    float left,
    float right,
    String direction,
    String risk)
{
    if (WiFi.status() != WL_CONNECTED)
        return;

    HTTPClient http;

    http.begin(N8N_WEBHOOK);
    http.addHeader("Content-Type", "application/json");

    String json = "{";
    json += "\"front\":" + String(front, 1) + ",";
    json += "\"left\":" + String(left, 1) + ",";
    json += "\"right\":" + String(right, 1) + ",";
    json += "\"direction\":\"" + direction + "\",";
    json += "\"risk\":\"" + risk + "\",";
    json += "\"device\":\"SMART_SHOE_01\"";
    json += "}";

    int responseCode = http.POST(json);

    Serial.print("n8n response: ");
    Serial.println(responseCode);

    http.end();
}


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

    pinMode(FRONT_TRIG, OUTPUT);
    pinMode(FRONT_ECHO, INPUT);

    pinMode(LEFT_TRIG, OUTPUT);
    pinMode(LEFT_ECHO, INPUT);

    pinMode(RIGHT_TRIG, OUTPUT);
    pinMode(RIGHT_ECHO, INPUT);

    pinMode(VIB_LEFT, OUTPUT);
    pinMode(VIB_RIGHT, OUTPUT);

    pinMode(BUZZER, OUTPUT);
    pinMode(STATUS_LED, OUTPUT);

    connectWiFi();
}


void loop()
{
    float front = readDistance(FRONT_TRIG, FRONT_ECHO);

    delay(50);

    float left = readDistance(LEFT_TRIG, LEFT_ECHO);

    delay(50);

    float right = readDistance(RIGHT_TRIG, RIGHT_ECHO);

    String direction = getDirection(front, left, right);

    float minimum = min(front, min(left, right));

    String risk = getRisk(minimum);

    Serial.println("---------------------------");

    Serial.print("Front: ");
    Serial.println(front);

    Serial.print("Left: ");
    Serial.println(left);

    Serial.print("Right: ");
    Serial.println(right);

    Serial.print("Direction: ");
    Serial.println(direction);

    Serial.print("Risk: ");
    Serial.println(risk);

    localWarning(front, left, right);

    // Send only meaningful events
    if (risk != "SAFE")
    {
        sendToN8N(
            front,
            left,
            right,
            direction,
            risk
        );
    }

    delay(500);
}

This is a prototype firmware, not medical/safety-certified navigation software. For a real assistive product, additional validation, fault handling, environmental testing, and accessibility/user testing would be required.

12. n8n Architecture

The n8n workflow becomes the central IoT automation layer.

                 ESP32
                   │
                   │ HTTP POST
                   ↓
          ┌──────────────────┐
          │  Webhook Node    │
          └────────┬─────────┘
                   ↓
          ┌──────────────────┐
          │ Validate Data    │
          └────────┬─────────┘
                   ↓
          ┌──────────────────┐
          │ Calculate Risk   │
          └────────┬─────────┘
                   ↓
          ┌──────────────────┐
          │ AI Agent         │
          └────────┬─────────┘
                   ↓
             ┌─────┴─────┐
             ↓           ↓
       Google Sheets   ThingSpeak
             │
             ↓
        Event Database

                   AI Decision
                       ↓
               ┌──────────────┐
               │ Alert Needed?│
               └──────┬───────┘
                      │ YES
                      ↓
              Telegram Message
                      ↓
                 Voice Alert

13. n8n Workflow — Node by Node

Node 1 — Webhook

Method:

POST

Example incoming JSON:

{
  "front": 42.5,
  "left": 160.2,
  "right": 125.4,
  "direction": "FRONT",
  "risk": "DANGER",
  "device": "SMART_SHOE_01"
}

Node 2 — Data Validation

Check:

front exists
left exists
right exists
risk exists
device exists

Reject malformed packets.

Node 3 — Function/Code Node

Example:

const front = Number($json.front);
const left = Number($json.left);
const right = Number($json.right);

const minimum = Math.min(front, left, right);

let direction = "NONE";

if (minimum === front) {
  direction = "FRONT";
} else if (minimum === left) {
  direction = "LEFT";
} else {
  direction = "RIGHT";
}

let risk = "SAFE";

if (minimum <= 50) {
  risk = "DANGER";
} else if (minimum <= 100) {
  risk = "WARNING";
} else if (minimum <= 200) {
  risk = "CAUTION";
}

return [{
  json: {
    ...$json,
    minimum,
    direction,
    risk,
    timestamp: new Date().toISOString()
  }
}];

14. AI Agent

The AI agent should interpret structured sensor data, not invent sensor measurements.

Example system instruction:

You are the decision assistant for a wearable obstacle
detection system.

Your job is to interpret sensor readings from an ESP32.

Rules:

1. Never invent sensor measurements.
2. Use only the supplied readings.
3. Identify the closest obstacle.
4. Identify its approximate direction.
5. Classify the event as SAFE, CAUTION, WARNING or DANGER.
6. Generate a very short voice-friendly alert.
7. Do not provide unnecessary explanations.
8. Do not claim that the system can see or identify an object
   unless an appropriate vision sensor has actually supplied
   that information.
9. If sensor data is invalid, return SENSOR_ERROR.

Input:

{
  "front": 38,
  "left": 160,
  "right": 142,
  "device": "SMART_SHOE_01"
}

Possible output:

{
  "status": "DANGER",
  "direction": "FRONT",
  "distance_cm": 38,
  "alert_required": true,
  "voice_message": "Obstacle very close ahead."
}

15. Important Meaning of "AI Prediction"

The phrase obstacle prediction needs to be technically defined.

A distance sensor alone primarily performs:

Obstacle detection and distance estimation.

True prediction could mean:

Current measurements
       +
Previous measurements
       +
Movement trend
       +
Walking speed
       ↓
Predicted future obstacle proximity

For example:

Time      Distance
T1        140 cm
T2        115 cm
T3         90 cm
T4         65 cm

The system detects that the obstacle is getting closer.

A future version could calculate:

Distance rate:

Δd / Δt

and estimate:

Estimated time-to-obstacle =
current distance / closing speed

This is much more defensible technically than claiming that a simple ultrasonic sensor performs AI object prediction.

16. Obstacle Prediction Algorithm

Suppose:

Previous distance = 100 cm
Current distance = 80 cm

Time interval = 0.5 sec

Then:

Closing speed =
(100 - 80) / 0.5

= 40 cm/sec

Estimated time:

80 / 40
= 2 seconds

The system could therefore generate:

"Obstacle approaching in approximately two seconds."

However, noisy sensor measurements must be filtered before making such a prediction.

17. Moving Average Filter

A simple filter:

float smoothDistance(
    float oldValue,
    float newValue)
{
    const float alpha = 0.3;

    return
        alpha * newValue +
        (1 - alpha) * oldValue;
}

This reduces sudden measurement fluctuations.

A more advanced implementation could use:

Median filtering
Exponential moving average
Kalman filtering
Sensor fusion

18. Telegram Voice Alert

The Telegram portion can operate like this:

ESP32
  ↓
n8n
  ↓
AI Agent
  ↓
"Obstacle very close ahead."
  ↓
Text-to-Speech
  ↓
Audio file
  ↓
Telegram Bot
  ↓
User's smartphone
  ↓
Voice/audio alert

Example alert messages:

"Obstacle ahead."

"Obstacle very close on your left."

"Obstacle approaching from the right."

"Multiple nearby obstacles detected."

"Sensor error. Please stop and check the device."

For accessibility, messages should be short, unambiguous and consistent.

19. Telegram Conversation Example

SMART SHOE BOT
──────────────

🤖 Smart Shoe:
Obstacle detected ahead.

👤 User:
Status

🤖 Smart Shoe:
Front: 82 cm.
Left: 160 cm.
Right: 145 cm.
Current status: WARNING.

👤 User:
What is the closest obstacle?

🤖 Smart Shoe:
The closest detected obstacle is ahead,
approximately 82 centimeters away.

Another example:

🤖 Smart Shoe:
⚠️ Obstacle very close on your right.

🔊 Voice:
"Obstacle very close on your right."

20. Google Sheets Integration

Google Sheets can act as the project's historical event database.

Example columns:

Timestamp	Device	Front	Left	Right	Direction	Risk	Alert
21:30:01	SHOE01	180	170	190	FRONT	SAFE	No
21:30:03	SHOE01	95	170	180	FRONT	CAUTION	Yes
21:30:04	SHOE01	62	160	175	FRONT	WARNING	Yes
21:30:05	SHOE01	38	160	175	FRONT	DANGER	Yes

This enables later analysis of:

Number of obstacles
Most frequent direction
Average distance
Number of danger events
Alert frequency
Sensor errors
Walking-session duration

21. ThingSpeak Dashboard

ThingSpeak can be used as the IoT visualization layer.

Possible channels:

Field 1 → Front Distance
Field 2 → Left Distance
Field 3 → Right Distance
Field 4 → Risk Level
Field 5 → Closing Speed
Field 6 → Battery

Conceptually:

             THINGSPEAK
                  │
       ┌──────────┼──────────┐
       ↓          ↓          ↓
    Front       Left       Right
  Distance    Distance    Distance
       │          │          │
       └──────────┼──────────┘
                  ↓
             Trend Graph

22. Web Dashboard

The project can additionally provide an IoT webpage.

Example layout:

┌─────────────────────────────────────────────┐
│          AI SMART SHOE DASHBOARD            │
├─────────────────────────────────────────────┤
│                                             │
│  DEVICE: SMART_SHOE_01       🟢 ONLINE      │
│                                             │
├──────────────┬──────────────┬───────────────┤
│ FRONT        │ LEFT         │ RIGHT         │
│              │              │               │
│ 82 cm        │ 165 cm       │ 145 cm        │
│              │              │               │
├──────────────┴──────────────┴───────────────┤
│                                             │
│ STATUS:       ⚠️ WARNING                    │
│                                             │
│ DIRECTION:    FRONT                         │
│                                             │
│ AI: Obstacle approaching                    │
│                                             │
├─────────────────────────────────────────────┤
│             SENSOR HISTORY                  │
│                                             │
│       📈 Distance Graph                     │
│                                             │
└─────────────────────────────────────────────┘

23. Example HTML Dashboard

A simple starting webpage:

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>AI Smart Shoe Dashboard</title>

    <style>
        body {
            font-family: Arial, sans-serif;
            background: #101820;
            color: white;
            margin: 0;
            padding: 20px;
        }

        h1 {
            text-align: center;
        }

        .dashboard {
            max-width: 900px;
            margin: auto;
        }

        .cards {
            display: flex;
            gap: 20px;
            justify-content: center;
            flex-wrap: wrap;
        }

        .card {
            background: #1c2b36;
            padding: 25px;
            border-radius: 15px;
            width: 200px;
            text-align: center;
        }

        .value {
            font-size: 35px;
            color: #00e5ff;
        }

        .status {
            text-align: center;
            padding: 25px;
            margin-top: 25px;
            background: #283b47;
            border-radius: 15px;
        }

        .danger {
            color: #ff4444;
        }

        .warning {
            color: #ffaa00;
        }

        .safe {
            color: #00ff88;
        }
    </style>
</head>

<body>

<div class="dashboard">

    <h1>AI Smart Shoe</h1>

    <div class="cards">

        <div class="card">
            <h3>FRONT</h3>
            <div class="value" id="front">--</div>
            <p>cm</p>
        </div>

        <div class="card">
            <h3>LEFT</h3>
            <div class="value" id="left">--</div>
            <p>cm</p>
        </div>

        <div class="card">
            <h3>RIGHT</h3>
            <div class="value" id="right">--</div>
            <p>cm</p>
        </div>

    </div>

    <div class="status">

        <h2>Status</h2>

        <h1 id="risk">WAITING</h1>

        <p>
            Direction:
            <strong id="direction">--</strong>
        </p>

        <p id="message">
            Waiting for sensor data...
        </p>

    </div>

</div>

<script>

function updateDashboard(data) {

    document.getElementById("front").innerText =
        data.front;

    document.getElementById("left").innerText =
        data.left;

    document.getElementById("right").innerText =
        data.right;

    document.getElementById("risk").innerText =
        data.risk;

    document.getElementById("direction").innerText =
        data.direction;

    document.getElementById("message").innerText =
        data.message;
}


// Example data
updateDashboard({
    front: 82,
    left: 160,
    right: 145,
    risk: "WARNING",
    direction: "FRONT",
    message: "Obstacle approaching ahead."
});

</script>

</body>
</html>

24. Complete Data Flow

The complete project can be represented as:

┌──────────────────────────────────────────────────────┐
│                    SMART SHOE                        │
│                                                      │
│   Front Sensor    Left Sensor    Right Sensor        │
│        │               │              │              │
│        └───────────────┼──────────────┘              │
│                        ↓                             │
│                      ESP32                          │
│                        │                             │
│             ┌──────────┴─────────┐                  │
│             ↓                    ↓                  │
│      Local Safety Logic       Wi-Fi                 │
│             │                    │                  │
│             ↓                    ↓                  │
│      Vibration/Buzzer          n8n                  │
└───────────────────────────────┬──────────────────────┘
                                │
                                ↓
                       ┌────────────────┐
                       │ Data Validation│
                       └───────┬────────┘
                               ↓
                       ┌────────────────┐
                       │ Risk Algorithm │
                       └───────┬────────┘
                               ↓
                       ┌────────────────┐
                       │    AI Agent    │
                       └───────┬────────┘
                               │
                ┌──────────────┼───────────────┐
                ↓              ↓               ↓
          Telegram        Google Sheets    ThingSpeak
             │                  │               │
             ↓                  ↓               ↓
        Voice Alert          History         Dashboard
             │
             ↓
            USER

25. n8n Workflow in More Detail

A recommended workflow is:

[Webhook]
    │
    ↓
[Set / Normalize Data]
    │
    ↓
[Code: Distance Calculation]
    │
    ├──────────────→ [Google Sheets]
    │
    ├──────────────→ [ThingSpeak]
    │
    ↓
[AI Agent]
    │
    ↓
[Structured AI Output]
    │
    ↓
[IF: alert_required]
    │
    ├── NO → END
    │
    YES
    ↓
[Text-to-Speech]
    │
    ↓
[Telegram]
    │
    ↓
[Log Alert]
    │
    ↓
   END

26. Preventing Alert Spam

A major problem with IoT alerts is:

Obstacle
Obstacle
Obstacle
Obstacle
Obstacle
Obstacle

which could result in five Telegram messages every second.

Instead, implement:

Same event
    ↓
Compare previous event
    ↓
Same direction + similar distance?
    ↓
YES
    ↓
Suppress repeated alert

For example:

21:30:01  Front 45 cm → ALERT
21:30:02  Front 43 cm → suppress
21:30:03  Front 42 cm → suppress
21:30:04  Front 30 cm → ALERT

This can be implemented using an n8n Data Store/database or a local state mechanism.

27. AI Agent Decision Example

Input:

{
    "front": 42,
    "left": 170,
    "right": 150,
    "previous_front": 70,
    "time_difference": 1
}

AI/logic layer:

Current distance = 42 cm
Previous distance = 70 cm

Obstacle is approaching.

Closing speed ≈ 28 cm/s

Risk = DANGER
Direction = FRONT

Output:

{
    "alert_required": true,
    "severity": "DANGER",
    "direction": "FRONT",
    "voice_message": "Obstacle very close ahead."
}

28. Chatbot Command Architecture

The Telegram bot can support commands:

/start
/status
/distance
/battery
/history
/alerts
/location
/stop
/help

Example:

User → /status

Bot →
Smart Shoe Status

Device: SHOE_01
Battery: 78%
Front: 120 cm
Left: 180 cm
Right: 150 cm

Status: CAUTION

29. Emergency Button

An emergency button can provide another useful function.

        PRESS BUTTON
              ↓
            ESP32
              ↓
             n8n
              ↓
      Emergency workflow
              ↓
      Telegram notification

Possible message:

🚨 Smart Shoe Emergency Alert

The emergency button on
SMART_SHOE_01 was activated.

Time: 21:35:12

If location functionality is later added, the message can include the device's location.

30. Battery Monitoring

An ADC input can be used to monitor battery voltage through an appropriate voltage-divider circuit.

Conceptually:

Battery
  │
  ├── Voltage Divider
  │
  ↓
ESP32 ADC
  │
  ↓
Battery %
  │
  ├──→ n8n
  ├──→ Google Sheets
  └──→ Dashboard

Example:

Battery > 30% → NORMAL

Battery 15–30% → LOW

Battery < 15% → CRITICAL

The exact battery percentage calculation should be calibrated to the selected battery chemistry and power-management circuit rather than assuming a linear voltage-to-percentage relationship.

31. Software Stack

Hardware
────────
ESP32
Ultrasonic / ToF Sensors
Vibration Motors
Buzzer

Firmware
────────
Arduino IDE
C/C++

IoT
───
Wi-Fi
HTTP/REST
Webhook

Automation
──────────
n8n

AI
──
LLM / AI Agent

Notification
────────────
Telegram Bot
Text-to-Speech

Storage
───────
Google Sheets

Visualization
─────────────
ThingSpeak
Web Dashboard

32. Software Development Flow

Install Arduino IDE
        ↓
Install ESP32 board support
        ↓
Connect ESP32
        ↓
Upload sensor test
        ↓
Verify distances
        ↓
Add local warning
        ↓
Connect Wi-Fi
        ↓
Create n8n webhook
        ↓
Send ESP32 JSON
        ↓
Verify n8n
        ↓
Add Google Sheets
        ↓
Add ThingSpeak
        ↓
Add AI Agent
        ↓
Add Telegram
        ↓
Add Text-to-Speech
        ↓
Test complete system

33. Testing Plan

Test 1 — No obstacle

Front = 250 cm
Left  = 240 cm
Right = 260 cm

Expected:

Status = SAFE
No emergency alert

Test 2 — Front obstacle

Front = 80 cm

Expected:

Direction = FRONT
Risk = WARNING/CAUTION depending on configured threshold

Test 3 — Left obstacle

Left = 40 cm

Expected:

Direction = LEFT
Risk = DANGER
Left vibration activated
Telegram alert

Test 4 — Right obstacle

Right = 35 cm

Expected:

Direction = RIGHT
Risk = DANGER
Right vibration activated
Telegram alert

Test 5 — Wi-Fi failure

Wi-Fi = OFF

Expected:

Local sensor detection continues
Vibration/buzzer continues
Cloud alert unavailable

This test is particularly important because the wearable's basic warning capability should not depend entirely on Internet connectivity.

34. Performance Metrics

Your project report can measure:

Detection accuracy

Detection Accuracy =
Correct detections / Total test obstacles × 100

False-positive rate

False Positive Rate =
False alerts / Total observations × 100

Alert latency

Alert Latency =
Telegram alert time − Sensor detection time

Prediction error

For predicted time-to-obstacle:

Prediction Error =
|Predicted Time − Actual Time|

Battery endurance

Operating Time =
Battery capacity / Average current consumption

Actual battery life must be measured experimentally because Wi-Fi transmission and sensor duty cycle significantly affect consumption.

35. Advantages

Wearable form factor
Hands-free obstacle detection
Directional sensing
Local vibration feedback
Cloud connectivity
AI-assisted interpretation
Telegram notifications
Historical logging
IoT visualization
Expandable architecture
Remote monitoring capability
Event-based automation

36. Limitations

The prototype should explicitly document limitations.

For example:

Ultrasonic sensors do not identify object type.
Sensor readings can be affected by object shape and surface characteristics.
Outdoor environments can introduce measurement variability.
Internet-dependent functions fail when connectivity is unavailable.
AI output should not be treated as guaranteed or safety-critical.
The system does not automatically understand complex scenes.
A prototype does not replace established mobility aids or trained orientation-and-mobility techniques.
Shoe-mounted sensors have a limited field of view.

These limitations are important for an academically credible project.

37. Advanced Version — Computer Vision

A future version could add a camera.

Camera
   ↓
Edge AI / Vision Model
   ↓
Object Detection
   ↓
Person / Vehicle / Stair / Pole / Wall
   ↓
ESP32 / Edge Computer
   ↓
Decision Layer

Then the system can potentially distinguish:

Obstacle detected

from:

Person ahead
Vehicle approaching
Staircase
Pole
Wall
Door

A camera-based system would require substantially more compute than a basic ESP32 sensor node, so an ESP32-S3 or a separate edge-AI processor may be appropriate depending on the model.

38. Advanced AI Architecture

A sophisticated version could use:

                Sensor Data
                    │
       ┌────────────┼────────────┐
       ↓            ↓            ↓
   Distance      Motion       Vision
    Sensor       Sensor       Camera
       │            │            │
       └────────────┼────────────┘
                    ↓
              Sensor Fusion
                    ↓
             AI Perception
                    ↓
             Risk Prediction
                    ↓
              Agent Planner
                    ↓
          ┌─────────┴─────────┐
          ↓                   ↓
     Local Warning       Cloud Alert
          │                   │
          ↓                   ↓
      Vibration            Telegram

39. Agentic IoT Concept

Your project can be described as an agentic IoT system if the automation layer performs multiple autonomous steps rather than simply forwarding data.

For example:

1. Receive sensor event
       ↓
2. Validate measurement
       ↓
3. Compare with previous measurements
       ↓
4. Determine risk
       ↓
5. Ask AI agent to interpret event
       ↓
6. Decide whether notification is necessary
       ↓
7. Generate accessible message
       ↓
8. Send Telegram voice alert
       ↓
9. Store event
       ↓
10. Update dashboard

The AI agent therefore becomes part of a larger decision/automation pipeline rather than merely being a chatbot.

40. Complete Project Flow chart

                     START
                       │
                       ↓
               Initialize ESP32
                       │
                       ↓
                Initialize Sensors
                       │
                       ↓
                  Connect Wi-Fi
                       │
                       ↓
              Read Sensor Values
                       │
                       ↓
              Filter Sensor Data
                       │
                       ↓
            Find Minimum Distance
                       │
                       ↓
              Determine Direction
                       │
                       ↓
                Calculate Risk
                       │
             ┌─────────┴─────────┐
             │                   │
          SAFE?                 NO
             │                   │
             ↓                   ↓
       Continue scan       Local warning
                                 │
                                 ↓
                             Send n8n
                                 │
                                 ↓
                         Validate Payload
                                 │
                                 ↓
                          Store Telemetry
                                 │
                                 ↓
                              AI Agent
                                 │
                                 ↓
                         Alert Required?
                         /            \
                       NO              YES
                       │                │
                       ↓                ↓
                     END          Generate Voice
                                        │
                                        ↓
                                   Telegram Bot
                                        │
                                        ↓
                                      USER

41. Project Block Diagram for Your Report

You can use this simplified diagram in the documentation:

 ┌─────────────────────────────────────┐
 │           SMART SHOE                │
 │                                     │
 │ ┌────────┐ ┌────────┐ ┌────────┐    │
 │ │ Front  │ │ Left   │ │ Right  │    │
 │ │Sensor  │ │Sensor  │ │Sensor  │    │
 │ └───┬────┘ └───┬────┘ └───┬────┘    │
 │     └───────────┼──────────┘         │
 │                 ↓                    │
 │            ┌─────────┐               │
 │            │  ESP32  │               │
 │            └────┬────┘               │
 │                 │                    │
 │       ┌─────────┴─────────┐          │
 │       ↓                   ↓          │
 │  Vibration             Wi-Fi        │
 │   /Buzzer                 │           │
 └───────────────────────────┼───────────┘
                             ↓
                       ┌───────────┐
                       │    n8n    │
                       └─────┬─────┘
                             ↓
                       ┌───────────┐
                       │ AI Agent  │
                       └─────┬─────┘
                             │
             ┌───────────────┼───────────────┐
             ↓               ↓               ↓
        Telegram       Google Sheets     ThingSpeak
             │               │               │
             ↓               ↓               ↓
       Voice Alert       Data Storage     Dashboard
             │
             ↓
            USER

42. Suggested Project Modules

For your final documentation, divide the project into these modules:

Module 1 — Sensor Module

Responsible for:

Distance measurement
Obstacle detection
Sensor filtering

Module 2 — ESP32 Control Module

Responsible for:

Sensor acquisition
Local decision making
Wi-Fi communication

Module 3 — Safety Module

Responsible for:

Vibration
Buzzer
Emergency response
Offline operation

Module 4 — IoT Module

Responsible for:

HTTP
Webhook
Cloud communication

Module 5 — n8n Automation Module

Responsible for:

Workflow
Data processing
Event routing
Notification automation

Module 6 — AI Agent Module

Responsible for:

Sensor interpretation
Risk explanation
Alert generation
Event reasoning

Module 7 — Notification Module

Responsible for:

Telegram
Text-to-speech
Voice alerts

Module 8 — Database Module

Responsible for:

Google Sheets
Event history
Telemetry

Module 9 — Dashboard Module

Responsible for:

ThingSpeak
Web dashboard
Real-time status
Historical graphs

43. Database Design

A more advanced implementation could use:

Device ID
Timestamp
Front Distance
Left Distance
Right Distance
Minimum Distance
Direction
Risk
Closing Speed
Predicted Time
Battery
Alert Sent
AI Message

Example:

SHOE01
2026-09-29 21:35:20
42
160
150
42
FRONT
DANGER
28 cm/s
1.5 sec
76%
YES
Obstacle very close ahead

44. Example AI Alert Logic

IF distance > 200
    → SAFE

ELSE IF distance > 100
    → CAUTION

ELSE IF distance > 50
    → WARNING

ELSE
    → DANGER

Then:

IF risk == DANGER
    AND same_event == false

        → Generate voice alert
        → Telegram
        → Log event

For a real implementation, these thresholds should be configurable rather than hard-coded.

45. Security

Because the system communicates over the Internet, security should be included in the report.

Do not hard-code credentials in publicly shared firmware.

Use:

Wi-Fi credentials
        ↓
Secure configuration

and protect:

n8n webhook
Telegram bot token
Google credentials
ThingSpeak API keys
AI API credentials

Also consider:

HTTPS
Authentication
Secret management
Rate limiting
Input validation

46. Project Folder Structure

A clean implementation could look like:

AI-Smart-Shoe/
│
├── esp32/
│   ├── smart_shoe.ino
│   ├── sensors.h
│   ├── sensors.cpp
│   └── config.h
│
├── n8n/
│   ├── workflow.json
│   └── ai-agent-prompt.txt
│
├── telegram/
│   └── bot-config.md
│
├── dashboard/
│   ├── index.html
│   ├── style.css
│   └── app.js
│
├── documentation/
│   ├── project-report.md
│   ├── architecture.md
│   └── testing.md
│
└── README.md

47. Final Demonstration Sequence

For a college/project demonstration, demonstrate it in this order:

STEP 1
Power ON smart shoe

        ↓

STEP 2
ESP32 connects to Wi-Fi

        ↓

STEP 3
Dashboard shows ONLINE

        ↓

STEP 4
Place object 2 meters away

        ↓

ESP32 → SAFE

        ↓

STEP 5
Move object closer

        ↓

ESP32 → CAUTION

        ↓

STEP 6
Move object to 70 cm

        ↓

ESP32 → WARNING

        ↓

STEP 7
Move object to 30–40 cm

        ↓

ESP32 → DANGER

        ↓

Local vibration/buzzer

        ↓

n8n receives event

        ↓

AI Agent processes event

        ↓

Telegram voice notification

        ↓

Google Sheets records event

        ↓

ThingSpeak updates graph

        ↓

Web dashboard updates

48. Final System Architecture in One Sentence

Your project can be summarized as:

An ESP32-based wearable assistive system that detects nearby obstacles using directional distance sensors, performs immediate local safety feedback, sends structured telemetry through Wi-Fi to an n8n automation layer, uses an AI agent for event interpretation and alert generation, delivers voice notifications through Telegram, records events in Google Sheets, and visualizes IoT telemetry through ThingSpeak and a web dashboard.

49. Recommended Final-Year Project Chapter Structure

For a full academic report, use:

CHAPTER 1 — INTRODUCTION
1.1 Background
1.2 Problem Statement
1.3 Motivation
1.4 Objectives
1.5 Scope
1.6 Proposed Solution

CHAPTER 2 — LITERATURE / TECHNOLOGY REVIEW
2.1 Assistive Technology
2.2 Smart Wearables
2.3 ESP32
2.4 Distance Sensors
2.5 IoT
2.6 n8n Automation
2.7 AI Agents
2.8 Telegram
2.9 Cloud Dashboards

CHAPTER 3 — SYSTEM ANALYSIS
3.1 Existing System
3.2 Existing-System Limitations
3.3 Proposed System
3.4 Functional Requirements
3.5 Non-functional Requirements

CHAPTER 4 — SYSTEM DESIGN
4.1 Architecture
4.2 Block Diagram
4.3 Circuit Diagram
4.4 Data Flow Diagram
4.5 Flowchart
4.6 Database Design
4.7 AI-Agent Architecture

CHAPTER 5 — HARDWARE IMPLEMENTATION
5.1 ESP32
5.2 Sensors
5.3 Vibration Motors
5.4 Buzzer
5.5 Power Supply
5.6 Physical Shoe Design

CHAPTER 6 — SOFTWARE IMPLEMENTATION
6.1 Arduino IDE
6.2 ESP32 Firmware
6.3 Wi-Fi
6.4 n8n
6.5 AI Agent
6.6 Telegram
6.7 Google Sheets
6.8 ThingSpeak
6.9 Web Dashboard

CHAPTER 7 — IMPLEMENTATION
7.1 Hardware Assembly
7.2 Firmware
7.3 n8n Workflow
7.4 AI Prompt
7.5 Telegram Integration
7.6 Cloud Integration

CHAPTER 8 — TESTING
8.1 Unit Testing
8.2 Sensor Testing
8.3 Integration Testing
8.4 AI Testing
8.5 Alert Testing
8.6 Network Failure Testing
8.7 Performance Testing

CHAPTER 9 — RESULTS
9.1 Detection Results
9.2 Latency
9.3 False Alerts
9.4 Prediction Results
9.5 Battery Results
9.6 Dashboard Results

CHAPTER 10 — CONCLUSION
10.1 Conclusion
10.2 Limitations
10.3 Future Scope

REFERENCES
APPENDIX
SOURCE CODE

50. What I would build next

For the actual implementation, I would use two safety paths:

                ┌───────────────┐
                │     ESP32     │
                └───────┬───────┘
                        │
              ┌─────────┴─────────┐
              ↓                   ↓
       LOCAL SAFETY PATH       CLOUD PATH
              │                   │
              ↓                   ↓
       Vibration/Buzzer          n8n
                                  │
                                  ↓
                              AI Agent
                                  │
                    ┌─────────────┼─────────────┐
                    ↓             ↓             ↓
                Telegram       Sheets       ThingSpeak
                    │
                    ↓
               Voice Alert

That gives you a much stronger engineering project than making the ESP32 completely dependent on an AI/cloud service.

If you want to turn this into an actual working prototype, the next useful deliverable is a complete implementation package: ESP32 wiring/circuit diagram + finalized Arduino code + exact n8n node-by-node workflow/JSON + Telegram bot setup + Google Sheets setup + ThingSpeak setup + AI-agent prompt + web dashboard + testing procedure + final-year-project report format.

Summary

AI Smart Shoes for Blind People with Obstacle Prediction is an IoT-based assistive wearable system using ESP32, distance sensors, AI, n8n automation, Telegram voice alerts, Google Sheets, ThingSpeak, and a web dashboard.

Core Workflow

Distance Sensors
      ↓
     ESP32
      ↓
Local Obstacle Detection
      ↓
Vibration / Buzzer
      ↓
     Wi-Fi
      ↓
   n8n Webhook
      ↓
 Data Processing
      ↓
    AI Agent
      ↓
 ┌────┼──────────────┐
 ↓    ↓              ↓
Telegram  Google Sheets  ThingSpeak
 ↓        ↓              ↓
Voice     History        Dashboard
Alert

Main Features

Front, left and right obstacle detection
Distance measurement in centimeters
Obstacle direction identification
Risk classification: SAFE / CAUTION / WARNING / DANGER
Local vibration and buzzer alerts
Wi-Fi connectivity using ESP32
n8n automation workflow
AI-agent-based sensor interpretation
Telegram voice notifications
Google Sheets event logging
ThingSpeak IoT visualization
Web-based monitoring dashboard
Alert-spam prevention
Battery monitoring
Optional emergency button
Future computer-vision capability

Obstacle Prediction

Basic sensors provide obstacle detection and distance estimation. Prediction can be added by analyzing distance over time:

Previous Distance
       +
Current Distance
       +
Time Difference
       ↓
Closing Speed
       ↓
Estimated Time-to-Obstacle
       ↓
Risk Prediction

Important Design Principle

The shoe should not depend entirely on the Internet, n8n, or AI for immediate safety.

Sensor → ESP32 → Local Warning
              │
              └──→ Wi-Fi → n8n → AI → Telegram

Thus, even if Wi-Fi/cloud services fail, the local obstacle warning can continue.

Project Documentation Structure

The complete project can be documented through:

Introduction
Problem statement and objectives
Literature/technology review
System analysis
System architecture
Hardware design
Circuit/schematic
ESP32 firmware
n8n workflow
AI-agent design
Telegram integration
Google Sheets integration
ThingSpeak dashboard
Web dashboard
Testing
Performance evaluation
Results
Limitations
Future scope
Conclusion
Source-code appendix

In short: the project combines wearable sensing + local safety + IoT automation + AI reasoning + voice accessibility + cloud data logging into one smart-shoe platform.

Yes. This is a good structure for a complete technical/project report. Below is the expanded documentation outline, with what should be written in each chapter.

AI Smart Shoes for Blind People with Obstacle Prediction

ESP 32 + IoT + AI Agent + n8n + Telegram Voice Alerts + Google Sheets + ThingSpeak + Web Dashboard

1. Introduction

1.1 Background

Explain visual impairment, challenges in independent mobility, and how wearable technology and IoT can assist with environmental awareness.

1.2 Project Overview

Describe the proposed smart shoe:

Sensors → ESP32 → Local Alert
             ↓
            Wi-Fi
             ↓
            n8n
             ↓
          AI Agent
             ↓
   Telegram Voice Alert

1.3 Motivation

Explain why a low -cost, wearable, connected obstacle-detection system is being developed.

1.4 Objectives

Detect nearby obstacles.
Determine approximate obstacle direction.
Estimate distance.
Provide immediate local feedback.
Predict approaching obstacles using distance trends.
Send remote voice alerts.
Store sensor data.
Visualize sensor information.
Automate decision-making using n8n and an AI agent.

1.5 Scope

Define what the prototype does and does not do.

2. Problem Statement and Objectives

2.1 Problem Statement

Conventional mobility assistance may not provide electronic environmental information or remote event logging. The proposed system attempts to provide an additional layer of obstacle awareness using wearable sensors and accessible audio/tactile feedback.

2.2 Proposed Solution

The system combines:

ESP32
+
Distance Sensors
+
Vibration/Buzzer
+
Wi-Fi
+
n8n
+
AI Agent
+
Telegram
+
Google Sheets
+
ThingSpeak
+
Web Dashboard

2.3 Functional Requirements

The system should:

Read sensors.
Calculate distance.
Identify direction.
Classify risk.
Activate local warnings.
Send telemetry.
Process events through n8n.
Generate appropriate alerts.
Store historical data.
Display system status.

3. Literature / Technology Review

Discuss existing technologies and explain the technology selected for this project.

3.1 Assistive Technology

3.2 Electronic Travel Aids

3.3 Smart Wearables

3.4 Ultrasonic/ToF Sensors

3.5 ESP32

3.6 Internet of Things

3.7 AI and Machine Learning

3.8 Agentic Automation

3.9 n8n

3.10 Telegram Bot and Voice Notifications

3.11 Google Sheets

3.12 ThingSpeak

3.13 Web Technologies

A comparison table can then be included:

Technology	Role
ESP32	Edge controller
Ultrasonic/ToF	Distance sensing
Vibration motor	Tactile warning
Buzzer	Local emergency warning
Wi-Fi	Internet communication
n8n	Workflow automation
AI Agent	Event interpretation
Telegram	Voice/text notification
Google Sheets	Historical storage
ThingSpeak	IoT visualization
HTML/CSS/JS	Web dashboard

4. System Analysis

4.1 Existing System

Describe traditional approaches and existing electronic obstacle-detection concepts.

4.2 Limitations

Possible limitations include:

Limited directional awareness.
Lack of cloud connectivity.
Lack of historical data.
No automated notifications.
Limited personalization.
No event-processing layer.

4.3 Proposed System

               SMART SHOE
                   │
       ┌───────────┴───────────┐
       ↓                       ↓
   Sensors                 ESP32
                               │
                  ┌────────────┴────────────┐
                  ↓                         ↓
            Local Safety                  Wi-Fi
                  │                         │
                  ↓                         ↓
          Vibration/Buzzer                n8n
                                            │
                                            ↓
                                         AI Agent
                                            │
                          ┌─────────────────┼──────────────┐
                          ↓                 ↓              ↓
                       Telegram          Sheets       ThingSpeak

5. System Architecture

5.1 High-Level Architecture

┌───────────────────────────────────┐
│             SMART SHOE            │
│                                   │
│ Front Sensor ─┐                   │
│ Left Sensor ──┼→ ESP32            │
│ Right Sensor ─┘                   │
│                                   │
│ Vibration ← ESP32 → Buzzer        │
└─────────────────┬─────────────────┘
                  │
                 Wi-Fi
                  │
                  ↓
            ┌───────────┐
            │    n8n    │
            └─────┬─────┘
                  ↓
             ┌─────────┐
             │ AI Agent│
             └────┬────┘
                  │
       ┌──────────┼───────────┐
       ↓          ↓           ↓
   Telegram    Sheets     ThingSpeak
       │
       ↓
   User Voice

5.2 Data Flow

Sensor Measurement
       ↓
Data Filtering
       ↓
Distance Calculation
       ↓
Direction Detection
       ↓
Risk Classification
       ↓
n8n
       ↓
AI Interpretation
       ↓
Alert Decision
       ↓
Notification + Logging

6. Hardware Design

6.1 ESP 32

Explain:

Processor
GPIO
ADC
Wi-Fi
Power requirements
Programming interface

6.2 Distance Sensors

Use three sensors:

             FRONT
               ↓
          [Sensor F]

 [Sensor L]  SHOE  [Sensor R]

6.3 Vibration Motors

Used for directional tactile feedback.

LEFT obstacle  → Left vibration
RIGHT obstacle → Right vibration
FRONT obstacle → Both/central warning

6.4 Buzzer

Used for high-priority local warnings.

6.5 Battery

Explain battery, charging, protection and voltage regulation.

6.6 Emergency Button

Optional button for emergency events.

7. Circuit / Schematic

Include a proper circuit diagram showing:

ESP32
 │
 ├── Front Sensor
 ├── Left Sensor
 ├── Right Sensor
 ├── Left Vibration Motor
 ├── Right Vibration Motor
 ├── Buzzer
 ├── Status LED
 └── Emergency Button

Example GPIO table

Component	ESP32
Front Trigger	GPIO 5
Front Echo	GPIO 18
Left Trigger	GPIO 19
Left Echo	GPIO 21
Right Trigger	GPIO 22
Right Echo	GPIO 23
Left Vibration	GPIO 25
Right Vibration	GPIO 26
Buzzer	GPIO 27
LED	GPIO 2
Button	GPIO 4

For HC-SR04-type sensors, explain the required Echo voltage-level conversion before connecting to ESP32 GPIO.

8. ESP32 Firmware

This chapter contains the complete Arduino code.

Firmware responsibilities

Initialize
   ↓
Connect Wi-Fi
   ↓
Read sensors
   ↓
Filter readings
   ↓
Calculate minimum distance
   ↓
Determine direction
   ↓
Determine risk
   ↓
Local warning
   ↓
Send JSON to n8n
   ↓
Repeat

Example payload:

{
  "device": "SMART_SHOE_01",
  "front": 42.5,
  "left": 160.2,
  "right": 125.4,
  "direction": "FRONT",
  "risk": "DANGER"
}

The appendix should contain the complete final firmware, rather than only fragments.

9. n8n Workflow

This is one of the main innovations of the project.

Workflow

Webhook
   ↓
Validate Input
   ↓
Normalize Data
   ↓
Calculate Risk
   ↓
Store Sensor Data
   ↓
AI Agent
   ↓
Alert Decision
   ↓
Text-to-Speech
   ↓
Telegram

Parallel branches:

                  n8n
                   │
          ┌────────┼─────────┐
          ↓        ↓         ↓
       AI Agent  Sheets   ThingSpeak
          │
          ↓
      Telegram

Explain every n8n node individually in the report.

10. AI-Agent Design

The AI agent receives structured sensor data, for example:

{
  "front": 38,
  "left": 150,
  "right": 165,
  "previous_front": 65
}

It determines:

Closest direction
       ↓
Risk
       ↓
Change over time
       ↓
Alert requirement
       ↓
Short voice message

Example output

{
  "severity": "DANGER",
  "direction": "FRONT",
  "alert_required": true,
  "voice_message": "Obstacle very close ahead."
}

The report should clearly distinguish sensor-based detection from genuine AI prediction.

11. Telegram Integration

Explain:

n8n
 ↓
Generate alert text
 ↓
Text-to-Speech
 ↓
Audio file
 ↓
Telegram Bot
 ↓
Smartphone
 ↓
User

Example:

"Obstacle very close on your left."

Include:

Bot creation
Authentication
Chat ID configuration
n8n Telegram node
Audio generation
Testing

12. Google Sheets Integration

Recommended columns:

Timestamp	Device	Front	Left	Right	Direction	Risk	Alert

Explain how each n8n event becomes one spreadsheet record.

This provides historical data for:

Analysis
Graphs
Testing
Event frequency
Performance evaluation

13. ThingSpeak Dashboard

Possible fields:

Field 1 → Front Distance
Field 2 → Left Distance
Field 3 → Right Distance
Field 4 → Risk
Field 5 → Closing Speed
Field 6 → Battery

Dashboard:

┌────────────────────────────┐
│     SMART SHOE IoT         │
├────────────────────────────┤
│ Front       82 cm          │
│ Left       160 cm          │
│ Right      145 cm          │
│                            │
│ Status: WARNING            │
├────────────────────────────┤
│     Distance Graph         │
└────────────────────────────┘

14. Web Dashboard

The web application displays:

Device status
Sensor distances
Current risk
Direction
Battery
Latest AI message
Alert history
Sensor graphs

Example

AI SMART SHOE
────────────────────────

🟢 DEVICE ONLINE

FRONT       LEFT       RIGHT
82 cm       160 cm     145 cm

STATUS: WARNING

DIRECTION: FRONT

AI MESSAGE:
Obstacle approaching ahead.

LATEST ALERT:
21:35:42

15. Testing

Create separate test cases.

Test	Input	Expected Result
No obstacle	>200 cm	SAFE
Front obstacle	80 cm	Warning
Left obstacle	40 cm	Left warning
Right obstacle	35 cm	Right warning
Very close	<50 cm	Danger
Wi-Fi failure	Network OFF	Local warning continues
Sensor failure	Invalid data	Sensor-error handling
Repeated obstacle	Same event	Alert suppression
Emergency button	Press	Emergency notification

16. Performance Evaluation

Measure actual prototype performance.

Detection accuracy

Accuracy =
Correct detections
────────────────── × 100
Total tests

Alert latency

Alert Latency =
Telegram arrival time
−
Sensor detection time

Prediction error

Prediction Error =
|Predicted time − Actual time|

Battery performance

Measure:

Operating time
Average current
Wi-Fi consumption
Sensor consumption

Do not put invented performance percentages in the final report; obtain them through actual testing.

17. Results

Present experimental results using:

Tables
Graphs
Screenshots
Sensor readings
Telegram alerts
Google Sheets records
ThingSpeak charts
Dashboard screenshots

Example result table:

Test	Distance	Direction	System Result	Alert
1	220 cm	None	SAFE	No
2	95 cm	Front	WARNING	Yes
3	45 cm	Left	DANGER	Yes
4	38 cm	Right	DANGER	Yes

Use your actual measured results in the final version.

18. Limitations

Document limitations honestly:

Distance sensors cannot necessarily identify object type.
Sensor accuracy varies with environment.
Sensor placement affects coverage.
Cloud functions depend on network availability.
AI interpretation is not guaranteed to be correct.
The system should not be presented as a replacement for established mobility aids.
A prototype requires extensive real-world validation before safety-critical use.

19. Future Scope

Possible future improvements:

Computer Vision

Camera
 ↓
Edge AI
 ↓
Object Detection
 ↓
Person / Vehicle / Stair / Pole / Door

GPS

Add location information for remote assistance.

IMU

Use accelerometer/gyroscope data to estimate movement.

Better Sensor Fusion

Combine:

ToF
+
Ultrasonic
+
IMU
+
Camera

Advanced Prediction

Use historical sensor sequences to estimate:

Obstacle movement
Closing speed
Time-to-obstacle
Risk trend

Mobile Application

Develop a dedicated Android/iOS interface instead of relying solely on Telegram.

20. Conclusion

The conclusion should explain that the project demonstrates a complete edge-to-cloud assistive IoT architecture:

Physical Environment
        ↓
Sensors
        ↓
ESP32 Edge Device
        ↓
Local Safety
        ↓
IoT Connectivity
        ↓
n8n Automation
        ↓
AI Agent
        ↓
Voice Notification
        ↓
Cloud Data
        ↓
Dashboard

The project combines embedded systems, IoT, automation, AI, cloud data management and accessibility into one integrated prototype.

21. Source-Code Appendix

The final report should include the complete source code organized as:

APPENDIX A
ESP32 Firmware

APPENDIX B
Sensor Library / Functions

APPENDIX C
n8n Workflow

APPENDIX D
AI Agent Prompt

APPENDIX E
Telegram Integration

APPENDIX F
Web Dashboard

APPENDIX G
Google Sheets Configuration

APPENDIX H
ThingSpeak Configuration

Final Deliverable Set

For a complete project submission, the final package should contain:

📁 AI-Smart-Shoe-Project
│
├── 📄 Full Project Report
├── 📐 Block Diagram
├── 🔌 Circuit/Schematic
├── 💻 ESP32 Source Code
├── 🔄 n8n Workflow
├── 🤖 AI Agent Prompt
├── 📱 Telegram Bot Configuration
├── 📊 Google Sheets Template
├── 📈 ThingSpeak Dashboard
├── 🌐 Web Dashboard
├── 🧪 Testing Documentation
├── 📋 Results
└── 📚 References

This structure is suitable for expanding into a full detailed project report with chapter-by-chapter explanations, diagrams, tables, code, n8n workflow configuration, and implementation instructions.

Tuesday, 29 September 2026