AI-Based Automatic Street Light Control with Traffic Prediction

AI-Based Automatic Street Light Control with Traffic Prediction Agentic IoT System using ESP32 + AI + n8n Automation + Telegram Voice Alerts + Google Sheets + ThingSpeak

1. Project Overview This project is an AI-powered smart street lighting system that automatically controls street lights based on: Traffic density Ambient light conditions Motion detection AI-based prediction Cloud analytics The system uses: Espressif Systems ESP32 microcontroller PIR motion sensors LDR light sensor AI prediction logic n8n workflow automation Telegram voice alerts Google Sheets logging ThingSpeak cloud dashboard The system reduces: Electricity wastage Manual maintenance Urban energy costs while enabling: Smart city automation Predictive street lighting Remote monitoring Voice-based AI notifications 2. Key Features Smart Features ✅ Automatic ON/OFF street lights ✅ Traffic density prediction ✅ AI-based energy optimization ✅ Cloud monitoring dashboard ✅ Telegram alerts with voice notification ✅ Google Sheets data logging ✅ ThingSpeak live analytics ✅ n8n automation workflow ✅ Real-time sensor monitoring ✅ ESP32 WiFi IoT control 3. System Architecture +----------------+ | LDR Sensor | +----------------+ | v +----------------+ | ESP32 | | AI Prediction | +----------------+ | | | | | | v v v PIR1 PIR2 Relay Module | | | v | Street Lights | v WiFi Internet | v +----------------------+ | n8n | | Automation Workflow | +----------------------+ | | | | | | v v v Telegram Google ThingSpeak Alerts Sheets Dashboard 4. Components List Component Quantity Purpose ESP32 Dev Board 1 Main controller PIR Motion Sensor 2 Vehicle detection LDR Sensor 1 Day/Night sensing Relay Module 1 Street light control LEDs / Street Lamp Model 4 Demonstration 220Ω Resistors 4 LED protection Breadboard 1 Prototyping Jumper Wires Several Connections 5V Adapter 1 Power supply WiFi Network 1 Cloud communication Telegram Bot 1 Notifications Google Sheet 1 Data storage ThingSpeak Channel 1 Dashboard 5. Circuit Schematic Diagram +------------------+ | ESP32 | | | LDR -------->| GPIO34 | PIR1 ------->| GPIO26 | PIR2 ------->| GPIO27 | Relay ------>| GPIO25 | | | +------------------+ Relay Module: COM -> AC Supply NO -> Street Light GND -> Common Ground LED Street Lights connected through relay 6. Working Principle Daytime LDR detects sunlight Street lights remain OFF Nighttime LDR senses darkness ESP32 activates monitoring mode Traffic Detection PIR sensors detect vehicle movement AI logic estimates traffic intensity AI Prediction Predicts: Peak traffic hours Energy consumption Lighting duration Automation Data sent to: Telegram Google Sheets ThingSpeak 7. Flowchart START | Initialize ESP32 | Read LDR Value | Is it Dark? / \ NO YES | | Lights Read PIR Sensors OFF | | Vehicle Detected? / \ NO YES | | Dim Lights Full Brightness | Send Data to Cloud | AI Prediction | Telegram Voice Alert | Repeat 8. ESP32 Source Code (Arduino IDE) #include #include const char* ssid = "YOUR_WIFI"; const char* password = "YOUR_PASSWORD"; #define LDR_PIN 34 #define PIR1 26 #define PIR2 27 #define RELAY 25 String webhook = "YOUR_N8N_WEBHOOK"; void setup() { Serial.begin(115200); pinMode(PIR1, INPUT); pinMode(PIR2, INPUT); pinMode(RELAY, OUTPUT); WiFi.begin(ssid, password); while(WiFi.status() != WL_CONNECTED){ delay(500); Serial.print("."); } Serial.println("WiFi Connected"); } void loop() { int ldr = analogRead(LDR_PIN); int pir1 = digitalRead(PIR1); int pir2 = digitalRead(PIR2); bool dark = ldr < 2000; bool traffic = pir1 || pir2; if(dark && traffic){ digitalWrite(RELAY, HIGH); } else{ digitalWrite(RELAY, LOW); } if(WiFi.status() == WL_CONNECTED){ HTTPClient http; http.begin(webhook); http.addHeader("Content-Type", "application/json"); String jsonData = "{"; jsonData += "\"ldr\":" + String(ldr) + ","; jsonData += "\"traffic\":" + String(traffic) + ","; jsonData += "\"light\":" + String(dark); jsonData += "}"; int response = http.POST(jsonData); Serial.println(response); http.end(); } delay(5000); } 9. AI Traffic & Power Prediction Logic Prediction Parameters The AI engine predicts: Vehicle density Energy usage Peak traffic periods Lighting duration Future electricity demand Simple AI Formula Traffic score: Traffic Score= 2 PIR1+PIR2 ​ Power consumption estimation: Power Consumption=Light_ON_Time×Wattage Prediction model: IF traffic high: Increase brightness ELSE: Dim lights Advanced AI Enhancements Future upgrades may use: TensorFlow Lite Edge AI Historical analytics Reinforcement learning 10. n8n Automation Workflow Using n8n automation platform. Workflow Steps Webhook Trigger | v Receive ESP32 JSON | +----> Google Sheets | +----> ThingSpeak Update | +----> Telegram Alert | +----> Voice Message 11. n8n Workflow JSON { "nodes": [ { "parameters": { "path": "street-light" }, "name": "Webhook", "type": "n8n-nodes-base.webhook" }, { "parameters": { "operation": "append" }, "name": "Google Sheets", "type": "n8n-nodes-base.googleSheets" }, { "parameters": { "chatId": "YOUR_CHAT_ID", "text": "Traffic detected. Street lights activated." }, "name": "Telegram", "type": "n8n-nodes-base.telegram" } ] } 12. Telegram Bot Setup Using Telegram BotFather Steps Open Telegram Search: @BotFather Create new bot: /newbot Copy Bot Token Add token into n8n Telegram node 13. Telegram Voice Notification Automation Voice Alert Example "Warning! Heavy traffic detected. Street lights switched to high brightness mode." n8n Voice Flow Webhook | Text-to-Speech API | Telegram Send Audio Recommended TTS APIs: Google Cloud Text-to-Speech ElevenLabs 14. Google Sheets Integration Using Google Sheets Logged Parameters Time LDR Traffic Light Status 10:30 PM 1800 HIGH ON Steps Create Google Sheet Enable Google Sheets API Connect credentials in n8n Append rows automatically 15. ThingSpeak Cloud Dashboard Setup Using ThingSpeak Create Channel Fields Field Description Field 1 LDR Value Field 2 Traffic Count Field 3 Light Status Dashboard Widgets Real-time graphs Traffic trends Power analytics AI prediction charts 16. AI Agentic IoT Concept This project becomes an Agentic AI IoT System because: ESP32 senses environment AI predicts conditions n8n automates decisions Telegram communicates alerts Cloud stores intelligence The system acts autonomously with minimal human intervention. 17. Future Enhancements AI Improvements TensorFlow Lite Micro Edge AI on ESP32 Camera-based traffic detection YOLO object detection Smart City Features Automatic fault detection Solar-powered operation Smart energy billing Adaptive brightness Cloud Expansion Firebase integration AWS IoT Core MQTT broker Grafana dashboards Security HTTPS encryption Secure MQTT Device authentication 18. Deployment Guide Hardware Deployment Install poles with PIR sensors Waterproof ESP32 enclosure Connect relay to street lamps Software Deployment Upload ESP32 code Configure WiFi Setup n8n server Connect Telegram API Create ThingSpeak dashboard Testing Simulate darkness Trigger PIR motion Verify cloud updates Check Telegram alerts 19. Applications Smart cities Highway lighting Parking areas Industrial zones Campus roads Smart villages 20. Advantages ✅ Energy saving ✅ Reduced maintenance ✅ AI-based automation ✅ Real-time monitoring ✅ Low operational cost ✅ Remote accessibility ✅ Scalable architecture 21. Conclusion This project demonstrates a complete AI-powered Agentic IoT Smart Street Lighting System integrating: ESP32 AI prediction n8n automation Telegram voice alerts Google Sheets ThingSpeak analytics The system intelligently manages street lights using environmental sensing and predictive analytics, making it suitable for future smart city infrastructure.

