Distributeur inverse (RVM) : Kit système de recyclage intelligent DIY

Composants et fournitures

Arduino Mega 2560	×1
Carte NodeMCU ESP8266	×1
Capteur de proximité inductif, 15 mm	×2
Capteur de proximité capacitif, 12 mm	×1
Moteur servo SG90	×2
Écran LCD alphanumérique 16×2	×1
Capteur ultrasonique HC-SR04	×2
Module GPS (générique)	×1
Buzzer piézo	×1
Potentiomètre 100k ohms	×1
Interrupteur poussoir	×1
LED 5 mm rouge	×2
Fils de connexion (générique)	×1
Batterie 12 V	×1
Batterie 9 V	×1
Plaque d'essai (générique)	×2

Outils et machines nécessaires

• Fer à souder
• Multimètre numérique
• Dénudeur et coupe-fils

Applications et services en ligne

• Arduino IDE
• Blynk
• API ThingSpeak

À propos du projet

Motivation

Où finissent les bouteilles en plastique ?

Dans les décharges, flottant sur les océans, les rivières et les trottoirs. On estime qu'il y a 46 000 morceaux de déchets plastiques par mile carré d'océan. Ce plastique tue les animaux, libère des produits chimiques et perturbe les écosystèmes. Chaque bouteille peut mettre jusqu'à 1000 ans à se décomposer, libérant des substances dangereuses durant ce processus. Certaines toxines peuvent causer le cancer et des troubles de la reproduction. L'incinération du plastique génère des émissions toxiques : monoxyde de carbone, chlore, acide chlorhydrique, furannes et nitrites. Malheureusement, le recyclage ne fait que peu de différence : seulement 12 % des 35 milliards de bouteilles utilisées chaque année sont recyclées, ce qui signifie que seulement la moitié de ce que vous mettez dans la poubelle de recyclage est réellement recyclée.

Idée

Une machine intelligente pour l'élimination des déchets plastiques et métalliques est un système qui accepte les bouteilles en plastique et les canettes métalliques pour le recyclage et, en retour, crédite des points sur le portefeuille de l'utilisateur qui recycle. Le distributeur inverse est équipé de capteurs de proximité pour distinguer les différents types de bouteilles, et les points sont gagnés lorsque l'utilisateur entre le code sur le site web. Cette invention concerne la gestion des déchets et le recyclage des bouteilles en plastique et métal dans l'environnement. L'abandon des déchets plastiques et la faible volonté de recycler posent un problème continu pour l'environnement et tous les êtres vivants.

Fonctionnement

