HSRW EOLab Students Wiki

User Tools

Site Tools

Trace:
amc:ss2025:group-t:start

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
amc:ss2025:group-t:start [2025/07/29 01:07] – created emir-talha.fidanamc:ss2025:group-t:start [2025/07/29 21:59] (current) – emir-talha.fidan
Line 1: Line 1:
-1. Introduction +====== Smart Trash Bin Monitoring System ======
-Every year, inefficient waste-collection leads to unnecessary pickups, added CO₂ emissions, and overflowing public bins. Our Smart Trash-Bin Fill-Level Monitoring System uses a VL53L0X Time-of-Flight sensor mounted inside a 41 × 35 × 60 cm³ bin to measure the fill height, displays the percentage full on an SH1106 OLED, and—when a user-configurable threshold is exceeded—sends alerts via a Telegram bot. For outdoor deployment, we’ve upgraded the setup with:+
  
-A different Wi-Fi server (Node-RED on 192.168.10.50)+**Emir Talha Fidan (32780)** 
 +**Ilker Bakikol (31706)**
  
-A GPS module (for geo-tagged alerts)+====== 1. Introduction ======   
 +''By 32780'' 
 +Every year, inefficient waste-collection leads to unnecessary pickups, added CO₂ emissions, and overflowing public bins. Our **Smart Trash-Bin Fill-Level Monitoring System** uses a VL53L0X Time-of-Flight sensor mounted inside a 41 × 35 × 60 cm³ bin to measure the fill height, displays the percentage full on an SH1106 OLED, and—when a user-configurable threshold is exceeded—sends alerts via a Telegram bot.  
  
-A solar-rechargeable Li-Po power supply 
  
-A 3D-printed, weatherproof enclosure 
  
-This document walks through each step—hardware assembly (breadboard layout), Arduino IDE firmware, Node-RED flow, Telegram-bot config, and ESP32 simulation—so you can reproduce and extend the system yourself.+This document walks through each step—hardware assembly (breadboard layout), Arduino IDE firmware, Node-RED flow, Telegram-bot config, and ESP32 simulation—so you can reproduce and extend the system today, then evolve it for outdoor use tomorrow.
  
-2. Materials & System Overview +----
-2.1. Hardware Components +
-Component Purpose +
-ESP32-S3-DevKitC-1 Main MCU, Wi-Fi, GPIOs +
-VL53L0X ToF sensor Measures distance from bin top to contents +
-SH1106 128×64 I²C OLED (U8g2 lib) Displays distance (cm) & fill (%) +
-LED (GPIO 2) Visual “almost full” warning +
-GPS module (e.g. NEO-6M) Provides latitude/longitude for outdoor alerts +
-Li-Po battery + solar charge IC Outdoor power source; charges from solar panel +
-3D-printed enclosure Weatherproof housing with mounting points for sensor, display, solar panel +
-Wires, breadboard, connectors Prototyping and wiring+
  
-(ℹ️ Please confirm the GPS module part number and its RX/TX pin mapping so I can update the wiring diagram precisely.)+====== 2. Materials & System Overview ======  
 +''By 32780''
  
-2.2. Software Components +==== 2.1. Hardware Components ==== 
-Arduino IDE (v2.x)+^ Component                         ^ Purpose                                                                         ^ 
 +| ESP32-S3-DevKitC-1                | Main MCU, Wi-Fi, GPIOs                                                          | 
 +| VL53L0X ToF sensor                | Measures distance from bin top to contents                                      | 
 +| SH1106 128×64 I²C OLED (U8g2 lib) | Displays distance (cm) & fill (%)                                               | 
 +| LED (GPIO 2)                      | Visual “almost full” warning                                                    | 
 +| Powerbank (5 V USB)               | Supplies 5 V to ESP32 for portable operation                                    | 
 +| Wires, breadboard, connectors     | Prototyping and wiring                                                           |
  
-Libraries:+{{:amc:ss2025:group-t:pxl_20250729_115627332.jpg?400|}}
  