AI-Based Automatic Number Plate Recognition with Crime Database Matching

AI-Based Automatic Number Plate Recognition (ANPR) with Crime Database Matching AI-Powered ESP32 + Agentic IoT + n8n Automation + Telegram Voice Alerts + Google Sheets + ThingSpeak Dashboard

AI-Based Automatic Number Plate Recognition (ANPR) with Crime Database Matching AI-Powered ESP32 + Agentic IoT + n8n Automation + Telegram Voice Alerts + Google Sheets + ThingSpeak Dashboard 1. Full Project Description This project is an AI-powered smart surveillance and alert system designed to automatically detect vehicle number plates using computer vision, compare them against a crime/stolen vehicle database, and instantly send alerts through Telegram voice notifications, cloud dashboards, and Google Sheets logging. The system combines: ESP32-CAM for image capture AI-based OCR/ANPR for license plate extraction n8n automation workflows Telegram bot notifications ThingSpeak IoT dashboard Google Sheets cloud logging Agentic AI logic for predictive monitoring Voice notification alerts The solution can be deployed in: Smart cities Toll plazas Police checkpoints Parking systems Campus security Border surveillance Highway monitoring 2. System Architecture ESP32-CAM ↓ WiFi Upload ↓ n8n Webhook ↓ AI OCR Processing ↓ Number Plate Extraction ↓ Crime Database Matching ↓ ┌───────────────┬────────────────┬─────────────────┐ ↓ ↓ ↓ Telegram Alert Google Sheets ThingSpeak Cloud Voice Message Data Logging Live Dashboard 3. Main Features Core Features AI-Based Number Plate Recognition OCR extracts vehicle registration number Supports multiple plate formats Crime Database Matching Compares plate with: stolen vehicle list blacklist database wanted vehicles Telegram Instant Alerts Text notification Voice notification Snapshot image Google Sheets Logging Stores: Vehicle number Date/time Match status GPS location Confidence score ThingSpeak IoT Dashboard Displays: Vehicle count Crime detections Daily trends AI analytics AI Power Consumption Prediction Predicts: Battery usage Camera activity Transmission load 4. Components List Component Quantity ESP32-CAM Module 1 FTDI Programmer 1 OV2640 Camera 1 5V Power Supply 1 Breadboard 1 Jumper Wires Several MicroSD Card 1 WiFi Router 1 USB Cable 1 Buzzer (optional) 1 Relay Module (optional) 1 GPS Module NEO-6M (optional) 1 OLED Display (optional) 1 Solar Panel + Battery (optional) 1 5. Circuit Schematic Diagram ESP32-CAM Basic Wiring FTDI ESP32-CAM -------------------------- 5V → 5V GND → GND TX → U0R RX → U0T GPIO0 → GND (Programming Mode) Optional Buzzer Buzzer + → GPIO12 Buzzer - → GND 6. Flowchart START ↓ ESP32 Captures Image ↓ Send Image to n8n Webhook ↓ AI OCR Extracts Number Plate ↓ Check Crime Database ↓ Is Match Found? ┌───────────────┐ │ YES │ ↓ │ NO Send Telegram │ Voice Alert │ ↓ │ Update Sheets │ ↓ │ Update Dashboard │ ↓ │ END │ ↓ Log Normal Vehicle ↓ END 7. ESP32 Source Code (Arduino IDE) Required Libraries Install: WiFi.h HTTPClient.h esp_camera.h ESP32 Code #include "WiFi.h" #include "HTTPClient.h" #include "esp_camera.h" const char* ssid = "YOUR_WIFI"; const char* password = "YOUR_PASSWORD"; String serverName = "https://your-n8n-instance/webhook/anpr"; void startCamera(); void setup() { Serial.begin(115200); WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } Serial.println("WiFi Connected"); startCamera(); } void loop() { camera_fb_t * fb = esp_camera_fb_get(); if(!fb) { Serial.println("Camera capture failed"); return; } HTTPClient http; http.begin(serverName); http.addHeader("Content-Type", "image/jpeg"); int response = http.POST(fb->buf, fb->len); Serial.println(response); http.end(); esp_camera_fb_return(fb); delay(10000); } void startCamera() { camera_config_t config; config.ledc_channel = LEDC_CHANNEL_0; config.ledc_timer = LEDC_TIMER_0; config.pin_d0 = 5; config.pin_d1 = 18; config.pin_d2 = 19; config.pin_d3 = 21; config.pin_d4 = 36; config.pin_d5 = 39; config.pin_d6 = 34; config.pin_d7 = 35; config.pin_xclk = 0; config.pin_pclk = 22; config.pin_vsync = 25; config.pin_href = 23; config.pin_sscb_sda = 26; config.pin_sscb_scl = 27; config.pin_pwdn = 32; config.pin_reset = -1; config.xclk_freq_hz = 20000000; config.pixel_format = PIXFORMAT_JPEG; esp_camera_init(&config); } 8. n8n Workflow Overview Workflow Nodes Webhook Trigger ↓ Image OCR API ↓ Extract Plate Number ↓ IF Node (Crime Match?) ┌──────────────┬──────────────┐ ↓ YES ↓ NO Telegram Alert Store Data ↓ Google Sheets ↓ ThingSpeak Update 9. Sample n8n Workflow JSON Structure { "nodes": [ { "name": "Webhook", "type": "n8n-nodes-base.webhook" }, { "name": "OCR API", "type": "n8n-nodes-base.httpRequest" }, { "name": "Check Database", "type": "n8n-nodes-base.if" }, { "name": "Telegram", "type": "n8n-nodes-base.telegram" } ] } 10. Telegram Bot Setup Step 1: Create Bot Open Telegram and search: Telegram Use: BotFather Commands: /newbot Copy: Bot Token Step 2: Get Chat ID Send a message to your bot. Open: Telegram API GetUpdates Example: https://api.telegram.org/botTOKEN/getUpdates Find: chat.id 11. Telegram Voice Notification Automation Text-to-Speech Flow Detected Plate ↓ Generate Alert Text ↓ Google TTS API ↓ MP3 Audio File ↓ Telegram Voice Message Example Alert Warning! Blacklisted vehicle detected. Vehicle Number AP09AB1234 Location: Highway Gate 2 12. Google Sheets Integration Required Setup Open: Google Sheets Columns: Time Vehicle No Match Confidence Location Use: Google Sheets node in n8n Authentication: Google OAuth2 13. ThingSpeak Cloud Dashboard Setup Create account at: ThingSpeak Create Fields Field Purpose Field 1 Vehicle Count Field 2 Crime Matches Field 3 AI Confidence Field 4 Power Usage API Example https://api.thingspeak.com/update?api_key=XXXX&field1=20 14. AI Power Consumption Prediction Logic AI Logic Inputs Camera ON time WiFi transmission frequency CPU load Night/day mode Alert frequency Prediction Formula Power Usage = (Camera Active Time × Current Draw) + (WiFi Transmission × Power Cost) Smart Optimization AI Agent: reduces image frequency during low traffic enters deep sleep mode activates high alert mode during suspicious activity 15. AI Agentic IoT Features Agent Behavior Autonomous Decisions Detect unusual activity Increase capture frequency Trigger emergency alerts Smart Learning Identify repeated suspicious vehicles Analyze peak crime hours Optimize bandwidth usage Predictive Analytics Vehicle traffic trends Crime hotspot prediction Battery health forecasting 16. Cloud Dashboard Features Dashboard Includes Live camera activity Detected vehicles Crime alerts GPS tracking AI confidence graph Battery status Daily statistics 17. Security Features Recommended Security API Security HTTPS webhook Token authentication Device Security Secure WiFi OTA firmware update Cloud Security Encrypted database Restricted dashboard access 18. Future Enhancements AI Improvements Deep learning vehicle recognition Face recognition integration Helmet detection Speed detection Hardware Expansion Solar-powered deployment Edge TPU acceleration 4G LTE connectivity Smart City Integration Police control room integration Traffic analytics Automatic barrier control 19. Deployment Guide Step-by-Step Deployment Hardware Assemble ESP32-CAM Upload firmware Connect to WiFi Cloud Configure n8n webhook Setup OCR API Connect Telegram bot Configure Google Sheets Setup ThingSpeak dashboard Testing Capture vehicle image Verify OCR accuracy Check alert system Validate database matching 20. Recommended OCR APIs API Accuracy OpenALPR High Plate Recognizer Very High Google Vision API High EasyOCR Medium Tesseract OCR Basic 21. Suggested AI Stack Technology Purpose ESP32-CAM Edge Device n8n Automation OpenCV Image Processing OCR AI Plate Recognition Telegram Bot Alerts Google Sheets Logging ThingSpeak IoT Dashboard MQTT Communication 22. Expected Output Example Vehicle Detected Plate Number: TS09AB1234 Status: BLACKLISTED Confidence: 96% Location: Checkpost 4 Alert Sent Successfully 23. Conclusion This project demonstrates a complete AI-powered smart surveillance ecosystem combining: Embedded IoT AI-based ANPR Cloud automation Agentic intelligence Real-time voice alerts Predictive analytics It is highly scalable for: smart cities law enforcement intelligent transportation systems automated security monitoring

