AI-Powered Waste Segregation Bin (dry and wet)

2025

10:16
Quality: HD

Short Description (సంక్షిప్త వివరణ) AI-పవర్డ్ చెత్త విభజన బిన్ అనేది ఆటోమేటెడ్ వ్యవస్థ, ఇది తడి (Wet) మరియు పొడి (Dry) చెత్తను స్వయంచాలకంగా వేరు చేస్తుంది. Arduino Uno మైక్రోకంట్రోలర్, అల్ట్రాసోనిక్ సెన్సార్, మరియు సర్వో మోటార్ సహాయంతో చెత్తను గుర్తించి, సరిగ్గా వేరు చేసి, పర్యావరణాన్ని పరిరక్షించడానికి సహాయపడుతుంది.

Genre: SCIENCE PROJECTS WITH WORKING MODELS IN TELUGU

View Project video

Watch Later

AI-POWERED WASTE SEGREGATION BIN (DRY AND WET)

(AI ఆధారిత తడి & పొడి చెత్త విభజన బిన్)

Brief Description (సంక్షిప్త వివరణ)

Objective (లక్ష్యం)

ఈ ప్రాజెక్ట్ యొక్క ముఖ్య ఉద్దేశ్యం చెత్తను ఆటోమేటెడ్‌గా వేరు చేయడం ద్వారా పర్యావరణాన్ని రక్షించడం. దీనిని స్వచ్ఛత మరియు వ్యర్థ నిర్వహణ వ్యవస్థలో మెరుగుపరచడానికి ఉపయోగించవచ్చు.

Components Needed (కావాల్సిన భాగాలు)

బిన్ నిర్మాణం: ఫోమ్ బోర్డ్ లేదా సన్ బోర్డ్
సెన్సార్ వ్యవస్థ: అల్ట్రాసోనిక్ సెన్సార్
తడి & పొడి చెత్త గుర్తింపు: కాపర్ ప్లేట్లు
కంట్రోల్ యూనిట్: ఆర్డునో ఉనో మైక్రోకంట్రోలర్
విభజన వ్యవస్థ: సర్వో మోటార్
ఆధార పదార్థం: ఫ్లూట్ బోర్డ్
ఎలక్ట్రికల్ కనెక్షన్లు: జంపర్ వైర్లు

Circuit Diagram (సర్క్యూట్ డయాగ్రామ్)

అల్ట్రాసోనిక్ సెన్సార్ చెత్తను గుర్తించి దూరాన్ని కొలుస్తుంది.
కాపర్ ప్లేట్లు తడి మరియు పొడి చెత్తను గుర్తించేందుకు ఉపయోగిస్తాయి.
Arduino Uno ఆ డేటాను ప్రాసెస్ చేసి, సర్వో మోటార్‌ను యాక్టివేట్ చేస్తుంది.
తడి చెత్తను తడి విభాగంలోకి, పొడి చెత్తను పొడి విభాగంలోకి వేరు చేస్తుంది.

Operation (కార్యాచరణ విధానం)

చెత్తను బిన్‌లో వేయగానే, అల్ట్రాసోనిక్ సెన్సార్ దానిని గుర్తిస్తుంది.
కాపర్ ప్లేట్లు తడి మరియు పొడి చెత్త మధ్య తేడాను గుర్తిస్తాయి.
Arduino Uno ప్రాసెస్ చేసి సర్వో మోటార్‌ను యాక్టివేట్ చేస్తుంది.
సర్వో మోటార్ తడి చెత్తను ఒక విభాగంలోకి, పొడి చెత్తను మరో విభాగంలోకి పంపిస్తుంది.

Conclusion (ముగింపు)

ఈ AI ఆధారిత చెత్త విభజన బిన్ తడి మరియు పొడి చెత్తను ఆటోమేటెడ్‌గా వేరు చేసే సమర్థవంతమైన పరిష్కారం. ఇది పర్యావరణాన్ని రక్షించేందుకు మరియు చెత్త నిర్వహణను మెరుగుపరచేందుకు ఉపయోగపడుతుంది.

AI-POWERED WASTE SEGREGATION BIN (DRY AND WET)

(AI ఆధారిత తడి & పొడి చెత్త విభజన బిన్)

Full Project Report (పూర్తి ప్రాజెక్ట్ నివేదిక)

Introduction (పరిచయం)

వ్యర్థాలను సరిగ్గా వేరు చేయడం పర్యావరణ పరిరక్షణకు చాలా అవసరం. సాంప్రదాయంగా చెత్తను వేరు చేయడం చాలా సమయం తీసుకునే ప్రక్రియ. ఈ AI ఆధారిత చెత్త విభజన బిన్ చెత్తను స్వయంచాలకంగా వేరు చేసి, పునర్వినియోగ పరచడం (Recycling) సులభతరం చేస్తుంది.

Components and Materials (భాగాలు మరియు పదార్థాలు)

ఫోమ్ బోర్డ్ లేదా సన్ బోర్డ్ – బిన్ నిర్మాణానికి.
అల్ట్రాసోనిక్ సెన్సార్ – చెత్తను గుర్తించేందుకు.
కాపర్ ప్లేట్లు – తడి మరియు పొడి చెత్తను వేరు చేయడానికి.
Arduino Uno మైక్రోకంట్రోలర్ – మొత్తం వ్యవస్థను నియంత్రించేందుకు.
సర్వో మోటార్ – చెత్తను సరిగ్గా వేరు చేయడానికి.
ఫ్లూట్ బోర్డ్ – అంతర్గత విభజన కోసం.
జంపర్ వైర్లు – ఎలక్ట్రికల్ కనెక్షన్ల కోసం.