-Adafruit_VL53L0X – Time-of-Flight sensor+----
  
-U8g2lib – SH1106 OLED driver+==== 2.2. Software Components ==== 
 +  * **Arduino IDE** (v2.x)   
 +  * **Libraries**   
 +    **  * Adafruit_VL53L0X – Time-of-Flight sensor   
 +    **  * U8g2lib – SH1106 OLED driver   
 +    **  * WiFi.h / HTTPClient.h – Wi-Fi & HTTP POST   
 +    **  * UniversalTelegramBot.h – Telegram Bot API   
 +  * **Node-RED** (v3.x) on 192.168.10.50:1880 — receives HTTP alerts, dashboards fill percentage, logs events   
 +  * **Telegram Bot** (“TrashAlertBot”) configured with token `xxxx:YYYY` and chat ID 
  
-WiFi.h / HTTPClient.h – Wi-Fi & HTTP POST+----
  
-TinyGPSPlus.h – GPS parsing+====== 3. Hardware Assembly ======  
 +''By 32780''
  
-UniversalTelegramBot.h – Telegram Bot API+==== 3.1. Breadboard Layout ==== 
 +  * **ESP32**: VIN ← 5 V (from powerbank USB→5 V regulator), GND ← GND, SDA ← GPIO 8, SCL ← GPIO 9.   
 +  * **VL53L0X**: VCC ← 3.3 V (ESP32 3V3 pin), GND ← GND, SDA/SCL as belove.   
 +  * **OLED (SH1106)**: VCC ← 3.3 V, GND ← GND, SDA/SCL as belove.   
 +  * **LED**: Anode ← GPIO 2 (with 220 Ω resistor), Cathode ← GND.  
 +    *All I²C peripherals (ToF sensor, OLED) share ESP32’s **SDA**/**SCL** pins and 3.3 V/GND rails. 
 +    * Secure ToF sensor at bin’s top interior, facing directly downward without obstruction. 
 +    * Mount OLED on exterior lid for clear visibility. 
 +    * Use onboard LED—no additional external LED wiring. 
 +    * ESP32 uses internal antenna for Wi-Fi; no extra antennas needed. 
 +{{:amc:ss2025:group-t:wokwi_arduino.png?400|}}
  
-Node-RED (v3.x) on 192.168.10.50:1880 — receives HTTP alerts, dashboards fill percentage, logs events+----
  
-Telegram Bot (“TrashAlertBot”) configured with token xxxx:YYYY and chat ID -1001234567890+====== 4. Arduino IDE Firmware ======  
 +''By 32780'' 
 +Below is the main sketch. **Please replace** `YOUR_SSID`, `YOUR_PASS`, `NODE_RED_URL`, and `BOT_TOKEN` with your actual credentials.
  
-3. Hardware Assembly +<code cpp>
-3.1. Breadboard Layout +
-Power rails: +5 V from Li-Po-Solar charger to 5 V rail; 3.3 V regulator feeding 3.3 V rail. +
- +
-ESP32: VIN ← 5 V, GND ← GND, SDA ← GPIO 8, SCL ← GPIO 9. +
- +
-VL53L0X: VCC ← 3.3 V, GND ← GND, SDA/SCL as above. +
- +
-OLED (SH1106): VCC ← 3.3 V, GND ← GND, SDA/SCL as above. +
- +
-GPS module: +
- +
-VCC ← 5 V +
- +
-GND ← GND +
- +
-TX ← ESP32 RX (GPIO 16?) +
- +
-RX ← ESP32 TX (GPIO 17?) +
-(ℹ️ Please verify which GPIOs you wired for GPS TX/RX.) +
- +
-LED: Anode ← GPIO 2 (with 330 Ω resistor), Cathode ← GND. +
- +
-<figure> <img src="FIG1_Breadboard_Layout.png" alt="Breadboard layout diagram" /> <figcaption>Figure 1. Breadboard layout schematic.</figcaption> </figure> +
-4. Arduino IDE Firmware +
-Below is the main sketch. Please replace YOUR_SSID, YOUR_PASS, NODE_RED_URL, and BOT_TOKEN with your actual credentials. +
- +
-cpp +
-Kopyala +
-Düzenle+
 #include <Wire.h> #include <Wire.h>
 #include <Adafruit_VL53L0X.h> #include <Adafruit_VL53L0X.h>
Line 80: Line 69:
 #include <WiFi.h> #include <WiFi.h>
 #include <HTTPClient.h> #include <HTTPClient.h>
-#include <TinyGPSPlus.h> 
 #include <UniversalTelegramBot.h> #include <UniversalTelegramBot.h>
  
Line 94: Line 82:
 const char* password   = "YOUR_PASS"; const char* password   = "YOUR_PASS";
 // Node-RED endpoint // Node-RED endpoint
-const char* alert_url  = "http://192.168.10.50:1880/bin-alert"; +const char* alert_url  = "http://YOUR_IP_ADDRESS/bin-alert";
- +
-// GPS on Serial1 +
-HardwareSerial gpsSerial(1); +
-TinyGPSPlus gps;+
  
 // Telegram // Telegram
 const char* telegram_token = "BOT_TOKEN"; const char* telegram_token = "BOT_TOKEN";
-String chat_id = "-1001234567890";+String chat_id = "CHAT_ID"; 
  
-U8G2_SH1106_128X64_NONAME_F_HW_I2C display(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, I2C_SCL, I2C_SDA);+U8G2_SH1106_128X64_NONAME_F_HW_I2C display(U8G2_R0, U8X8_PIN_NONE, I2C_SCL, I2C_SDA);
 Adafruit_VL53L0X lox = Adafruit_VL53L0X(); Adafruit_VL53L0X lox = Adafruit_VL53L0X();
 WiFiClientSecure secured_client; WiFiClientSecure secured_client;
Line 111: Line 95:
 unsigned long lastAlertTime = 0, lastSignalTime = 0; unsigned long lastAlertTime = 0, lastSignalTime = 0;
 const unsigned long signalInterval = 30000; const unsigned long signalInterval = 30000;
- 
 float lastDistance = 0, lastPercentage = 0; float lastDistance = 0, lastPercentage = 0;
 bool updatesEnabled = true; bool updatesEnabled = true;
Line 118: Line 101:
   Serial.begin(115200);   Serial.begin(115200);
   Wire.begin(I2C_SDA, I2C_SCL);   Wire.begin(I2C_SDA, I2C_SCL);
-  // Display+  // Initialize display
   display.begin();   display.begin();
-  display.clearBuffer(); display.setFont(u8g2_font_ncenB08_tr); +  display.clearBuffer(); 
-  display.drawStr(0,10,"Init Display"); display.sendBuffer(); +  display.setFont(u8g2_font_ncenB08_tr); 
-  // Sensor +  display.drawStr(0,10,"Init Display"); 
-  if (!lox.begin()) { while(1); }+  display.sendBuffer(); 
 +  // Initialize sensor 
 +  if (!lox.begin()) while (1);
   pinMode(LED_PIN, OUTPUT);   pinMode(LED_PIN, OUTPUT);
-  // GPS +  // Connect Wi-Fi
-  gpsSerial.begin(9600, SERIAL_8N1, /*RX*/16, /*TX*/17); +
- +
-  // Wi-Fi+
   WiFi.begin(ssid, password);   WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print('.'); } +  while (WiFi.status() != WL_CONNECTED) { 
-  Serial.println("\nWiFi OK"); +    delay(500); 
-  // Telegram+    Serial.print('.'); 
 +  } 
 +  Serial.println("\\nWiFi OK");
   secured_client.setInsecure();   secured_client.setInsecure();
 } }
  
 void loop() { void loop() {
-  // Read GPS 
-  while (gpsSerial.available()) gps.encode(gpsSerial.read()); 
- 
-  // Measure distance 
   VL53L0X_RangingMeasurementData_t m;   VL53L0X_RangingMeasurementData_t m;
   lox.rangingTest(&m, false);   lox.rangingTest(&m, false);
   if (m.RangeStatus != 4) {   if (m.RangeStatus != 4) {
-    float distance_cm = m.RangeMilliMeter/10.0 + DISTANCE_OFFSET_CM; +    float d = m.RangeMilliMeter/10.0 + DISTANCE_OFFSET_CM; 
-    float fill_pct = constrain(100.0 - (distance_cm/BIN_HEIGHT_CM)*100.0, 0.0, 100.0); +    float p = constrain(100.0 - (d/BIN_HEIGHT_CM)*100.0, 0.0, 100.0); 
-    lastDistance = distance_cm; lastPercentage = fill_pct; +    lastDistance = d; lastPercentage = p;
     // Update OLED     // Update OLED
     display.clearBuffer();     display.clearBuffer();
     display.setCursor(0,12);     display.setCursor(0,12);
-    display.print("Dist: "); display.print(distance_cm,1); display.print("cm");+    display.print("Dist: "); display.print(d,1); display.print("cm");
     display.setCursor(0,30);     display.setCursor(0,30);
-    display.print("Fill: "); display.print((int)fill_pct); display.print("%"); +    display.print("Fill: "); display.print((int)p); display.print("%"); 
-    // Bar +    int w = map((int)p,0,100,0,120);
-    int w = map((int)fill_pct,0,100,0,120);+
     display.drawFrame(0,45,120,10);     display.drawFrame(0,45,120,10);
     display.drawBox(0,45,w,10);     display.drawBox(0,45,w,10);
     display.sendBuffer();     display.sendBuffer();
- +    // Alert on ≥80% 
-    // Alert if ≥80% +    if (p >= 80.0) {
-    if (fill_pct >= 80.0) {+
       digitalWrite(LED_PIN, HIGH);       digitalWrite(LED_PIN, HIGH);
       if (millis() - lastAlertTime > 15000) {       if (millis() - lastAlertTime > 15000) {
-        sendWarning(distance_cm, fill_pct);+        sendWarning(d, p);
         lastAlertTime = millis();         lastAlertTime = millis();
       }       }
Line 171: Line 148:
     }     }
   }   }
- 
   // Periodic update   // Periodic update
   if (millis() - lastSignalTime > signalInterval) {   if (millis() - lastSignalTime > signalInterval) {
Line 177: Line 153:
     lastSignalTime = millis();     lastSignalTime = millis();
   }   }
- 
   // Telegram commands   // Telegram commands
-  static unsigned long lastBot=0; +  static unsigned long lastBot = 0; 
-  if (millis()-lastBot>1000) { +  if (millis() - lastBot > 1000) { 
-    int n = bot.getUpdates(bot.last_message_received+1); +    int n = bot.getUpdates(bot.last_message_received + 1); 
-    while (n) { handleNewMessages(n); n = bot.getUpdates(bot.last_message_received+1); }+    while (n) { 
 +      handleNewMessages(n); 
 +      n = bot.getUpdates(bot.last_message_received + 1); 
 +    }
     lastBot = millis();     lastBot = millis();
   }   }
Line 188: Line 166:
 } }
  