AI-Based Animal Intrusion Detection for Agriculture Fields

AI-Based Animal Intrusion Detection for Agriculture Fields AI-Powered Agentic IoT System using ESP32 + n8n + Telegram Voice Alerts + Google Sheets + ThingSpeak

1. Project Overview This project is an intelligent agriculture security system that detects animal intrusion in farm fields using AI-enabled IoT automation. The system uses an ESP32 microcontroller connected to motion and distance sensors. When an animal enters the protected area: ESP32 captures intrusion data Sends alerts to cloud services Triggers AI-based automation using n8n Sends Telegram notifications with voice alerts Stores logs in Google Sheets Displays live analytics on ThingSpeak dashboard Predicts future power consumption using AI logic This system helps farmers: Prevent crop damage Monitor fields remotely Receive instant warnings Analyze intrusion patterns Reduce manual surveillance 2. System Architecture ┌────────────────────┐ │ Animal Movement │ └─────────┬──────────┘ │ ┌─────────▼──────────┐ │ PIR / Ultrasonic │ │ Sensors │ └─────────┬──────────┘ │ ┌─────────▼──────────┐ │ ESP32 │ │ WiFi + AI Logic │ └─────────┬──────────┘ │ HTTP/MQTT ┌─────────────────┼─────────────────┐ │ │ │ ▼ ▼ ▼ ┌────────────┐ ┌─────────────┐ ┌──────────────┐ │ ThingSpeak │ │ n8n Server │ │ Google Sheet │ └────────────┘ └──────┬──────┘ └──────────────┘ │ ┌──────────▼───────────┐ │ Telegram Bot Alerts │ │ Voice + Text Message │ └──────────────────────┘ 3. Features Core Features Animal intrusion detection Real-time Telegram alerts AI-based intrusion classification Voice warning notifications Cloud dashboard monitoring Google Sheets logging Automated workflows using n8n AI Features Power usage prediction Intrusion frequency analysis Smart alert prioritization Future threat prediction IoT Features WiFi connectivity Cloud synchronization Remote monitoring Edge-device automation 4. Required Components List Component Quantity Purpose ESP32 Dev Board 1 Main controller PIR Motion Sensor 1 Motion detection Ultrasonic Sensor HC-SR04 1 Distance sensing Buzzer 1 Local alarm LED Indicators 2 Status display Jumper Wires Several Connections Breadboard 1 Prototyping Power Supply 5V 1 System power WiFi Network 1 Internet connectivity Telegram Bot 1 Notifications ThingSpeak Account 1 Cloud dashboard Google Account 1 Sheets integration n8n Server 1 Automation workflows 5. Circuit Schematic Diagram ESP32 PIN CONNECTIONS PIR Sensor ----------- VCC -> 3.3V GND -> GND OUT -> GPIO 13 Ultrasonic Sensor HC-SR04 ------------------------- VCC -> 5V GND -> GND TRIG -> GPIO 12 ECHO -> GPIO 14 Buzzer ------- + -> GPIO 27 - -> GND LED --- + -> GPIO 26 - -> GND 6. Working Principle PIR sensor detects motion. Ultrasonic sensor measures object distance. ESP32 validates intrusion. Data uploaded to ThingSpeak. ESP32 triggers webhook to n8n. n8n: Sends Telegram text alert Generates voice notification Stores records in Google Sheets AI logic predicts power usage trends. Dashboard visualizes all activities. 7. Flowchart START │ Initialize ESP32 │ Connect WiFi │ Read PIR Sensor │ Motion Detected? ┌─No─────────────┐ │ │ │ Wait │ │ └────Yes─────────┘ │ Measure Distance │ Animal Detected? ┌─No─────────────┐ │ │ │ Continue │ │ └────Yes─────────┘ │ Activate Buzzer │ Send Data to ThingSpeak │ Trigger n8n Webhook │ Telegram Alert + Voice │ Store Data in Sheets │ Repeat 8. ESP32 Source Code (Arduino IDE) #include #include const char* ssid = "YOUR_WIFI_NAME"; const char* password = "YOUR_WIFI_PASSWORD"; String webhookURL = "YOUR_N8N_WEBHOOK_URL"; #define PIR_PIN 13 #define TRIG_PIN 12 #define ECHO_PIN 14 #define BUZZER 27 #define LED 26 long duration; float distance; void setup() { Serial.begin(115200); pinMode(PIR_PIN, INPUT); pinMode(TRIG_PIN, OUTPUT); pinMode(ECHO_PIN, INPUT); pinMode(BUZZER, OUTPUT); pinMode(LED, OUTPUT); WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED) { delay(1000); Serial.println("Connecting..."); } Serial.println("WiFi Connected"); } float getDistance() { digitalWrite(TRIG_PIN, LOW); delayMicroseconds(2); digitalWrite(TRIG_PIN, HIGH); delayMicroseconds(10); digitalWrite(TRIG_PIN, LOW); duration = pulseIn(ECHO_PIN, HIGH); distance = duration * 0.034 / 2; return distance; } void loop() { int motion = digitalRead(PIR_PIN); if (motion == HIGH) { distance = getDistance(); if (distance < 150) { digitalWrite(BUZZER, HIGH); digitalWrite(LED, HIGH); sendAlert(distance); delay(5000); digitalWrite(BUZZER, LOW); digitalWrite(LED, LOW); } } delay(1000); } void sendAlert(float dist) { if(WiFi.status()== WL_CONNECTED){ HTTPClient http; String url = webhookURL + "?distance=" + String(dist); http.begin(url); int httpCode = http.GET(); Serial.println(httpCode); http.end(); } } 9. n8n Workflow Logic Workflow Steps Webhook Trigger │ ▼ AI Decision Node │ ▼ Telegram Message Node │ ▼ Google Sheets Node │ ▼ ThingSpeak Update Node │ ▼ Text-to-Speech Node │ ▼ Telegram Voice Send 10. Sample n8n Workflow JSON { "nodes": [ { "name": "Webhook", "type": "n8n-nodes-base.webhook", "parameters": { "path": "animal-alert" } }, { "name": "Telegram Alert", "type": "n8n-nodes-base.telegram", "parameters": { "text": "Animal detected in field!" } } ] } 11. Telegram Bot Setup Step 1: Create Bot Open Telegram and search: Telegram Then search for: BotFather Commands: /newbot Provide: Bot Name Username Copy generated API token. Step 2: Get Chat ID Send message to your bot. Open: https://api.telegram.org/botYOUR_BOT_TOKEN/getUpdates Copy: chat.id 12. Google Sheets Integration Steps Create new Google Sheet Add columns: | Timestamp | Distance | Alert Type | Power Usage | In n8n: Add Google Sheets node Authenticate Google account Select spreadsheet Append rows automatically Recommended columns: Timestamp Animal Type Distance Battery Voltage Alert Status 13. ThingSpeak Cloud Dashboard Setup Create account on: ThingSpeak Create Channel Fields Field Purpose Field 1 Distance Field 2 Motion Field 3 Battery Field 4 Intrusion Count Dashboard Widgets Live intrusion graph Daily activity chart Battery monitor AI prediction chart 14. AI Power Consumption Prediction Logic Objective Predict battery drain and optimize power usage. Inputs Sensor active time Alert frequency WiFi transmission count Buzzer usage duration Simple Prediction Formula The estimated power model: P daily ​ =P idle ​ +n(P wifi ​ +P sensor ​ +P buzzer ​ ) Where: P daily ​ = total daily consumption n = number of intrusion events AI Enhancement Use: Moving average prediction Linear regression Intrusion trend analysis Future AI models: TinyML on ESP32 Edge AI classification Animal species prediction 15. Voice Notification Automation Workflow Intrusion Detected │ ▼ n8n Receives Webhook │ ▼ Text-to-Speech API │ ▼ Generate MP3 Voice │ ▼ Send Telegram Voice Message Example Voice Message Warning! Animal detected in agricultural field sector 3. 16. AI Agentic Automation Concept The system behaves like an AI agent: AI Agent Capability Function Observe Sensor monitoring Analyze Intrusion validation Decide Threat classification Act Send alerts Learn Analyze intrusion history 17. Future Enhancements AI Improvements YOLO animal detection camera TinyML animal classification AI-based crop damage prediction Hardware Enhancements Solar-powered system GSM backup connectivity LoRa communication Cloud Enhancements Mobile app dashboard Firebase integration AWS IoT integration Security Improvements Multi-factor authentication Encrypted communication Edge anomaly detection 18. Deployment Guide Farm Installation Tips Mount sensors 2–3 feet above ground Use waterproof enclosure Install solar charging Ensure stable WiFi coverage Power Optimization Deep sleep mode on ESP32 Send alerts only on confirmed detection Reduce WiFi transmission intervals 19. Advantages Low-cost smart agriculture solution Real-time remote monitoring AI-assisted automation Easy cloud integration Scalable architecture Energy efficient 20. Applications Agricultural farms Forest boundary monitoring Smart villages Wildlife intrusion prevention Crop protection systems 21. Conclusion This AI-powered Agentic IoT system combines: ESP32 AI automation Cloud dashboards Telegram voice alerts n8n workflows Google Sheets analytics to create a complete smart agriculture protection platform capable of intelligent monitoring, automation, and predictive analytics. The project is highly scalable and can evolve into: AI wildlife monitoring Smart farm automation Precision agriculture systems Edge AI surveillance platforms