Working Principle (పని చేసే విధానం)

అల్ట్రాసోనిక్ సెన్సార్ చెత్తను గుర్తించి దూరాన్ని కొలుస్తుంది.
కాపర్ ప్లేట్లు తడి మరియు పొడి చెత్తను వేరు చేయడానికి ఉపయోగిస్తాయి.
Arduino Uno మైక్రోకంట్రోలర్ డేటాను ప్రాసెస్ చేసి, సర్వో మోటార్‌ను నడిపిస్తుంది.
సర్వో మోటార్ తడి చెత్తను ఒక భాగంలోకి, పొడి చెత్తను మరో భాగంలోకి పంపుతుంది.

Advantages (ప్రయోజనాలు)

✅ ఆటోమేటెడ్ తడి మరియు పొడి చెత్త విభజన.
✅ పునర్వినియోగాన్ని మెరుగుపరచే వ్యవస్థ.
✅ స్వచ్ఛమైన మరియు సులభమైన చెత్త నిర్వహణ.
✅ తక్కువ ఖర్చుతో స్మార్ట్ వెయస్ట్ మేనేజ్మెంట్ పరిష్కారం.

Disadvantages (తప్పుల బిందువులు)

❌ నిరంతర విద్యుత్ అవసరం.
❌ తడి మరియు పొడి చెత్తలో మిశ్రమంగా ఉన్న వస్తువులను వేరు చేయడం కష్టం.
❌ సెన్సార్ పనితీరు గాలి తేమ వల్ల ప్రభావితం కావచ్చు.

Applications (వినియోగాలు)

ఇళ్లలో – హోమ్ వాడకానికి.
కార్యాలయాల్లో – వ్యాపార ప్రదేశాల్లో చెత్త నిర్వహణకు.
స్మార్ట్ సిటీలలో – నూతన నగరాల్లో చెత్త పునర్వినియోగానికి.
పాఠశాలలు & కళాశాలలు – విద్యార్థుల్లో పర్యావరణ అవగాహన పెంచేందుకు.

Future Enhancements (భవిష్యత్ విస్తరణలు)

IoT ఆధారిత చెత్త స్థాయి మానిటరింగ్.
వర్చువల్ డేటా లాగింగ్ ద్వారా చెత్త నిర్వహణను మెరుగుపరచడం.
సోలార్ పవర్‌తో పని చేసే బిన్.

ఈ AI ఆధారిత చెత్త విభజన బిన్ పర్యావరణాన్ని రక్షించేందుకు, తడి మరియు పొడి చెత్తను సమర్థవంతంగా వేరు చేసేందుకు మరియు పునర్వినియోగాన్ని మెరుగుపరచేందుకు ఉపయోగపడే అత్యంత అవసరమైన పరిష్కారం.

AI-POWERED WASTE SEGREGATION BIN (DRY AND WET) 
code: 

#include <Servo.h>
Servo myServo;

// Define pins for ultrasonic sensor
const int trigPin = 9;
const int echoPin = 10;

// Define pin for conducting strip
const int conductingStripPin = 7; // Digital pin to read the conducting strip

// Variables for ultrasonic sensor
long duration;
int distance;

// Function to move the servo slowly
void moveServoSlowly(int targetAngle) {
  int currentAngle = myServo.read(); // Get current angle of the servo
  
  if (targetAngle > currentAngle) {
    for (int angle = currentAngle; angle <= targetAngle; angle++) {
      myServo.write(angle);
      delay(15); // Adjust delay for speed control
    }
  } else {
    for (int angle = currentAngle; angle >= targetAngle; angle--) {
      myServo.write(angle);
      delay(15); // Adjust delay for speed control
    }
  }
}

void setup() {
  // Initialize servo
  myServo.attach(6);
  myServo.write(95); // Start at 90 degrees
  
  // Initialize pins
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  
  // Set the conducting strip pin with an internal pull-up resistor
  pinMode(conductingStripPin, INPUT_PULLUP);
  
  // Begin serial communication for debugging
  Serial.begin(9600);
  Serial.println("System Initialized");
}

void loop() {
  // Trigger the ultrasonic sensor
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Read the echo time
  duration = pulseIn(echoPin, HIGH);

  // Calculate distance
  distance = duration * 0.034 / 2;

  // Output the distance to the Serial Monitor
  Serial.print("Distance: ");
  Serial.print(distance);
  Serial.println(" cm");

  // Check if an object is detected within a certain range (e.g., 10 cm)
  if (distance <= 20) {
    // Read the conducting strip to determine if waste is wet or dry
    int stripState = digitalRead(conductingStripPin);

    // Output the conducting strip state to the Serial Monitor
    if (stripState == LOW) {
      Serial.println("Wet Waste Detected");
      moveServoSlowly(10); // Move servo slowly to 0 degrees
    } else {
      Serial.println("Dry Waste Detected");
      moveServoSlowly(170); // Move servo slowly to 180 degrees
    }

    // Wait for a while to simulate the waste being sorted
    delay(2000);

    // Return the servo to the initial position slowly
    moveServoSlowly(95);
    Serial.println("Servo Returned to 90 Degrees");
  } else {
    Serial.println("No Waste Detected");
  }

  // Small delay before the next loop iteration
  delay(500);
}