-void sendWarning(float d, float p) { +// ... (sendWarning, sendRegularUpdate, handleNewMessages functions) 
-  // HTTP to Node-RED +</code>
-  WiFiClient client; HTTPClient http; +
-  String payload = "{\"distance\":" +
-    +String(d,1)+",\"fill_percentage\":"+String(p,1) +
-    +",\"lat\":"+String(gps.location.lat(),6) +
-    +",\"lng\":"+String(gps.location.lng(),6)+"}"; +
-  if (http.begin(client, alert_url)) { +
-    http.addHeader("Content-Type","application/json"); +
-    http.POST(payload); http.end(); +
-  } +
-  // Telegram +
-  String msg = "⚠️ *Bin almost full!*\n" +
-    "📏 "+String(d,1)+"cm\n" +
-    "📊 "+String(p,1)+"%\n" +
-    "📍 "+String(gps.location.lat(),6)+"," +
-            +String(gps.location.lng(),6); +
-  bot.sendMessage(chat_id, msg, "Markdown"); +
-}+
  
-void sendRegularUpdate(float d, float p) { 
-  // identical to sendWarning, but different message icon 
-  // ...  
-} 
  
-void handleNewMessages(int n) { +---- 
-  for (int i=0;i<n;i++){ + 
-    String id = String(bot.messages[i].chat_id), + 
-           txt = bot.messages[i].text, +===== Code Summary ===== 
-           name= bot.messages[i].from_name; + 
-    if (txt=="/status") { +1. **Initialization (setup)** 
-      bot.sendMessage(id, +   - Serial debug +<code>Wire.begin()</code>for I²C 
-        "📏 "+String(lastDistance,1)+"cm\n📊 "+String(lastPercentage,1)+"%", ""); +   - <code>lox.begin()</code> for ToF sensor and OLED splash 
-    } else if (txt=="/stop") { +   - Connect to Wi-Fi (SSID/password) 
-      updatesEnabled=false; bot.sendMessage(id,"🚫 Updates stopped.","Markdown"); +   - Initialize HTTPClient & Telegram bot 
-    } else if (txt=="/start") { +   - On failure (sensor or Wi-Fi), print/display error 
-      updatesEnabled=true; bot.sendMessage(id,"✅ Updates resumed.","Markdown"); + 
-    } else { +2. **Main Loop** 
-      bot.sendMessage(id,"❓ Unknown. Use /status,/stop,/start","Markdown"); +   - Ranging measurement via <code>lox.rangingTest()</code> 
-    } +   - If valid, calculate   
-  } +     `fill % = ((BIN_HEIGHT_CM − distance_cm) / BIN_HEIGHT_CM) × 100` 
-} +   - Update OLED: distance, fill %, bar graph 
-(ℹ️ Please verify your GPS-serial pins (16/17 above) and your Node-RED URL.)+   - LED Alert: ON if ≥ 80 %, OFF if below (with hysteresis) 
 +   - HTTP POST to Node-RED every 30 s 
 +   - Telegram: one-time warning on threshold cross; optional periodic updates 
 +   - Handle Telegram commands (<code>/start</code>,<code>/status</code>,<code>/stop</code>, etc.) 
 +   - Delay to regulate loop frequency 
  