Un distributeur inverse (RVM) est un appareil qui accepte les contenants de boissons usagés et rend de l'argent à l'utilisateur (l'inverse du cycle de distribution typique). Ces machines sont populaires dans les lieux où existent des lois obligatoires de recyclage ou une législation sur la consigne.

Les opérations de base : le recycleur place la bouteille/canette vide dans l'ouverture de réception ; le système d'alimentation horizontale permet d'insérer les contenants un par un. Le contenant est ensuite scanné automatiquement à l'aide de capteurs de proximité capacitifs et inductifs. Si la valeur du capteur inductif est 1, l'objet est en plastique ; si la valeur du capteur inductif est 0 et celle du capteur capacitif est 1, l'objet est en métal.

Pour le système de récompense, le RVM distribue des jetons précieux (pièces ou coupons) lors du recyclage. Les coupons sont ensuite utilisés pour échanger des cadeaux au comptoir. Cependant, compte tenu de la sensibilisation aux enjeux environnementaux et de l'objectif de réduire l'usage du papier, l'impression de coupons n'est pas favorisée. Dans notre système proposé, lorsque le plastique est détecté, un code chiffré s'affiche sur l'écran LCD. L'utilisateur doit alors scanner le code QR présent sur la machine pour accéder au site web et échanger ses points en entrant le code obtenu sur l'écran LCD.

Il existe une base de données pour les utilisateurs ayant un compte sur le site du distributeur inverse. Il est obligatoire d'avoir un compte pour se connecter et échanger les points contre le recyclage du plastique.

La machine possède une fonctionnalité supplémentaire : si elle est pleine, les collecteurs de déchets ou les recycleurs sont notifiés via une application. Le niveau de remplissage est surveillé par un capteur ultrasonique et le NodeMCU ; lorsque la machine est pleine, les collecteurs sont informés et la position exacte de la machine est envoyée grâce au GPS.

Code

Tri des déchets

#include <LiquidCrystal.h>
#include <Servo.h>

LiquidCrystal lcd(1, 2, 4, 5, 6, 7);
const int knapp = 3;
int ButtonState = 0;
int oldButtonState = 0;
const int ledPin1 = 10;
const int ledPin2 = 11;
const int buzz1 = 12;
const int buzz2 = 13;
const int plasticsensor = A0;
int metalsensor = A1;
int metalsensor_M = A2;
Servo myservo;
Servo myservo_M;
int pos = 90;
int pos_M = 360;

void setup() {
  pinMode(knapp, INPUT);
  digitalWrite(knapp, LOW);
  lcd.begin(16, 2);
  lcd.clear();
  myservo.attach(9);
  myservo_M.attach(8);
  pinMode(plasticsensor, INPUT_PULLUP);
  pinMode(metalsensor, INPUT_PULLUP);
  pinMode(metalsensor_M, INPUT_PULLUP);
  pinMode(ledPin1, OUTPUT);
  pinMode(ledPin2, OUTPUT);
  pinMode(buzz1, OUTPUT);
  pinMode(buzz2, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  lcd.setCursor(0, 0);
  lcd.print("INSERT METAL ON");
  lcd.setCursor(0, 1);
  lcd.print(" RIGHT SIDE ");
  delay(6000);
  lcd.clear();
  
  int sensor_read = digitalRead(plasticsensor);
  Serial.println("plastic sensor");
  Serial.println(sensor_read);
  
  int sensor_read_m = digitalRead(metalsensor);
  Serial.println("metal sensor1");
  Serial.println(sensor_read_m);
  
  int sensor_read_mm = digitalRead(metalsensor_M);
  Serial.println(sensor_read_mm);
  
  // Détection plastique
  if ((sensor_read == 1) && (sensor_read_m != 1)) {
    for (pos = 90; pos <= 240; pos += 1) {
      myservo.write(pos);
      digitalWrite(ledPin1, HIGH);
      digitalWrite(buzz1, HIGH);
    }
    for (pos = 240; pos >= 90; pos -= 1) {
      myservo.write(pos);
    }
  } else {
    myservo.write(pos);
    digitalWrite(ledPin1, LOW);
    digitalWrite(buzz1, LOW);
  }
  
  // Détection métal
  if ((sensor_read_mm == 1) && (sensor_read == 0)) {
    for (pos_M = 360; pos_M >= 50; pos_M -= 1) {
      myservo_M.write(pos_M);
      digitalWrite(ledPin2, HIGH);
      digitalWrite(buzz2, HIGH);
    }
    for (pos_M = 50; pos_M <= 360; pos_M += 1) {
      myservo_M.write(pos_M);
    }
  } else {
    myservo_M.write(pos_M);
    digitalWrite(ledPin2, LOW);
    digitalWrite(buzz2, LOW);
  }
}

Surveillance du niveau de remplissage

#include "ThingSpeak.h"
#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h>
#include <TinyGPS++.h>
#include <SoftwareSerial.h>

#define BLYNK_PRINT Serial
#define TRIGGER2 5
#define ECHO2 4

WiFiClient client;
static const int RXPin = 4, TXPin = 5;
static const uint32_t GPSBaud = 9600;
unsigned long myChannelField = 1067056;
const int ChannelField = 1;
const char * myWriteAPIKey = "FMV95MD2A1J7Y8SP";

TinyGPSPlus gps;
WidgetMap myMap(V0);
SoftwareSerial ss(RXPin, TXPin);
BlynkTimer timer;

char auth[] = "YVvgHBx9fIM1-yR_2XrGXXkKdIuEmrYL";
char ssid[] = "diksha";
char pass[] = "diksha19";
unsigned int move_index = 1;

void setup() {
  Serial.begin(115200);
  ss.begin(GPSBaud);
  Blynk.begin(auth, ssid, pass);
  pinMode(TRIGGER2, OUTPUT);
  pinMode(ECHO2, INPUT);
  pinMode(BUILTIN_LED, OUTPUT);
  WiFi.mode(WIFI_STA);
  ThingSpeak.begin(client);
}

void loop() {
  if (WiFi.status() != WL_CONNECTED) {
    Serial.print("Attempting to connect to SSID: ");
    Serial.println(ssid);
    while (WiFi.status() != WL_CONNECTED) {
      WiFi.begin(ssid, pass);
      Serial.print(".");
      delay(100);
    }
    Serial.println("\nConnected.");
  }
  
  while (ss.available() > 0) {
    if (gps.encode(ss.read())) {
      Serial.println("GPS Connected");
      if (gps.location.isValid()) {
        float latitude = gps.location.lat();
        float longitude = gps.location.lng();
        Serial.print("LAT: "); Serial.println(latitude, 6);
        Serial.print("LONG: "); Serial.println(longitude, 6);
        ThingSpeak.setField(3, latitude);
        ThingSpeak.setField(4, longitude);
        ThingSpeak.writeFields(myChannelField, myWriteAPIKey);
        Blynk.virtualWrite(V1, String(latitude, 6));
        Blynk.virtualWrite(V2, String(longitude, 6));
        myMap.location(move_index, latitude, longitude, "GPS_Location");
      }
    }
  }
  
  long duration2, distance2;
  digitalWrite(TRIGGER2, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIGGER2, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIGGER2, LOW);
  duration2 = pulseIn(ECHO2, HIGH);
  distance2 = (duration2 / 2) / 29.1;
  
  if (distance2 <= 5) {
    Blynk.notify("Please!! empty the dustbin");
  }
  
  Serial.println("2 ultrasonic Centimeter:");
  Serial.println(distance2);
  Blynk.virtualWrite(V6, distance2);
  ThingSpeak.writeField(myChannelField, ChannelField, distance2, myWriteAPIKey);
  delay(100);
  Blynk.run();
  timer.run();
}

Schéma électrique

Schéma de câblage du circuit disponible dans le projet original.