AI Smart Wheelchair with Voice and Eye Control

AI Smart Wheelchair with Voice and Eye Control AI-Powered ESP32 + Agentic IoT + n8n Automation + Telegram Voice Alerts + Google Sheets + ThingSpeak Dashboard

AI Smart Wheelchair with Voice and Eye Control AI-Powered ESP32 + Agentic IoT + n8n Automation + Telegram Voice Alerts + Google Sheets + ThingSpeak Dashboard 1. Project Overview This project is an AI-enabled Smart Wheelchair designed for elderly and disabled individuals. The wheelchair can be controlled using: 👁️ Eye movement tracking 🎙️ Voice commands 📱 Mobile IoT dashboard 🤖 AI-based automation The system uses an ESP32 microcontroller integrated with: Sensors Motor drivers Cloud platforms AI analytics n8n workflow automation Telegram voice alert system The wheelchair also sends: Battery health alerts Emergency notifications Usage analytics Power consumption predictions 2. Key Features Smart Control Features Voice-controlled navigation Eye-controlled movement Obstacle detection Automatic braking AI-assisted movement prediction IoT Features Real-time monitoring Cloud dashboard Telegram alerts Google Sheets logging Remote tracking AI Features Battery prediction Usage pattern learning Intelligent alert generation Power optimization 3. System Architecture +----------------------+ | User Voice | +----------+-----------+ | v Voice Recognition | v +-------------+ +-------------+ +--------------+ | Eye Sensor | --> | ESP32 | --> | Motor Driver | +-------------+ +-------------+ +--------------+ | ---------------------------------------- | | | v v v ThingSpeak Google Sheets Telegram Bot | | | -------------------------------------- | v n8n AI Automation 4. Components List Component Quantity Purpose ESP32 Dev Board 1 Main controller L298N Motor Driver 1 Motor control DC Geared Motors 2 Wheelchair movement IR Eye Blink Sensor 1 Eye movement detection Ultrasonic Sensor HC-SR04 2 Obstacle detection Microphone Module 1 Voice command input Battery Pack 12V 1 Power supply Buck Converter 1 Voltage regulation Relay Module 1 Safety shutdown Buzzer 1 Alert system WiFi Router/Hotspot 1 Internet connectivity Jumper Wires Multiple Connections Wheelchair Chassis 1 Base frame 5. Circuit Schematic Diagram +----------------+ | ESP32 | | | | GPIO 18 -----> Motor IN1 | GPIO 19 -----> Motor IN2 | GPIO 21 -----> Motor IN3 | GPIO 22 -----> Motor IN4 | GPIO 5 <---- Eye Sensor | GPIO 13 <---- Echo | GPIO 12 ----> Trigger | GPIO 34 <---- Mic Module | GPIO 25 ----> Buzzer +----------------+ | v WiFi Connection | ------------------------ | | | v v v Telegram n8n ThingSpeak 6. Flowchart START | v Initialize ESP32 | v Connect to WiFi | v Read Sensors Data | ------------------- | | | v v v Voice Eye Obstacle Command Movement Detection | | | ---------- | | | v | Control Motors <--- | v Upload Data to Cloud | v Trigger n8n Workflow | v Send Telegram Alerts | v LOOP 7. ESP32 Source Code (Arduino IDE) #include #include const char* ssid = "YOUR_WIFI_NAME"; const char* password = "YOUR_WIFI_PASSWORD"; String apiKey = "THINGSPEAK_API_KEY"; #define IN1 18 #define IN2 19 #define IN3 21 #define IN4 22 #define trigPin 12 #define echoPin 13 #define eyeSensor 5 #define buzzer 25 long duration; int distance; void setup() { Serial.begin(115200); pinMode(IN1, OUTPUT); pinMode(IN2, OUTPUT); pinMode(IN3, OUTPUT); pinMode(IN4, OUTPUT); pinMode(trigPin, OUTPUT); pinMode(echoPin, INPUT); pinMode(eyeSensor, INPUT); pinMode(buzzer, OUTPUT); WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } Serial.println("WiFi Connected"); } void loop() { // Ultrasonic Distance digitalWrite(trigPin, LOW); delayMicroseconds(2); digitalWrite(trigPin, HIGH); delayMicroseconds(10); digitalWrite(trigPin, LOW); duration = pulseIn(echoPin, HIGH); distance = duration * 0.034 / 2; // Eye Sensor int eyeState = digitalRead(eyeSensor); if(distance < 20) { stopWheelchair(); digitalWrite(buzzer, HIGH); } else { digitalWrite(buzzer, LOW); if(eyeState == HIGH) { moveForward(); } else { stopWheelchair(); } } uploadThingSpeak(distance, eyeState); delay(3000); } void moveForward() { digitalWrite(IN1, HIGH); digitalWrite(IN2, LOW); digitalWrite(IN3, HIGH); digitalWrite(IN4, LOW); } void stopWheelchair() { digitalWrite(IN1, LOW); digitalWrite(IN2, LOW); digitalWrite(IN3, LOW); digitalWrite(IN4, LOW); } void uploadThingSpeak(int distance, int eye) { if(WiFi.status()== WL_CONNECTED){ HTTPClient http; String url = "http://api.thingspeak.com/update?api_key=" + apiKey + "&field1=" + String(distance) + "&field2=" + String(eye); http.begin(url); int httpCode = http.GET(); Serial.println(httpCode); http.end(); } } 8. n8n Workflow Logic Workflow Functions Receive ESP32 webhook data Analyze sensor values Generate AI decisions Send Telegram alerts Store logs in Google Sheets Trigger voice notifications n8n Workflow Steps Webhook Trigger | v HTTP Request (ESP32 Data) | v IF Node (distance < 20?) | YES/NO | v Telegram Alert | v Google Sheets Logging | v AI Processing Node | v Voice Notification 9. Example n8n Workflow JSON { "nodes": [ { "name": "Webhook", "type": "n8n-nodes-base.webhook", "parameters": { "path": "wheelchair-data" } }, { "name": "Telegram", "type": "n8n-nodes-base.telegram", "parameters": { "chatId": "YOUR_CHAT_ID", "text": "Obstacle detected!" } } ] } 10. Telegram Bot Setup Step 1: Create Bot Open Telegram and search: Telegram Then message: @BotFather Commands: /newbot BotFather provides: Bot Token API access Step 2: Get Chat ID Send message to your bot. Open: https://api.telegram.org/bot/getUpdates Find: "chat":{"id":123456789} Step 3: Send Notifications Example API: https://api.telegram.org/bot/sendMessage?chat_id=&text=ObstacleDetected 11. Google Sheets Integration Create Sheet Columns Time Distance Eye State Battery Status n8n Google Sheets Node Connect Google account Select Spreadsheet Append Rows automatically Data stored: Sensor logs Alerts Battery prediction User activity 12. ThingSpeak Dashboard Setup Create Channel Use: ThingSpeak Create Fields: Distance Eye Sensor Battery Temperature Dashboard Widgets Live graph Gauge meter Alert chart Battery analytics 13. AI Power Consumption Prediction Logic Goal Predict battery drain and optimize wheelchair runtime. Inputs Motor usage time Obstacle frequency Distance traveled Battery voltage Speed AI Formula Battery Consumption: P=V×I Remaining Battery Estimate: Battery Remaining=Battery total ​ −Consumption Prediction Logic IF battery < 20% Send Alert Reduce Motor Speed Enable Power Saving 14. Voice Notification Automation Telegram Voice Alerts n8n converts text to speech: “Obstacle detected” “Battery low” “Emergency assistance required” Workflow ESP32 Event | v n8n Webhook | v AI Decision | v Text-to-Speech | v Telegram Voice Message 15. AI Agentic Features Intelligent Behaviors Learns user movement patterns Predicts battery usage Detects abnormal activity Sends autonomous alerts Example AI Actions Situation AI Response Low battery Reduce speed Obstacle nearby Stop wheelchair Emergency detected Notify caregiver Long inactivity Trigger wellness alert 16. Future Enhancements Advanced AI Features Face recognition Emotion detection Health monitoring Fall detection IoT Upgrades GPS tracking Mobile app Cloud AI dashboard Remote driving Hardware Upgrades Li-ion smart BMS Brushless motors Solar charging Autonomous navigation 17. Deployment Guide Hardware Assembly Mount motors Install ESP32 Connect sensors Attach battery Configure wiring Software Installation Arduino IDE Install: ESP32 board package WiFi library HTTPClient library Cloud Setup Configure ThingSpeak API Configure n8n workflow Setup Telegram bot Connect Google Sheets 18. Applications Disabled assistance Elderly mobility Smart hospitals Rehabilitation centers AI healthcare systems 19. Advantages Hands-free control Low-cost AI system Real-time monitoring Emergency automation Cloud analytics 20. Conclusion This project combines: ESP32 IoT AI automation Voice control Eye tracking Cloud analytics Agentic workflows to create a modern AI Smart Wheelchair System capable of improving mobility, safety, and independence for users with physical disabilities.