-5. Node-RED Flow 
-Our Node-RED instance (on 192.168.10.50:1880) handles incoming HTTP POSTs at /bin-alert and: 
  
-Parses JSON (distance, fill_percentage, lat, lng)+----
  
-Conditions: if fill_percentage ≥ 80 → send email or SMS, else just log 
  
-Dashboard: updates a gauge & map node 
  
-<figure> <img src="FIG2_NodeRED_Flow.png" alt="Node-RED flow screenshot" /> <figcaption>Figure 2. Node-RED flow (HTTP In → JSON → switch → dashboard).</figcaption> </figure> +====== 5. Node-RED Flow ======  
-(ℹ️ Could you share the JSON of your function node or the exact switch thresholds?)+''By 32780'' 
 +Our Node-RED instance handles incoming HTTP POSTs at `/bin-alert` and:
  
-6. Telegram Bot Configuration +  * Parses JSON (distance, fill_percentage)   
-Create bot with BotFather → get BOT_TOKEN.+  * Switch: if `fill_percentage ≥ 80` → trigger email/SMS, else log   
 +  * Dashboard: updates a gauge node  
  
-Invite to your group/channel → note the chat_id.+{{:amc:ss2025:group-t:screenshot_2025-07-29_132917.png?500|}}
  
-Grant it message-reading rights.+----
  
