Differences

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

--- amc:ss2025:group-t:start [2025/07/29 01:05] – emir-talha.fidan
+++ amc:ss2025:group-t:start [2025/07/29 21:59] (current) – emir-talha.fidan
@@ Line 1: / Line 1: @@
+====== Smart Trash Bin Monitoring System ======
+**Emir Talha Fidan (32780)**
+**Ilker Bakikol (31706)**
-# Smart Trash Bin Monitoring System
+====== 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.
-## Introduction
-Efficient waste management often requires knowing when a trash bin is nearing capacity to prevent overflow and optimize collection schedules. This project implements a smart trash bin fill-level monitoring system using an ESP32-S3-DevKitC-1 microcontroller and a Time-of-Flight (ToF) distance sensor. The system continuously measures the distance from the bin’s lid to the top of the trash and calculates the fill percentage of a waste bin (internal dimensions \~41×35×60 cm). An OLED display provides real-time readouts of the distance and fill level, and an onboard LED gives a visual alert when the bin is almost full. Additionally, the device connects via Wi-Fi to send periodic updates and warnings to a Node-RED dashboard and a Telegram channel, enabling remote monitoring. This report details the design and results of the system, including hardware/software implementation, operational results, code logic, and a brief discussion of limitations and improvements.
-## Materials and Methods
+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.
-*Hardware Components:* The project’s hardware centers on the Espressif ESP32-S3-DevKitC-1 board, which serves as the main microcontroller. This board offers ample processing power and built-in Wi-Fi for network connectivity, making it ideal for IoT applications. Key components include:
+----
-* *ESP32-S3-DevKitC-1 Microcontroller:* Handles sensor interfacing, data processing, and Wi-Fi connectivity. The board’s onboard RGB LED (on GPIO48) is repurposed as a fill-level warning indicator.
+====== 2. Materials & System Overview ======
-* *Time-of-Flight Distance Sensor (VL53L0X or VL53L1X):* Short-range LiDAR module used to measure the distance from the bin’s lid to the trash surface. The VL53L0X can measure distances up to \~2 m, while the VL53L1X extends to \~4 m – both easily covering the \~0.6 m bin height. The sensor is mounted at the top of the bin pointing downward. It communicates via I²C to provide high-resolution distance readings in millimeters.
+''By 32780''
-* *SH1106 OLED Display (128×64 pixels, I²C):* Used to show the current distance reading (in cm) and the calculated fill percentage on a compact screen. This provides immediate visual feedback to users on site.
-* *Bin and Casing:* A standard trash bin (\~41 cm × 35 cm base, 60 cm tall) is used as the container. The electronics are mounted such that the ToF sensor protrudes inside the lid, and the OLED is visible externally for easy reading. The ESP32 board and sensor are powered via USB or a 5 V supply.
-*Wiring and Assembly:* The circuit is straightforward since most components use the I²C bus. The VL53L0X/VL53L1X sensor and the SH1106 OLED display are both connected to the ESP32’s I²C pins (SDA and SCL) using the Wire library for communication. Power (3.3 V) and ground lines are shared among the ESP32 and the I²C peripherals. The ESP32’s onboard LED is used for alerts (no extra wiring needed for an external LED). During assembly, care was taken to firmly attach the sensor at the bin’s top interior, ensuring it faces downwards without obstruction. The OLED is mounted on the outside or the lid for visibility. The ESP32 board connects to a Wi-Fi network for data transmission but requires no additional wiring for this (it uses its internal antenna).
+==== 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                                                    |
+| Powerbank (5 V USB)               | Supplies 5 V to ESP32 for portable operation                                    |
+| Wires, breadboard, connectors     | Prototyping and wiring                                                           |
-*Software and Libraries:* The firmware is written in C++ using the Arduino framework. Development and testing were done via the Arduino IDE. Several standard libraries facilitate the functionality:
+{{:amc:ss2025:group-t:pxl_20250729_115627332.jpg?400|}}
-* *Wire.h:* I²C communication library used to interface with the ToF sensor and OLED display.
+----
-* *Adafruit\_VL53L0X.h:* Driver for the ST VL53L0X ToF sensor (also compatible with VL53L1X with minor modifications) to initialize the sensor and read distance values.
-* *U8g2lib.h:* U8g2 graphics library for driving the SH1106 OLED display. It provides functions to render text and graphics on the screen over I²C.
-* *WiFi.h:* ESP32 Wi-Fi library to connect the device to a local wireless network (providing internet/LAN connectivity for IoT features).
-* *HTTPClient.h:* Used to send HTTP requests to a backend (in this case, a Node-RED endpoint). The system uses this to *POST* or *GET* the bin status to a Node-RED server, which can log data or trigger further actions.
-* *UniversalTelegramBot.h:* Library for interacting with the Telegram Bot API. This enables the ESP32 to send messages or alerts to a predefined Telegram chat (via an HTTP(S) request to Telegram’s servers). For example, the system uses this to push a warning message when the bin exceeds a fill threshold.
-* (Other core Arduino libraries like \<ArduinoJson.h> may be used for formatting data payloads, and \<ESP32HTTPClient.h> is typically included via HTTPClient on ESP32.)
-After programming, the ESP32-S3 board was powered and connected to Wi-Fi. A simple Node-RED flow was set up on a computer/server to receive HTTP POST data from the ESP32 (containing distance or fill level info) and display or log it. A Telegram bot was created and its credentials (bot token and chat ID) were configured in the firmware to allow the device to send Telegram messages.
+==== 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
-## Results
+----
-Once deployed, the smart bin monitoring system performed continuous measurement and successfully provided both local and remote feedback on the bin’s status. *Distance and Fill Readout:* The OLED display updates in real-time with the current distance from the sensor to the trash. For instance, if the trash is 45 cm below the lid, the display might show “Distance: 45.0 cm” on one line. The next line shows the calculated fill percentage, e.g. “Fill: 25%”. The fill percentage is computed based on the bin’s 60 cm height (e.g. fill% = (60 cm − measured_distance) / 60 cm × 100%). As trash accumulates and the measured distance decreases, the displayed percentage increases. This provides an immediate intuitive indication of how full the bin is.
+====== 3. Hardware Assembly ======
+''By 32780''
-*Visual and Remote Alerts:* A key feature is the automatic alert when the bin is nearly full. The system defines “nearly full” as ≥80% capacity (i.e. the trash is within roughly 12 cm of the lid). When this threshold is reached or exceeded, the ESP32’s onboard LED turns on as a *visual alert. In testing, when the bin was filled above the 80% mark, the LED illuminated clearly (in the case of an RGB LED, it can be set to a bright color like red). Simultaneously, the system sends a **warning message* over Wi-Fi. The Node-RED endpoint receives a JSON payload (for example: {"bin":"Kitchen","fill":85,"status":"Nearly Full"}), which can be displayed on a dashboard gauge and logged with a timestamp. The Telegram bot sends a notification to the configured channel or user, for example: “⚠ Alert: The kitchen trash bin is 85% full. Please empty it soon.” These alerts were verified during demonstrations – the Telegram message arrived within seconds of the bin crossing the threshold, and Node-RED successfully updated its interface. Regular status updates (e.g. periodic messages or Node-RED updates even when the fill level is below the threshold) were also enabled, allowing remote monitoring of the bin level over time. If the sensor ever encounters a read error (for instance, no object detected or an I²C read failure), the system handles it by displaying an error message on the OLED (e.g. “Sensor error”) and skipping that reading; an error flag can also be sent to Node-RED/Telegram so the user knows the data might be momentarily unavailable.
+==== 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|}}
-Overall, the system proved capable of accurately monitoring the bin’s fill level. In a simple test, placing objects inside to different heights yielded the expected distance readings and corresponding fill percentages. The 80% full LED trigger worked as intended, and remote notifications were successfully delivered, demonstrating the viability of the design.
+----
-## Code Summary
+====== 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.
-The firmware follows a typical Arduino structure with setup and loop functions, utilizing the aforementioned libraries to implement the logic. The pseudocode of the system is outlined below:
+<code cpp>
+#include <Wire.h>
+#include <Adafruit_VL53L0X.h>
+#include <U8g2lib.h>
+#include <WiFi.h>
+#include <HTTPClient.h>
+#include <UniversalTelegramBot.h>
-. *Initialization (setup):* The ESP32 initializes serial communication for debugging and configures the I²C bus. The ToF sensor is started (e.g., using lox.begin() and possibly set to continuous ranging mode). The SH1106 display is initialized via U8g2 and a splash or initial message may be shown. Wi-Fi connectivity is then established using the stored SSID/password, and upon success an HTTP client and Telegram bot client are prepared. If any initialization fails (sensor not found, Wi-Fi not connected), the system prints error messages and may indicate this on the OLED (e.g. “WiFi Error” or “Sensor Fail”).
+#define I2C_SDA 8
-. *Main Loop (continuous operation):* The microcontroller continuously measures the distance to the trash. In each cycle, a distance reading is obtained from the VL53L0X sensor (e.g., distance = sensor.readRange()). The code checks for invalid readings (the sensor returns 0 or a timeout if it fails to measure). If a reading is valid, the fill percentage is calculated using the bin’s known height.
+#define I2C_SCL 9
-. *Display Update:* The OLED is refreshed with the new values each cycle. The code clears the display buffer and prints the distance (in centimeters, possibly averaged or filtered for stability) and the fill percentage. This update occurs at a reasonable interval (for example, a few times per second or every few seconds) to keep the display current without flickering.
+#define LED_PIN 2
-. *LED Alert Logic:* The program compares the fill percentage against the predefined threshold (80%). If fill_percent >= 80% and the LED is not already on, the onboard LED is activated (e.g., set to HIGH or in case of an RGB LED, set to a solid color). If the fill drops below the threshold (e.g., after emptying the bin) the LED is turned off. This hysteresis prevents flicker around the threshold boundary.
-. *Networking – Node-RED Update:* The loop periodically (e.g. every fixed interval like 30 seconds, or each significant change) sends an HTTP POST request to the Node-RED server with the latest data. This is done using the HTTPClient library: the bin’s status (distance, fill%, maybe a timestamp) is formatted (often as a JSON string) and posted to a known URL endpoint where Node-RED is listening. The code checks the HTTP response to ensure the data was received.
-. *Networking – Telegram Notifications:* Using the UniversalTelegramBot library, the code sends a Telegram message when certain events occur. Specifically, when the fill crosses the 80% threshold (or reaches 100%), a one-time alert message is sent to notify that the bin is nearly full and should be emptied. Additionally, the system can be configured to send periodic Telegram updates (for example, a daily summary or when the bin gets emptied). The bot communication involves sending an HTTPS request via WiFi to Telegram’s API with the bot token and chat ID.
-. *Error Handling and Loop Delay:* If the distance sensor returns an error (e.g., no valid reading), the code can retry a few times or output an error state for that cycle, ensuring the rest of the loop continues. A short delay or timer is used at the end of each loop iteration to regulate the measurement frequency and avoid flooding the network with too many requests. In practice, readings and updates might be done, for example, once every few seconds for local display and perhaps every minute for remote updates, which is sufficient for a trash bin scenario.
-This logical structure ensures that the device remains responsive and up-to-date, providing both local feedback via display/LED and remote feedback via network. The code is modular, with separate functions handling sensor reading, display output, and network communication, making it easier to maintain or expand.
+#define BIN_HEIGHT_CM 60.0
+#define DISTANCE_OFFSET_CM -3.0
-## Discussion
+// Wi-Fi
+const char* ssid       = "YOUR_SSID";
+const char* password   = "YOUR_PASS";
+// Node-RED endpoint
+const char* alert_url  = "http://YOUR_IP_ADDRESS/bin-alert";
-This smart bin monitoring system demonstrates a practical Internet-of-Things solution for waste management, but there are some limitations and opportunities for improvement. One limitation is that the ToF sensor measures distance at a single point directly below it. If trash is unevenly distributed (e.g. piled higher on one side away from the sensor), the measured distance might not reflect the true highest fill level. In such cases, the bin could be slightly fuller than reported. A possible improvement would be to use multiple sensors or a scanning mechanism (like a servo-mounted sensor) to sample distances at various points, giving a more holistic measurement of fill level. Another limitation is the reliance on Wi-Fi connectivity: if the network is down or the device loses connection, remote updates and alerts will fail. Implementing reconnection logic or an offline indicator (and perhaps storing data to send later) could mitigate this. Additionally, the system currently runs on continuous power; if battery operation is desired, power-saving techniques (like deep sleep between measurements) could be implemented to prolong battery life.
+// Telegram
+const char* telegram_token = "BOT_TOKEN";
+String chat_id = "CHAT_ID";
-There is also room for feature enhancements. For example, adding a weight sensor at the bottom of the bin could provide another metric for fill level (by weight) to complement the distance measurement. The OLED display, while useful, could be supplemented with an audible buzzer for a local alarm when the bin is full, which would be hard to miss. On the software side, the Node-RED integration could be expanded — for instance, to send email notifications or log historical fill data for analysis. The Telegram bot could be made interactive, allowing a user to query the current bin status on-demand.
+U8G2_SH1106_128X64_NONAME_F_HW_I2C display(U8G2_R0, U8X8_PIN_NONE, I2C_SCL, I2C_SDA);
+Adafruit_VL53L0X lox = Adafruit_VL53L0X();
+WiFiClientSecure secured_client;
+UniversalTelegramBot bot(telegram_token, secured_client);
+unsigned long lastAlertTime = 0, lastSignalTime = 0;
+const unsigned long signalInterval = 30000;
+float lastDistance = 0, lastPercentage = 0;
+bool updatesEnabled = true;
+void setup() {
+  Serial.begin(115200);
+  Wire.begin(I2C_SDA, I2C_SCL);
+  // Initialize display
+  display.begin();
+  display.clearBuffer();
+  display.setFont(u8g2_font_ncenB08_tr);
+  display.drawStr(0,10,"Init Display");
+  display.sendBuffer();
+  // Initialize sensor
+  if (!lox.begin()) while (1);
+  pinMode(LED_PIN, OUTPUT);
+  // Connect Wi-Fi
+  WiFi.begin(ssid, password);
+  while (WiFi.status() != WL_CONNECTED) {
+    delay(500);
+    Serial.print('.');
+  }
+  Serial.println("\\nWiFi OK");
+  secured_client.setInsecure();
+}
+void loop() {
+  VL53L0X_RangingMeasurementData_t m;
+  lox.rangingTest(&m, false);
+  if (m.RangeStatus != 4) {
+    float d = m.RangeMilliMeter/10.0 + DISTANCE_OFFSET_CM;
+    float p = constrain(100.0 - (d/BIN_HEIGHT_CM)*100.0, 0.0, 100.0);
+    lastDistance = d; lastPercentage = p;
+    // Update OLED
+    display.clearBuffer();
+    display.setCursor(0,12);
+    display.print("Dist: "); display.print(d,1); display.print("cm");
+    display.setCursor(0,30);
+    display.print("Fill: "); display.print((int)p); display.print("%");
+    int w = map((int)p,0,100,0,120);
+    display.drawFrame(0,45,120,10);
+    display.drawBox(0,45,w,10);
+    display.sendBuffer();
+    // Alert on ≥80%
+    if (p >= 80.0) {
+      digitalWrite(LED_PIN, HIGH);
+      if (millis() - lastAlertTime > 15000) {
+        sendWarning(d, p);
+        lastAlertTime = millis();
+      }
+    } else {
+      digitalWrite(LED_PIN, LOW);
+    }
+  }
+  // Periodic update
+  if (millis() - lastSignalTime > signalInterval) {
+    if (updatesEnabled) sendRegularUpdate(lastDistance, lastPercentage);
+    lastSignalTime = millis();
+  }
+  // Telegram commands
+  static unsigned long lastBot = 0;
+  if (millis() - lastBot > 1000) {
+    int n = bot.getUpdates(bot.last_message_received + 1);
+    while (n) {
+      handleNewMessages(n);
+      n = bot.getUpdates(bot.last_message_received + 1);
+    }
+    lastBot = millis();
+  }
+  delay(500);
+}
+// ... (sendWarning, sendRegularUpdate, handleNewMessages functions)
+</code>
+----
+===== Code Summary =====
+. **Initialization (setup)**
+   - Serial debug +<code>Wire.begin()</code>for I²C
+   - <code>lox.begin()</code> for ToF sensor and OLED splash
+   - Connect to Wi-Fi (SSID/password)
+   - Initialize HTTPClient & Telegram bot
+   - On failure (sensor or Wi-Fi), print/display error
+. **Main Loop**
+   - 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
+   - 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 ======
+''By 32780''
+Our Node-RED instance handles incoming HTTP POSTs at `/bin-alert` and:
+  * Parses JSON (distance, fill_percentage)
+  * Switch: if `fill_percentage ≥ 80` → trigger email/SMS, else log
+  * Dashboard: updates a gauge node
+{{:amc:ss2025:group-t:screenshot_2025-07-29_132917.png?500|}}
+----
+====== 6. Telegram Bot Configuration ======
+''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|}}
+**Commands**:
+  * /start - Start bot
+  * /status - Get current bin fill
+  * /stop - Stop regular update messages
+  * /startupdates - Resume regular updates
+  * /help - Show this message
+----
+====== 7. Results ======
+''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.
+  * **Distance & Fill Readout**
+    - OLED updates in real time:
+      * “Distance: 21.8 cm”
+      * “Fill: 63 %”
+    - Fill percentage = ((60 cm − measured_distance) / 60 cm) × 100 %.
+  * **Visual & Remote Alerts**
+    - 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.
+----
+{{ :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|}}
+----
+====== 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.
+* **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.
+  * **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.
+  * **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.
+----
+====== 9. Conclusion ======
+''By 31706''
+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.
+----
+====== 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/
+{{youtube>2MH0t_iPs9k?}}
-Despite these limitations, the impact of the project is significant for its scale. In a broader context, such a system can reduce the need for manual checks of trash bins and enable more efficient waste collection scheduling. Facilities management in smart buildings or campuses could deploy these sensors on multiple bins and monitor them centrally, ensuring bins are emptied right when needed and never overflow. This not only improves cleanliness and hygiene but can also optimize labor and collection routes, contributing to smarter urban infrastructure. In conclusion, the project achieved its primary goal of creating a functional bin fill-level monitoring device, and it illustrates how low-cost sensors and Wi-Fi connectivity can be leveraged to solve everyday problems in an intelligent way.