AI Smart Traffic Signal Control Using Real-Time Vehicle Density Analysis

AI Smart Traffic Signal Control Using Real-Time Vehicle Density Analysis Agentic IoT System using ESP32 + AI + n8n + Telegram Voice Alerts + Google Sheets + ThingSpeak

AI Smart Traffic Signal Control Using Real-Time Vehicle Density Analysis Agentic IoT System using ESP32 + AI + n8n + Telegram Voice Alerts + Google Sheets + ThingSpeak 1. Project Overview This project is an AI-powered smart traffic management system that dynamically controls traffic lights based on real-time vehicle density using an ESP32 microcontroller, IoT cloud services, and automation workflows. The system: Detects vehicle density using sensors/camera logic Uses AI logic to optimize signal timing Sends data to cloud dashboards Stores traffic logs in Google Sheets Generates Telegram alerts and voice notifications Uses n8n workflows for automation Predicts congestion and power consumption trends 2. Objectives Reduce traffic congestion Minimize waiting time Optimize signal timing automatically Enable remote monitoring Provide real-time traffic analytics Generate AI-based predictions Enable smart city integration 3. System Architecture Vehicle Sensors / Camera ↓ ESP32 ↓ WiFi / Internet Connection ↓ ┌────────────────────────────┐ │ Cloud Services │ │----------------------------│ │ ThingSpeak Dashboard │ │ Google Sheets Logging │ │ Telegram Alerts │ │ n8n Automation │ └────────────────────────────┘ ↓ AI Decision Engine ↓ Smart Traffic Signal Control 4. Hardware Components List Component Quantity Purpose ESP32 Dev Board 1 Main controller Ultrasonic Sensors HC-SR04 4 Vehicle density detection Traffic LEDs (Red/Yellow/Green) 12 Traffic lights Resistors 220Ω 12 LED protection Breadboard 1 Prototyping Jumper Wires Multiple Connections Buzzer 1 Alert indication 5V Power Supply 1 System power WiFi Router 1 Internet connectivity Optional Camera Module 1 AI vision enhancement 5. Working Principle Each road lane contains an ultrasonic sensor. The ESP32: Measures vehicle queue length Calculates density score Assigns green signal duration dynamically Uploads data to cloud Triggers alerts during congestion AI Logic High density → longer green signal Low density → shorter green signal Emergency override supported Predictive congestion analysis possible 6. Traffic Density Logic Example density ranges: Distance Measured Traffic Density > 80 cm Low 40–80 cm Medium < 40 cm High Signal timing: Density Green Time Low 10 sec Medium 20 sec High 35 sec 7. Circuit Schematic Diagram +------------------+ | ESP32 | | | HC-SR04_1 --> GPIO 4,5 HC-SR04_2 --> GPIO 18,19 HC-SR04_3 --> GPIO 21,22 HC-SR04_4 --> GPIO 23,25 RED LEDs --> GPIO 12,13,14,15 YELLOW LEDs --> GPIO 26,27,32,33 GREEN LEDs --> GPIO 2,16,17,18 BUZZER --> GPIO 5 WiFi --> Cloud Services +------------------+ 8. Flowchart START ↓ Initialize ESP32 ↓ Connect WiFi ↓ Read Sensor Data ↓ Calculate Vehicle Density ↓ AI Decision Engine ↓ Set Traffic Signal Timing ↓ Upload Data to ThingSpeak ↓ Store Data in Google Sheets ↓ Trigger Telegram Alerts ↓ Repeat Loop 9. ESP32 Source Code (Arduino IDE) #include #include const char* ssid = "YOUR_WIFI_NAME"; const char* password = "YOUR_WIFI_PASSWORD"; String apiKey = "THINGSPEAK_API_KEY"; #define RED1 12 #define YELLOW1 26 #define GREEN1 2 #define TRIG1 4 #define ECHO1 5 long duration; int distance; WiFiClient client; void setup() { Serial.begin(115200); pinMode(TRIG1, OUTPUT); pinMode(ECHO1, INPUT); pinMode(RED1, OUTPUT); pinMode(YELLOW1, OUTPUT); pinMode(GREEN1, OUTPUT); WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED) { delay(1000); Serial.println("Connecting..."); } Serial.println("WiFi Connected"); } int getDistance() { digitalWrite(TRIG1, LOW); delayMicroseconds(2); digitalWrite(TRIG1, HIGH); delayMicroseconds(10); digitalWrite(TRIG1, LOW); duration = pulseIn(ECHO1, HIGH); distance = duration * 0.034 / 2; return distance; } void loop() { int density = getDistance(); int greenTime = 10; if (density < 40) { greenTime = 35; } else if (density < 80) { greenTime = 20; } digitalWrite(GREEN1, HIGH); delay(greenTime * 1000); digitalWrite(GREEN1, LOW); digitalWrite(YELLOW1, HIGH); delay(3000); digitalWrite(YELLOW1, LOW); digitalWrite(RED1, HIGH); delay(5000); sendToThingSpeak(density, greenTime); } void sendToThingSpeak(int density, int greenTime) { if(WiFi.status()== WL_CONNECTED){ HTTPClient http; String url = "http://api.thingspeak.com/update?api_key=" + apiKey + "&field1=" + String(density) + "&field2=" + String(greenTime); http.begin(url); int httpCode = http.GET(); Serial.println(httpCode); http.end(); } } 10. ThingSpeak Cloud Dashboard Setup Using ThingSpeak Steps Create account Create new channel Add fields: Vehicle Density Green Signal Time Congestion Score Copy Write API Key Add API key into ESP32 code Dashboard features: Real-time graphs Traffic analytics Historical trends AI prediction visualization 11. Google Sheets Integration Using: Google Apps Script Webhook API n8n automation Data Stored Time Density Green Time Alert Google Apps Script function doPost(e) { var sheet = SpreadsheetApp.getActiveSheet(); var data = JSON.parse(e.postData.contents); sheet.appendRow([ new Date(), data.density, data.greenTime, data.alert ]); return ContentService .createTextOutput("Success"); } Deploy as: Web App Access: Anyone 12. Telegram Bot Setup Using Telegram BotFather Steps Open Telegram Search “BotFather” Create bot using: /newbot Copy bot token Get Chat ID Use HTTP API in n8n 13. Telegram Voice Notification Alerts Example alert: ⚠ Heavy Traffic Detected at Junction 2 Green Signal Extended to 35 Seconds Voice generation options: Google TTS ElevenLabs gTTS Python API 14. n8n Automation Workflow Using n8n Automation Platform Workflow Functions Receive ESP32 webhook data Analyze congestion Store records Trigger Telegram notifications Generate voice alerts Predict traffic trends n8n Workflow Structure Webhook Trigger ↓ Data Parser ↓ IF Density > Threshold ↓ ┌──────────────┬───────────────┐ ↓ ↓ Telegram Msg Google Sheets ↓ Voice Alert ↓ ThingSpeak Update 15. Sample n8n Workflow JSON { "nodes": [ { "name": "Webhook", "type": "n8n-nodes-base.webhook", "position": [250, 300] }, { "name": "IF Traffic High", "type": "n8n-nodes-base.if", "position": [500, 300] }, { "name": "Telegram Alert", "type": "n8n-nodes-base.telegram", "position": [750, 200] }, { "name": "Google Sheets", "type": "n8n-nodes-base.googleSheets", "position": [750, 400] } ] } 16. AI Power Consumption Prediction Logic The AI module predicts: Power usage Peak traffic hours Congestion patterns Energy optimization Simple Prediction Formula P=V×I Where: P = Power V = Voltage I = Current AI Prediction Parameters Parameter Usage Vehicle Count Congestion estimate Signal Duration Energy usage Peak Time Traffic prediction Historical Data ML training 17. AI Enhancement Possibilities Machine Learning Features Vehicle classification Emergency vehicle detection Accident detection Adaptive traffic prediction Smart rerouting Possible AI frameworks: TensorFlow Lite Edge Impulse OpenCV YOLO object detection 18. Cloud Dashboard Features Dashboard Includes Live traffic density Signal status Historical analytics Congestion heatmaps AI prediction charts Alert logs 19. Future Enhancements Advanced Features Smart City Integration Connect multiple junctions Centralized monitoring AI Camera Vision Vehicle counting Lane analysis Emergency Vehicle Priority Ambulance detection Automatic signal clearance Solar Power System Renewable energy support GSM Backup SMS alerts during internet failure 20. Deployment Guide Step-by-Step Deployment Hardware Assemble circuit Connect sensors Verify LED operation Software Install Arduino IDE Install ESP32 board package Upload source code Cloud Configure ThingSpeak Configure Google Sheets Configure Telegram Bot Import n8n workflow Testing Simulate traffic Verify signal timing Check dashboard updates Confirm Telegram alerts 21. Expected Results Scenario Output Low Traffic Short signal duration Heavy Traffic Extended green signal Congestion Telegram alert Peak Hours AI prediction generated 22. Advantages Reduces traffic congestion Saves fuel Low-cost implementation Real-time monitoring Scalable architecture Supports smart cities 23. Applications Smart city infrastructure Highways Urban intersections Industrial traffic control Campus traffic systems 24. Technologies Used Technology Purpose ESP32 IoT controller n8n Workflow automation Telegram Bot Notifications ThingSpeak Cloud analytics Google Sheets Data logging AI/ML Prediction logic 25. Conclusion This project demonstrates a modern AI-powered intelligent traffic management system using ESP32, IoT cloud platforms, and automation tools. By combining: Real-time vehicle density analysis AI-based adaptive signal control Cloud dashboards Telegram voice notifications Automation workflows …the system provides a scalable foundation for future smart-city traffic infrastructure.