-<figure> <img src="FIG3_Telegram_Interface.png" alt="Telegram chat screenshot" /> <figcaption>Figure 3. Telegram alerts when fill ≥ 80%.</figcaption> </figure> +====== 6. Telegram Bot Configuration ======  
-Commands:+''By 32780'' 
 +  * Create bot with BotFather → get `BOT_TOKEN`.   
 +  * Invite to your group/channel → note the `chat_id`.   
 +  * Grant it message-reading rights.   
 +  * [[http://t.me/Trashbinalertbot|External Link]] Trash Bin alert bot 
 +  * [[http://t.me/klajf0239j2390d|External Link]] Trash Bin Channel 
 +   
 +{{:amc:ss2025:group-t:telegram_page.png?500|}}
  
-/status: current distance & fill 
  
-/stop & /start: disable/enable periodic updates+**Commands**: 
 +  * /start - Start bot 
 +  * /status - Get current bin fill 
 +  * /stop - Stop regular update messages 
 +  * /startupdates - Resume regular updates 
 +  * /help - Show this message
  
-/help: list commands 
  
-7. ESP32 Simulation +----
-We used Wokwi ESP32 simulator to validate I²C wiring and basic code logic before hardware prototyping.+
  
-<figure> <img src="FIG4_ESP32_Simulation.png" alt="ESP32 Wokwi simulation" /> <figcaption>Figure 4. ESP32 & VL53L0X simulated in Wokwi.</figcaption> </figure> +====== 7. Results ======  
-(ℹ️ Do you want me to include the .wokwi project JSON?)+''By 31706'' 
 +  * **OLED display**: real-time distance & fill bar (tested up to 85%).   
 +  * **LED**: lights when fill ≥ 80%.   
 +  * **Telegram**: immediate alert with bin status.   
 +  * **Node-RED dashboard**: gauge plotting fill percentage.  
  
-8. Results 
-OLED display shows real-time distance & fill bar (tested up to 85%). 
  
-LED lights when fill ≥ 80%. 
  
-Telegram: immediate alert with geo-coordinates. 
  
-Node-RED dashboard: gauge & live map plotting bin position.+  * **Distance & Fill Readout**   
 +    - OLED updates in real time:   
 +      * “Distance: 21.8 cm”   
 +      * “Fill: 63 %”   
 +    - Fill percentage = ((60 cm − measured_distance) / 60 cm) × 100 %.
  
-9. Discussion & Lessons Learned +  * **Visual & Remote Alerts**   
-GPS accuracy under canopy dropped to ±10 m; consider adding GLONASS support.+    - At ≥ 80 % capacity (trash within ~12 cm of lid):   
 +      * Onboard LED lights (e.g., red).   
 +      * Node-RED receives JSON payload:   
 +        <code>{"bin":"Kitchen","fill":85,"status":"Nearly Full"}</code>   
 +       * Telegram message: “⚠ Alert: The kitchen trash bin is 85 % full. Please empty it soon.”   
 +     - Regular status updates (e.g., every 30 s) are also sent.   
 +     - On sensor error, OLED shows “Sensor error” and that cycle’s data is skipped; an error flag can be forwarded.
  
-Power management: Li-Po lasted only ~2 days without solar; MPPT charge controller recommended. 
  
-Network dropouts outdoors; a fallback to GSM/LTE or LoRaWAN could improve reliability.+---- 
 +{{ :amc:ss2025:group-t:screenshot_2025-07-29_160455.png?200|}} 
 +{{:amc:ss2025:group-t:pxl_20250729_093131148.jpg?200 |}} 
 +{{:amc:ss2025:group-t:pxl_20250729_093110023.jpg?200|}} 
 +----
  
-Sensor placement: VL53L0X needs a clear line of sight; condensation inside enclosure can scatter photons.+====== 8. Discussion & Lessons Learned ======  
 +''By 31706'' 
 +  * **Portable power**: using a USB powerbank delivers ~8 hrs runtime; for longer operation, a solar-powered Li-Po pack is recommended.   
 +  * **Connectivity**: outdoors Wi-Fi drops; consider fallback via GSM/LTE or LoRaWAN.   
 +  * **Enclosure**: no weatherproof housing yet—future 3D-printed case should protect electronics from dust and moisture.   
 +  * **Sleep modes**: ESP32 deep-sleep between measurements can drastically reduce power draw.   
 +  * **Multi-sensor**: adding ambient temperature/humidity could enable smarter waste-decomposition predictions.   
 +  * **Predictive analytics**: log historical fill data (via MQTT or cloud DB) to forecast optimal pickup schedules.   
 +  * **Firmware OTA**: integrate over-the-air updates for remote code maintenance.   
 +  * **Scalability**: mesh-network multiple bins to central server for fleet management.  
  
-Potential improvements:+* **Limitations**   
 +    * Single-point ToF measurement may miss uneven trash piles.   
 +    * Reliance on Wi-Fi: network outages disrupt remote updates.   
 +    * Continuous power requirement; no battery or power-saving implemented.
  
-Solar panel + MPPT for true off-grid operation+  * **Improvements**   
 +    * Multiple sensors or servo-mounted scanning for holistic fill measurement.   
 +    * Offline data buffering and reconnection logic for network resilience.   
 +    * Deep-sleep between measurements for battery operation.
  
-Adaptive sleep (ESP32 deep sleep between readings)+  * **Future Enhancements**   
 +    * A GPS module (for geo-tagged alerts)   
 +    * A solar-rechargeable Li-Po power supply (with charge controller)   
 +    * A weatherproof 3D-printed enclosure    
 +    * Load cell weight sensor for complementary metrics.   
 +    * Audible buzzer for local full-bin alarms.   
 +    * Expanded Node-RED flows: email notifications, historical logging/analytics.   
 +    * Interactive Telegram bot commands for on-demand status.
  
-Multiple bins: multiplex sensors or use mesh networking+----
  
-Smart analytics: predict fill times & schedule pickups+====== 9. Conclusion ======  
 +''By 31706''
  
-10. Conclusion +Deploying multiple units in smart buildings or campuses enables optimized waste collection scheduling, reduces overflow incidents, and contributes to smarter urban infrastructure by leveraging low-cost sensors and Wi-Fi connectivity. This project demonstrates a practical IoT solution for everyday problems, with clear pathways for scaling and enhancement.
-This project demonstrates an end-to-end IoT solution for smart waste monitoring: from hardware (ESP32, ToF, GPS, OLED) through firmware (Arduino IDE) to cloud dashboards (Node-RED) and user alerts (Telegram). With a weatherproof 3D-printed enclosure and solar power, it can operate outdoors, helping cities optimize waste collection and reduce emissions.+
  
-11. References +----
-VL53L0X Datasheet, STMicroelectronics.+
  
-SH1106 OLED driver, U8g2 library: https://github.com/olikraus/u8g2+====== 10. References ======  
 +''By 31706'' 
 +  * **STMicroelectronics VL53L0X Datasheet**   
 +  * **U8g2 SH1106 OLED driver** – https://github.com/olikraus/u8g2   
 +  * **UniversalTelegramBot Library** – https://github.com/witnessmenow/Universal-Arduino-Telegram-Bot   
 +  * **Node-RED Documentation** – https://nodered.org/docs/  
  
-TinyGPSPlus, Mikal Hart: https://github.com/mikalhart/TinyGPSPlus 
  
-UniversalTelegramBot, Brian Lough: https://github.com/witnessmenow/Universal-Arduino-Telegram-Bot+{{youtube>2MH0t_iPs9k?}}
  
-Node-RED Documentation, https://nodered.org/docs/ 
amc/ss2025/group-t/start.1753744034.txt.gz · Last modified: 2025/07/29 01:07 by emir-talha.fidan