AI-Based ECG and Heart Disease Prediction System

AI-Based ECG & Heart Disease Prediction System Agentic IoT using ESP32 + AI + n8n Automation + Telegram Voice Alerts + Google Sheets + ThingSpeak Cloud Dashboard

AI-Based ECG & Heart Disease Prediction System Agentic IoT using ESP32 + AI + n8n Automation + Telegram Voice Alerts + Google Sheets + ThingSpeak Cloud Dashboard 1. Project Overview This project is an advanced AI-powered IoT healthcare monitoring system that continuously monitors ECG signals using an ESP32 microcontroller and predicts possible heart abnormalities using AI logic. The system integrates: ESP32 for sensor data acquisition ECG sensor module (AD8232) AI-based heart disease prediction n8n automation workflows Telegram voice alerts Google Sheets cloud logging ThingSpeak real-time dashboard Agentic IoT automation Web dashboard visualization The solution can be used for: Remote patient monitoring Smart healthcare systems Elderly monitoring Preventive cardiac diagnosis Wearable healthcare projects AI-assisted hospital systems 2. System Architecture ECG Sensor (AD8232) │ ▼ ESP32 Board │ ┌───────────┼───────────┐ ▼ ▼ ▼ ThingSpeak n8n Workflow AI Engine Dashboard │ │ ▼ ▼ Telegram Alerts Heart Disease Voice Msg Prediction │ ▼ Google Sheets 3. Features Core Features ✅ Real-time ECG Monitoring ✅ Heart Disease Prediction using AI ✅ Cloud Dashboard Visualization ✅ Telegram Notification Alerts ✅ Voice Notification Automation ✅ Google Sheets Data Logging ✅ ESP32 WiFi Connectivity ✅ ThingSpeak IoT Dashboard ✅ Agentic AI Decision Making ✅ Abnormal Heartbeat Detection ✅ BPM Calculation ✅ ECG Waveform Monitoring 4. Components List Component Quantity Purpose ESP32 Dev Board 1 Main controller AD8232 ECG Sensor 1 ECG signal acquisition Jumper Wires Several Connections Breadboard 1 Prototyping USB Cable 1 ESP32 programming Power Supply 1 System power WiFi Network 1 Cloud communication Smartphone 1 Telegram alerts Laptop/PC 1 n8n & monitoring 5. Working Principle ECG sensor captures heartbeat signals. ESP32 reads analog ECG waveform. BPM is calculated. AI logic evaluates ECG abnormalities. Data uploaded to ThingSpeak cloud. n8n receives webhook data. Telegram sends alert notifications. Voice alerts generated automatically. Google Sheets stores historical records. 6. Circuit Schematic Diagram AD8232 to ESP32 Connections AD8232 Pin ESP32 Pin OUTPUT GPIO34 3.3V 3.3V GND GND LO+ GPIO26 LO- GPIO27 7. Circuit Diagram (Text Representation) +-------------------+ | ESP32 | | | ECG OUT --> GPIO34 | LO+ --> GPIO26 | LO- --> GPIO27 | 3.3V --> 3.3V | GND --> GND | +-------------------+ 8. Flowchart START │ ▼ Initialize ESP32 WiFi │ ▼ Read ECG Sensor Data │ ▼ Calculate BPM │ ▼ AI Prediction Logic │ ┌──────┴───────┐ ▼ ▼ Normal Abnormal │ │ ▼ ▼ Upload Data Send Alert │ │ ▼ ▼ ThingSpeak Telegram Voice │ │ └──────┬───────┘ ▼ Google Sheets │ ▼ 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"; const int ecgPin = 34; int threshold = 550; void setup() { Serial.begin(115200); WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED) { delay(1000); Serial.println("Connecting..."); } Serial.println("WiFi Connected"); } void loop() { int ecgValue = analogRead(ecgPin); Serial.println(ecgValue); String condition = "Normal"; if(ecgValue > threshold) { condition = "Abnormal"; } if(WiFi.status() == WL_CONNECTED) { HTTPClient http; String url = "http://api.thingspeak.com/update?api_key=" + apiKey + "&field1=" + String(ecgValue); http.begin(url); int httpCode = http.GET(); Serial.println(httpCode); http.end(); } delay(2000); } 10. AI Heart Disease Prediction Logic Basic AI Logic The AI engine analyzes: ECG amplitude BPM variations Signal irregularities Threshold crossings Heart rhythm pattern Prediction Categories ECG Condition Prediction Normal waveform Healthy Irregular spikes Arrhythmia Risk High BPM Tachycardia Low BPM Bradycardia Noise patterns Sensor Error 11. Advanced AI Enhancement You can improve prediction using: TensorFlow Lite TinyML on ESP32 Edge AI inference Deep learning ECG classification Possible datasets: MIT-BIH Arrhythmia Dataset PhysioNet ECG Database 12. ThingSpeak Cloud Dashboard Setup Using ThingSpeak Steps Create account Create new channel Add fields: ECG Value BPM Prediction Copy Write API Key Insert API key into ESP32 code View real-time graphs 13. Google Sheets Integration Using: Google Apps Script n8n webhook automation Stored Parameters Timestamp ECG BPM Prediction Time ECG Value Heart Rate AI Result 14. Telegram Bot Setup Using Telegram BotFather Steps Open Telegram Search: BotFather Create new bot Copy Bot Token Obtain Chat ID Integrate into n8n workflow 15. Voice Notification Automation Example Voice Alerts Warning! Abnormal heart activity detected. Please check patient condition immediately. Voice Generation Methods Google Text-to-Speech Telegram Voice API ElevenLabs TTS gTTS Python library 16. n8n Automation Workflow Using n8n Automation Platform Workflow Process Webhook Trigger │ ▼ Receive ECG Data │ ▼ AI Analysis │ ▼ Condition Check │ ┌────┴─────┐ ▼ ▼ Normal Abnormal │ │ ▼ ▼ Log Data Telegram Alert │ │ ▼ ▼ Google Sheets Voice Message 17. Example n8n Workflow JSON { "nodes": [ { "parameters": {}, "name": "Webhook", "type": "n8n-nodes-base.webhook", "typeVersion": 1, "position": [250, 300] }, { "parameters": {}, "name": "Telegram", "type": "n8n-nodes-base.telegram", "typeVersion": 1, "position": [600, 300] } ], "connections": {} } 18. Web Dashboard Features Dashboard Includes Real-time ECG graph BPM display AI prediction result Alert status Patient history Device connectivity status 19. Agentic AI Features The system behaves like an autonomous AI agent: ✅ Detects anomalies ✅ Makes decisions ✅ Sends alerts automatically ✅ Stores data autonomously ✅ Predicts heart abnormalities ✅ Triggers emergency notifications 20. Power Consumption Prediction Logic AI Power Optimization The ESP32 predicts usage patterns: State Power Mode Idle Deep Sleep Monitoring Active Alert Mode High Performance Optimization Techniques Deep sleep mode Sensor polling intervals Adaptive WiFi transmission Edge AI processing 21. Security Enhancements Recommended Security HTTPS APIs Secure MQTT Token authentication Encrypted cloud communication User authentication 22. Future Enhancements Future Scope AI Enhancements Deep learning ECG analysis CNN-based arrhythmia detection Cloud AI diagnosis IoT Enhancements MQTT communication Firebase integration AWS IoT Core Edge AI Healthcare Enhancements Multi-patient monitoring Doctor dashboard Emergency ambulance alerts GPS tracking Hardware Enhancements OLED display Battery backup Wearable ECG device Mobile app integration 23. Deployment Guide Hardware Deployment Assemble ECG circuit Upload ESP32 firmware Connect WiFi Verify sensor readings Configure ThingSpeak Configure n8n Setup Telegram bot Test alerts 24. Testing Procedure Test Expected Result ECG Reading Real-time waveform BPM Calculation Accurate BPM Cloud Upload Data visible Telegram Alert Alert message received Voice Notification Audio alert plays Google Sheets Data logged 25. Applications Healthcare Applications Smart hospitals Remote healthcare Elderly monitoring ICU monitoring Fitness tracking Home healthcare systems 26. Advantages ✅ Low-cost healthcare solution ✅ Real-time monitoring ✅ AI-assisted diagnosis ✅ Remote accessibility ✅ Cloud integration ✅ Automation support ✅ Scalable architecture 27. Limitations ⚠ Not a certified medical device ⚠ Requires proper ECG electrode placement ⚠ AI predictions are indicative only ⚠ Internet required for cloud features 28. Conclusion The AI-Based ECG and Heart Disease Prediction System combines: Embedded systems Artificial intelligence IoT cloud monitoring Automation workflows Agentic healthcare intelligence This project demonstrates how ESP32, AI, n8n automation, and cloud technologies can create an intelligent remote healthcare monitoring ecosystem capable of real-time prediction, autonomous alerts, and scalable deployment. 29. Recommended Software & Platforms Arduino IDE ESP32 Board Package ThingSpeak Cloud n8n Workflow Automation Google Sheets Telegram API Documentation TensorFlow Lite for Microcontrollers

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