AI Smart Surveillance Robot with Face and Motion Detection

AI Smart Surveillance Robot with Face & Motion Detection ESP32 + AI Agentic IoT + n8n Automation + Telegram Voice Alerts + Google Sheets + ThingSpeak Cloud Dashboard

AI Smart Surveillance Robot with Face & Motion Detection ESP32 + AI Agentic IoT + n8n Automation + Telegram Voice Alerts + Google Sheets + ThingSpeak Cloud Dashboard 1. Project Overview This project is an AI-powered smart surveillance robot using an ESP32-CAM and IoT automation. The robot can: Detect motion Perform face detection Capture images Send Telegram alerts Send voice notifications Store logs in Google Sheets Upload sensor values to ThingSpeak Trigger AI-based automation via n8n Predict power usage using simple AI logic Provide remote cloud monitoring 2. System Architecture ┌─────────────────┐ │ ESP32-CAM │ │ Motion + Camera │ └────────┬────────┘ │ WiFi ▼ ┌─────────────────┐ │ n8n │ │ Automation Hub │ └──────┬──────────┘ │ ┌────────────────┼────────────────┐ ▼ ▼ ▼ Telegram Bot Google Sheets ThingSpeak Voice Alerts Data Logging Cloud Dashboard │ ▼ AI Notification & Automation Agent 3. Features Smart Surveillance Motion detection using PIR sensor Face detection using ESP32-CAM AI library Intruder image capture AI Automation Event classification Intelligent alert triggering AI power consumption estimation Cloud Features Real-time dashboard Cloud logging Remote monitoring Notifications Telegram instant alerts Telegram voice alerts Sensor event messages 4. Required Components Component Quantity ESP32-CAM Module 1 FTDI Programmer 1 PIR Motion Sensor HC-SR501 1 Servo Motors (Robot movement) 2 L298N Motor Driver 1 DC Gear Motors 2 Ultrasonic Sensor HC-SR04 1 Buzzer 1 Li-ion Battery Pack 1 Voltage Regulator 5V 1 Jumper Wires Many Robot Chassis 1 Breadboard 1 Optional: IR LEDs for night vision Solar charging module Relay module 5. Circuit Connections ESP32-CAM Pin Mapping Device ESP32 Pin PIR OUT GPIO 13 Buzzer GPIO 12 Servo Left GPIO 14 Servo Right GPIO 15 Ultrasonic TRIG GPIO 2 Ultrasonic ECHO GPIO 4 Motor Driver IN1 GPIO 16 Motor Driver IN2 GPIO 17 6. Circuit Schematic (Text Representation) +-------------------+ | ESP32-CAM | | | PIR ---->| GPIO13 | Buzzer ->| GPIO12 | Servo1 ->| GPIO14 | Servo2 ->| GPIO15 | TRIG --->| GPIO2 | ECHO --->| GPIO4 | +-------------------+ │ WiFi ▼ Internet / Router ▼ n8n Automation Server │ ┌──────────┼───────────┐ ▼ ▼ ▼ Telegram GoogleSheet ThingSpeak 7. Working Principle PIR sensor detects movement ESP32 activates camera Face detection algorithm runs Snapshot captured Data sent to n8n webhook n8n: Sends Telegram message Sends voice alert Updates Google Sheets Uploads ThingSpeak data AI logic predicts battery consumption 8. Flowchart START │ ▼ Initialize ESP32 │ ▼ Connect WiFi │ ▼ Detect Motion? ┌────┴─────┐ │ │ NO YES │ │ ▼ ▼ Continue Capture Image Monitoring │ ▼ Face Detection │ ▼ Send to n8n │ ┌───────────┼───────────┐ ▼ ▼ ▼ Telegram Google ThingSpeak Alerts Sheets Upload │ ▼ Voice Notification │ ▼ END 9. ESP32 Source Code (Arduino) #include "WiFi.h" #include "HTTPClient.h" #include "esp_camera.h" const char* ssid = "YOUR_WIFI"; const char* password = "YOUR_PASSWORD"; String webhook = "https://YOUR_N8N/webhook/surveillance"; #define PIR_PIN 13 #define BUZZER 12 void setup() { Serial.begin(115200); pinMode(PIR_PIN, INPUT); pinMode(BUZZER, OUTPUT); WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED) { delay(1000); Serial.println("Connecting..."); } Serial.println("WiFi Connected"); } void loop() { int motion = digitalRead(PIR_PIN); if (motion == HIGH) { digitalWrite(BUZZER, HIGH); HTTPClient http; http.begin(webhook); http.addHeader("Content-Type", "application/json"); String payload = "{\"motion\":\"detected\"}"; int response = http.POST(payload); Serial.println(response); http.end(); delay(5000); digitalWrite(BUZZER, LOW); } delay(500); } 10. ESP32-CAM Face Detection Use the built-in ESP-WHO library. Enable: #define CONFIG_ESP_FACE_DETECT_ENABLED Functions: Face detection Face recognition Object tracking 11. n8n Workflow Overview Workflow Nodes Webhook Trigger IF Motion Detected Telegram Send Message Telegram Voice Notification Google Sheets Append Row ThingSpeak HTTP Request AI Decision Node 12. Example n8n Workflow JSON { "nodes": [ { "name": "Webhook", "type": "n8n-nodes-base.webhook" }, { "name": "Telegram", "type": "n8n-nodes-base.telegram" }, { "name": "Google Sheets", "type": "n8n-nodes-base.googleSheets" } ] } 13. Telegram Bot Setup Step 1 — Create Bot Open Telegram and search: BotFather Official Telegram Bot Commands: /newbot Save: Bot Token Bot Username Step 2 — Get Chat ID Open: Get Telegram Chat ID Bot Step 3 — Test Message API https://api.telegram.org/botBOT_TOKEN/sendMessage?chat_id=CHAT_ID&text=MotionDetected 14. Telegram Voice Notification Use Telegram sendVoice. Generate voice using: Google TTS gTTS Python library ElevenLabs API Example n8n flow: Webhook → AI Text → TTS → Telegram Voice Example alert: "Warning. Motion detected near the entrance." 15. Google Sheets Integration Create Sheet Columns: Timestamp Motion Face Battery Distance Google Cloud Setup Create Google Cloud Project Enable Google Sheets API Create Service Account Download credentials JSON Connect credentials in n8n Useful resources: Google Sheets API Documentation n8n Official Website 16. ThingSpeak Dashboard Setup Create account: ThingSpeak Official Website Fields Field Data Field1 Motion Field2 Battery Field3 Distance Field4 AI Risk Score ESP32 Upload API String url = "http://api.thingspeak.com/update?api_key=APIKEY&field1=1"; 17. AI Power Consumption Prediction Logic Inputs Camera active time WiFi usage Motor activity Alert frequency Formula P=V×I Battery prediction: E=P×t Example AI Logic if motion_events > 50: power_mode = "HIGH" if battery < 20: disable_camera() 18. AI Agentic Automation The AI agent can: Analyze motion frequency Detect suspicious patterns Reduce false alarms Predict battery depletion Trigger emergency alerts 19. Voice Automation Pipeline ESP32 Event │ ▼ n8n Webhook │ ▼ AI Message Generator │ ▼ Text-to-Speech │ ▼ Telegram Voice Alert 20. Security Features Secure HTTPS webhook Telegram authentication API key encryption Cloud access control 21. Future Enhancements AI Upgrades Face recognition database Intruder classification Weapon detection Edge AI object tracking IoT Upgrades GPS tracking Live video streaming MQTT communication Home Assistant integration Robotics Autonomous navigation SLAM mapping Obstacle avoidance AI 22. Deployment Guide Local Deployment Home security robot Office surveillance Warehouse monitoring Cloud Deployment VPS-hosted n8n server Remote dashboard access Multi-device monitoring Recommended platforms: n8n Cloud Google Cloud Platform AWS IoT Core 23. Suggested Folder Structure AI_Surveillance_Robot/ │ ├── ESP32_Code/ ├── n8n_Workflow/ ├── Telegram_Bot/ ├── GoogleSheets/ ├── ThingSpeak/ ├── AI_Logic/ ├── Documentation/ └── Circuit_Diagram/ 24. Estimated Cost Total:₹8000–₹8500 Approx 25. Final Outcome This project creates a: ✅ Smart AI surveillance robot ✅ Cloud-connected IoT security system ✅ Real-time Telegram alert system ✅ AI-powered automation platform ✅ Edge AI + cloud AI hybrid architecture ✅ Expandable smart security ecosystem

AI Smart Railway Track Crack Detection Robot

AI Smart Railway Track Crack Detection Robot Agentic IoT using ESP32 + AI + n8n Automation + Telegram Voice Alerts + Google Sheets + ThingSpeak Dashboard

AI Smart Railway Track Crack Detection Robot Agentic IoT using ESP32 + AI + n8n Automation + Telegram Voice Alerts + Google Sheets + ThingSpeak Dashboard 1. Project Overview The AI Smart Railway Track Crack Detection Robot is an intelligent autonomous monitoring system designed to detect cracks and abnormalities in railway tracks using sensors and AI-based logic. The robot continuously scans railway tracks using ultrasonic and vibration sensors. The collected data is processed by an ESP32 microcontroller and transmitted to cloud services through Wi-Fi. The system integrates: ESP32-based IoT controller Crack detection sensors AI-powered anomaly prediction n8n automation workflows Telegram instant alerts Telegram voice notifications Google Sheets logging ThingSpeak cloud dashboard Agentic AI monitoring logic This project can help reduce railway accidents by detecting track faults early and automatically notifying railway authorities. 2. Key Features ✅ Real-time railway crack detection ✅ ESP32 Wi-Fi enabled IoT monitoring ✅ AI-based abnormality prediction ✅ Telegram instant alerts ✅ Telegram voice notifications ✅ Google Sheets automatic logging ✅ ThingSpeak cloud visualization ✅ Autonomous Agentic IoT workflow ✅ Cloud monitoring dashboard ✅ Low-power intelligent operation ✅ Expandable for GPS and camera AI 3. System Architecture Railway Track ↓ Sensors (Ultrasonic + Vibration + IR) ↓ ESP32 Controller ↓ Wi-Fi Cloud APIs / n8n ↓ ┌──────────────────────┐ │ Telegram Bot Alerts │ │ Voice Notifications │ │ Google Sheets Logs │ │ ThingSpeak Dashboard│ └──────────────────────┘ ↓ AI Prediction Engine ↓ Maintenance Decision Support 4. Components List Component Quantity Purpose ESP32 Dev Board 1 Main controller Ultrasonic Sensor HC-SR04 1 Crack distance detection Vibration Sensor SW-420 1 Detect rail vibration anomalies IR Sensor Module 1 Track surface monitoring DC Gear Motors 2 Robot movement L298N Motor Driver 1 Motor control Robot Chassis 1 Mechanical platform Wheels 2 Robot mobility Li-ion Battery Pack 1 Power supply Voltage Regulator 1 Stable voltage Jumper Wires Multiple Connections Breadboard / PCB 1 Circuit assembly Buzzer 1 Local alert LED Indicators 2 Status indication Wi-Fi Router/Hotspot 1 Internet connectivity 5. Working Principle Robot moves along railway track. Ultrasonic sensor continuously measures surface gap. If abnormal distance is detected: Crack condition triggered. ESP32 sends sensor data to: n8n workflow ThingSpeak cloud Google Sheets n8n automation: Generates Telegram alerts Sends voice notifications AI logic predicts: Power consumption Sensor anomaly patterns Maintenance risk score 6. Circuit Schematic Diagram ESP32 Connections ESP32 Pin Connected Device GPIO 5 Ultrasonic Trigger GPIO 18 Ultrasonic Echo GPIO 19 Vibration Sensor GPIO 21 IR Sensor GPIO 25 Motor Driver IN1 GPIO 26 Motor Driver IN2 GPIO 27 Motor Driver IN3 GPIO 14 Motor Driver IN4 GPIO 2 Buzzer 5V Sensors VCC GND Common Ground 7. Flowchart START ↓ Initialize ESP32 & Wi-Fi ↓ Read Sensors ↓ Analyze Crack Condition ↓ Is Crack Detected? ┌───────────────┐ │ YES │ NO ↓ ↓ Send Alerts Continue Monitoring ↓ Upload to Cloud ↓ AI Prediction ↓ Store in Google Sheets ↓ Voice Notification ↓ Continue Monitoring 8. ESP32 Source Code (Arduino IDE) #include #include const char* ssid = "YOUR_WIFI_NAME"; const char* password = "YOUR_WIFI_PASSWORD"; #define TRIG_PIN 5 #define ECHO_PIN 18 #define BUZZER 2 String webhookURL = "YOUR_N8N_WEBHOOK_URL"; void setup() { Serial.begin(115200); pinMode(TRIG_PIN, OUTPUT); pinMode(ECHO_PIN, INPUT); pinMode(BUZZER, OUTPUT); WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED) { delay(1000); Serial.println("Connecting..."); } Serial.println("WiFi Connected"); } float getDistance() { digitalWrite(TRIG_PIN, LOW); delayMicroseconds(2); digitalWrite(TRIG_PIN, HIGH); delayMicroseconds(10); digitalWrite(TRIG_PIN, LOW); long duration = pulseIn(ECHO_PIN, HIGH); float distance = duration * 0.034 / 2; return distance; } void loop() { float distance = getDistance(); Serial.println(distance); if(distance > 15) { digitalWrite(BUZZER, HIGH); if(WiFi.status() == WL_CONNECTED) { HTTPClient http; http.begin(webhookURL); http.addHeader("Content-Type", "application/json"); String payload = "{\"crack\":\"DETECTED\",\"distance\":" + String(distance) + "}"; int httpResponseCode = http.POST(payload); Serial.println(httpResponseCode); http.end(); } } else { digitalWrite(BUZZER, LOW); } delay(3000); } 9. n8n Automation Workflow Workflow Functions The n8n workflow performs: Receives ESP32 webhook data Detects crack event Sends Telegram message Converts text to voice Logs to Google Sheets Updates AI prediction database n8n Workflow Structure Webhook Trigger ↓ IF Crack Detected ↓ ┌───────────────┬────────────────┬────────────────┐ ↓ ↓ ↓ Telegram Bot Google Sheets ThingSpeak API ↓ Text-to-Speech ↓ Telegram Voice Alert n8n Workflow JSON { "nodes": [ { "name": "Webhook", "type": "n8n-nodes-base.webhook" }, { "name": "IF Crack", "type": "n8n-nodes-base.if" }, { "name": "Telegram", "type": "n8n-nodes-base.telegram" }, { "name": "Google Sheets", "type": "n8n-nodes-base.googleSheets" } ] } 10. Telegram Bot Setup Step 1: Create Bot Open Telegram and search: Telegram Search for: BotFather Commands: /start /newbot Copy generated BOT TOKEN. Step 2: Get Chat ID Send a message to your bot. Open: Telegram API GetUpdates Example: https://api.telegram.org/bot/getUpdates Copy chat ID. 11. Telegram Voice Notification Automation Voice Alert Logic When crack detected: "Warning! Railway track crack detected. Immediate inspection required." n8n uses: Google TTS ElevenLabs API Telegram voice upload 12. Google Sheets Integration Create Google Sheet Example columns: Time Distance Crack Status Location Google Cloud Setup Enable: Google Sheets API Google Drive API Create: OAuth credentials Connect Google account in n8n. 13. ThingSpeak Cloud Dashboard Setup Create account on: ThingSpeak Create Channel Fields Field Data Field 1 Distance Field 2 Crack Status Field 3 AI Risk Score ESP32 Upload API Example String url = "http://api.thingspeak.com/update?api_key=YOUR_KEY&field1=" + String(distance); 14. AI Power Consumption Prediction Logic Objective Predict battery usage and optimize robot operation. AI Parameters Parameter Description Motor runtime Robot movement duration Sensor activity Number of readings Wi-Fi transmission Network usage Alert frequency Number of alerts Simple AI Formula Battery prediction: P=V×I Remaining battery estimation: Battery Life= Current Consumption Battery Capacity ​ AI Decision Logic IF battery < 20% Reduce sensor frequency Disable continuous movement Enable low-power mode 15. ThingSpeak AI Analytics ThingSpeak can: Visualize sensor graphs Generate anomaly trends Predict maintenance frequency Monitor robot uptime 16. Future Enhancements Advanced AI Features Computer Vision Add ESP32-CAM Crack image detection using CNN GPS Tracking Real-time robot location GSM Module SMS alerts without Wi-Fi Solar Charging Autonomous outdoor charging Edge AI TinyML on ESP32 Digital Twin Railway virtual monitoring system 17. Deployment Guide Railway Testing Procedure Step 1 Test sensors on small track model. Step 2 Calibrate crack threshold values. Step 3 Deploy on low-speed railway section. Step 4 Monitor cloud dashboard. Step 5 Train AI model using collected data. 18. Safety Considerations Use insulated battery enclosure Waterproof sensor casing Add emergency stop switch Ensure motor speed control Avoid live railway testing without permission 19. Advantages ✅ Low-cost monitoring ✅ Real-time automation ✅ Reduced human inspection ✅ Early fault detection ✅ Cloud-enabled analytics ✅ AI-assisted maintenance 20. Applications Railway safety systems Smart transportation Industrial track monitoring Metro rail maintenance Autonomous inspection robots 21. Project Outcome The system demonstrates how AI + IoT + Automation + Cloud Computing can modernize railway infrastructure using low-cost embedded hardware. The combination of: ESP32 n8n workflows Telegram automation Google Sheets logging ThingSpeak analytics AI prediction creates a complete Agentic Smart Railway Monitoring Ecosystem.