Poubelle Sensibilisatrice - Sensitizing Bin

by UlysseH in Circuits > Arduino

88 Views, 1 Favorites, 0 Comments

Poubelle Sensibilisatrice - Sensitizing Bin

SensiBIN_Illu.png

En français :

Dans le cadre de ma formation en Licence Sciences et Technologies à l'Institut Villegon-Georges Charpak, je mène un projet d'ingénierie passionnant. Ce projet consiste à concevoir et à construire une poubelle intelligente équipée de capteurs de poids, intégrant des technologies telles que l'ESP32 et le module HX711. L'objectif est de créer un système de gestion des déchets innovant qui peut peser automatiquement les déchets jetés, fournissant ainsi des données précieuses pour encourager une consommation plus responsable et une réduction des déchets.

En effet, les déchets constituent un véritable problème au sein de la chaîne de consommation. En effet, bien que leur production engendre de la pollution, il est nécessaire de les détruire ou de les stocker puisqu'ils sont inutilisables. Cela crée de nouveaux problèmes, qu’ils soient environnementaux ou économiques. En 2019, les déchets ménagers représentaient 10 % des déchets produits en France.

Dans certains pays, comme le Japon, la Corée ou la Suisse, une tarification incitative des déchets a été mise en place. Ce système encourage les usagers à modifier leurs comportements en diminuant la quantité de déchets produits.

Il est donc intéressant de pouvoir suivre la quantité de déchets que nous produisons individuellement, que ce soit pour savoir si nous réduisons la quantité de déchets produits ou pour connaître le montant que nous allons payer après la mise en place de la tarification incitative des déchets.

C'est pourquoi j'ai décidé de créer une poubelle capable de peser automatiquement les déchets que nous jetons. Ensuite, il est possible de consulter sur une application le poids actuel dans la poubelle ainsi que le poids total avec un suivi au cours du temps.

---------------------------------------------------------------------------------------------------------------------------

In English :

As part of my studies in Bachelor of Science and Technology at the Villegon Georges Charpak Institute, I am working on an exciting engineering project. This project involves designing and building a smart trash can equipped with weight sensors, incorporating technologies such as the ESP32 and the HX711 module. The goal is to create an innovative waste management system that can automatically weigh the discarded waste, providing valuable data to encourage responsible consumption and waste reduction.

Indeed, waste is a real problem within the consumption chain. Indeed, although its production causes pollution, it is necessary to destroy or store it since it is unusable. This leads to new problems, whether environmental or economic. In 2019, household waste represented 10% of the waste produced in France.

In some countries, such as Japan, South Korea, and Switzerland, an incentive-based waste pricing system has been implemented. This system encourages users to change their behavior by reducing the amount of waste produced.

It is therefore interesting to be able to track the amount of waste we produce individually, whether to know if we are reducing the amount of waste produced or to find out how much we will pay after the implementation of the incentive-based waste pricing system.

This is why I decided to create a trash can capable of automatically weighing the waste we throw away. Then, it is possible to check the current weight in the trash can as well as the total weight over time through an application.

Supplies

En français :

Matériaux :

Outils :

  • Une scie à métaux
  • 1 pistolet à colle
  • 1 fer à souder et du fil d'étain
  • 1 imprimante 3D (0,72 euro de plastique)
  • 1 ordinateur

Prix total de 90,26 euros (sachant que vous pouvez utiliser votre propre poubelle comme je l'ai fait).

---------------------------------------------------------------------------------------------------------------------------

In English :

Materials:

Tools:

  • 1 hacksaw
  • 1 hot glue gun
  • 1 soldering iron and solder wire
  • 1 3D printer (0,72 euro of plastic)
  • 1 computer

Total cost of 90.26 euros (assuming you can use your own bin like I did).

Préparer La Poubelle / Prepare the Bin

Seau.png
SeauCoupé.jpg
SocleSeau.jpg

En français :

I. Découper le seau

Pour permettre au seau de toucher le fond de la poubelle, il est necessaire de découper la petite bande de plastique qui l'entour (voir la première photo).

A l'aide de la scie à métaux, découpez la bande en longeant le plus possible le bord du seau pour avoir une coupe nette et ains obtenir un bond continu et plat comme sur la seconde image.

II. Placer le socle en plexiglass

Pour que le seau appuie correctement sur les cellules de poids, il faut ajouter une surface dure et plate en dessous.

Pour se faire, collez le disque en plexiglass sous le seau grâce à un pistolet à colle, comme sur la dernière image.

---------------------------------------------------------------------------------------------------------------------------

In English :

I. Cutting the Bucket

To allow the bucket to touch the bottom of the trash can, it is necessary to cut the small plastic strip that surrounds it (see the first photo).

Using a hacksaw, cut the strip as close to the edge of the bucket as possible to achieve a clean cut, resulting in a continuous and flat edge as shown in the second image.

II. Placing the Plexiglass Base

To ensure the bucket properly presses on the load cells, a hard and flat surface needs to be added underneath.

To do this, glue the plexiglass disc under the bucket using a hot glue gun, as shown in the last image.

Montage Electrique / Electrical Assembly

MontageCellule.png
Esp32-Pins.jpg
MontageRéel.jpg

En français :

I. Connexion des cellules de charge :

II. Connexion du module HX711 au ESP32 NodeMCU (avec les fils femelle - femelle) :

  • Connectez la broche DT (Data) du module HX711 à la broche 23 sur l'ESP32 NodeMCU.
  • Connectez la broche SCK (Clock) du module HX711 à la broche 19 sur l'ESP32 NodeMCU.
  • Connectez la broche VCC du HX711 à la broche 3.3V de l'ESP32 NodeMCU.
  • Connectez la broche GND du HX711 à la broche GND de l'ESP32 NodeMCU.

Le schéma des broches de l'ESP32 est sur la deuxième image.

À la fin, vous êtes censé obtenir un montage semblable à l'image 3.

III. Alimentation de l'ESP32 NodeMCU :

  • Connectez l'adaptateur 5V avec un câble micro USB à l'ESP32 NodeMCU pour fournir l'alimentation.
  • Assurez-vous que l'alimentation est capable de fournir suffisamment de courant (au moins 1000mA) pour un fonctionnement stable.

---------------------------------------------------------------------------------------------------------------------------

In English :

I. Connection of the Load Cells:

II. Connection of the HX711 Module to the ESP32 NodeMCU (using female-to-female wires):

  • Connect the DT (Data) pin of the HX711 module to pin 23 on the ESP32 NodeMCU.
  • Connect the SCK (Clock) pin of the HX711 module to pin 19 on the ESP32 NodeMCU.
  • Connect the VCC pin of the HX711 to the 3.3V pin of the ESP32 NodeMCU.
  • Connect the GND pin of the HX711 to the GND pin of the ESP32 NodeMCU.

The pinout diagram for the ESP32 is on the second image.

By the end, you should have a setup similar to image 3.

III. Powering the ESP32 NodeMCU:

  • Connect the 5V adapter with a micro USB cable to the ESP32 NodeMCU to provide power.
  • Ensure that the power supply can deliver sufficient current (at least 1000mA) for stable operation.

Incorporer Le Système Electrique À La Poubelle / Incorporating the Electrical System Into the Bin

Up.jpg
SocleCellule.jpg
Collage.jpg
CollageHX711.jpg

En français :

I. Impression des socles pour les cellules de poids

Les cellules de poids ont besoin d'un support pour fonctionner correctement, il est donc nécessaire de les créer.

II. Placement des cellules de poids dans la poubelle

  • Pour fixer les cellules de poids au fond de la poubelle, vous devez découper la planche de bois en un disque de 20 cm de diamètre, puis le couper en deux pour obtenir deux demi-disques. Cela permettra de ne pas gêner le système de pédale de la poubelle.
  • Placez les cellules de poids dans leurs socles et disposez-les comme sur l'image 2.
  • Fixez-les à l'aide des vis de 13 mm pour obtenir un résultat similaire à celui des images 1 et 2.

Je suggère de placer les cellules de poids plus près du centre de la poubelle (par rapport à ce qui est montré sur l'image 1) pour garantir que tous les capteurs soient en contact avec le fond du seau lors de l'utilisation.

III. Fixation du montage

  • Faites passer les fils rouges des cellules de poids ainsi que le module HX711 à travers le bas de la poubelle.
  • À l'aide du pistolet à colle, collez les demi-disques de bois à la poubelle comme sur l'image 3.
  • Collez le module HX711 comme sur l'image 4, de sorte à le maintenir sous la poubelle sans qu'il touche le sol.
  • Laissez dépasser la carte ESP32 de la poubelle pour y avoir facilement accès et la brancher sur secteur une fois que le système sera opérationnel.

---------------------------------------------------------------------------------------------------------------------------

In English :

I. Printing the bases for the load cells

The load cells need a support to function properly, so it is necessary to create them.

II. Placing the load cells in the trash can

  • To attach the load cells to the bottom of the trash can, you need to cut the wooden board into a 20cm diameter disc and then cut it in half to obtain two half-discs. This will prevent interference with the pedal system of the trash can.
  • Place the load cells in their bases and arrange them as shown in image 2.
  • Secure them using the 13mm screws to achieve a similar result as shown in images 1 and 2.

I suggest placing the load cells closer to the center of the trash can (compared to what is shown in image 1) to ensure that all sensors are in contact with the bottom of the bucket during use.

III. Mounting the assembly

  • Thread the red wires of the load cells and the HX711 module through the bottom of the trash can.
  • Use a hot glue gun to attach the half-discs of wood to the trash can as shown in image 3.
  • Glue the HX711 module as shown in image 4, ensuring it is secured under the trash can without touching the ground.
  • Leave the ESP32 board protruding from the trash can for easy access and to plug it into power once the system is operational.

Downloads

support poubelle.stl

Le Code / the Code

Device.png
MemoryW.png
TotalW.png
Exemple.png

En français :

I. Créer un espace de travail sur Arduino Cloud

  • Branchez la carte ESP32 en USB à votre ordinateur.
  • Allez sur app.arduino.cc et connectez vous à votre compte (ou créez en un).
  • Allez dans la rubrique Devices et cliquer sur + Device en haut à droite.
  • Cliquez sur Third Party device puis selectionnez ESP32 comme type d'appareil en précisant ESP32 Dev Modul comme sur l'image 1.
  • Donnez lui un nom et telechargez le fichier contenant les clefs de sécurité propre à l'appareil.
  • Allez sur la rubrique Things et créez en un nouveau en cliquant sur + Things en haut à droite.
  • Dans "Associated Device", selectionnez le Device que vous venez de créer.
  • Dans "Network", indiquez le nom de votre Wi-Fi, le mot de passe du Wi-Fi ansi que la clef secrète propre au Device.

Le Wi-Fi ne doit pas être créé par votre téléphone ou la carte ESP32 ne pourra pas se connecter aux serveurs d'Arduino Cloud. Je vous conseille d'utiliser le Wi-Fi de votre logement.

  • Ajoutez deux "Cloud Variables" nommées MemoryW et TotalW configurées comme indiqué respectivement sur les images 2 et 3.

II. Incorporer le code

Dans la page "Sketch", collez le code ci-dessous pour remplacer tout ce qui est déjà écrit dans la page .ino.

#include <EEPROM.h>
#include <HX711.h>
#include "thingProperties.h"


HX711 scale;


uint8_t DOUT  = 23; //broche choisie pour les datas
uint8_t CLK = 19; //broche choisie pour la clock


float weight;
float TempoW = 0;
int Deci;
int Unit;
int Cent;
float calibration_factor = Votre valeur; // vous devrez changer la valeur avec celle que vous obtiendrez grâce à la méthode expliquée au III.


void setup() {
  // Initialize serial and wait for port to open:
  Serial.begin(115200);
  EEPROM.begin(512);
  EEPROM.write(0,0);
  EEPROM.write(1,0);
  EEPROM.write(2,0);
  MemoryW = 0;
  TotalW = 0;
  Serial.println("HX711 calibration sketch");
  Serial.println("Remove all weight from scale");
  Serial.println("After readings begin, place known weight on scale");
  Serial.println("Press + or a to increase calibration factor");
  Serial.println("Press - or z to decrease calibration factor");
  scale.begin(DOUT, CLK);
  scale.tare(); //remet la valeur à 0
  long zero_factor = scale.read_average(); //Get a baseline reading
  Serial.print("Zero factor: "); //permet de voir si le facteur de calibration est cohérent
  Serial.println(zero_factor);
  delay(1500) ; // Ce delai donne le temps d'attendre un Serial Monitor sans bloquer si rien n'est trouvé


  // Defined in thingProperties.h
  initProperties();


  // Connect to Arduino IoT Cloud
  ArduinoCloud.begin(ArduinoIoTPreferredConnection);
  
  /*
     The following function allows you to obtain more information
     related to the state of network and IoT Cloud connection and errors
     the higher number the more granular information you’ll get.
     The default is 0 (only errors).
     Maximum is 4
 */
  setDebugMessageLevel(4);
  ArduinoCloud.printDebugInfo();
}


void loop() {
  ArduinoCloud.update();
  // Your code here 
  scale.set_scale(calibration_factor);
  Serial.println("Reading: ");
  weight = (scale.get_units(20));
  if (weight<0){
    weight=0.00;
  }
  if (weight < MemoryW){
    delay(1000);
    weight = (scale.get_units(20));
    if (weight <= 0) {// vérifie si la valeur moyenne est inférieure à 0
      if (TempoW > MemoryW);{
        MemoryW = TempoW;
      }
      Serial.print("MemoryW : ");
      Serial.println(MemoryW);
      Serial.print("TotalW : ");
      Serial.println(TotalW);
      TotalW = float(int(MemoryW*100))/100 + float(EEPROM.read(0))/100 + float(EEPROM.read(1)) + float(EEPROM.read(2)*100); // create new TotalW value
      Cent = int(TotalW/100);
      Serial.print("Cent : ");
      Serial.println(Cent);
      Unit = int(TotalW) - 100*Cent;
      Serial.print("Unit : ");
      Serial.println(Unit);
      Serial.print("Deci : ");
      Serial.println(Deci);
      Deci = int(TotalW*100) - 100*Unit - 1000*Cent;
      EEPROM.write(2,Cent); //enregistre les centaines en mémoire
      EEPROM.write(1,Unit); //enregistre les uinités en mémoire
      EEPROM.write(0,Deci); //enregistre les décimales en mémoire
      EEPROM.commit(); //rend les changement en mémoire permanent
      Serial.print("Somme : ");
      Serial.println(TotalW);
      MemoryW = 0;
      TempoW = 0;
      delay(20000); //donne le temps aux capteurs de retourner à 0
    }
    else if (MemoryW > weight){
      TempoW = MemoryW;
      MemoryW = weight;
    }
  }
  if (MemoryW < weight){
    TempoW = MemoryW;
    MemoryW = weight;
  }
  TotalW = float(EEPROM.read(0))/100 + float(EEPROM.read(1)) + float(EEPROM.read(2)*100);
  Serial.print("Kilogram :");
  Serial.print( MemoryW); 
  Serial.println(" Kg");
  Serial.print(" Poids total :");
  Serial.print( TotalW); 
  Serial.println(" Kg");
  Serial.print(" calibration_factor : ");
  Serial.print(calibration_factor);
  Serial.println();
  Serial.println(" ");
  delay(1000);  //Delai avant de refaire les mesures
}

III. Obtenir le facteur de calibration

Le facteur de calibration (calibration_factor) peut varier. il est necessaire que vous le mesuriez avec votre montage.

  • Retourner dans "Home" sur le site de Arduino Cloud.
  • Allez dans "Sketches" et créez un nouveau sketches en cliquant sur le bouton "Create" en haut à droite.
  • Selectionnez le Device correspondant à la carte ESP32 de la poubelle branchée à l'ordinateur.
  • Allez dans "Exemples" et selectionnez dans "From Libraries" l'exemple HX_calibration dans la catégorie HX711 (voir l'image 4).
  • Changez les valeurs 6 et 7 ligne 12 et 13 par respectivement les valeurs 23 et 19.
  • Televersez le code en cliquant sur la flèche et suivez les différentes étapes pour obtenir le facteur de calibration (les poids doivent être donnés en gramme). Cliquez sur "Serial Monitor" pour visualiser ce que vous envoie la carte ESP32.
  • Allez dans dans votre "Thing" et changez la valeur du facteur de qualibration qui se trouve ligne 15 sur la page .ino.
  • Televersez le code vers la carte ESP32 en cliquant sur la flèche.

---------------------------------------------------------------------------------------------------------------------------

In English :

I. Create a workspace on Arduino Cloud

  • Connect the ESP32 board to your computer via USB.
  • Go to app.arduino.cc and log in to your account (or create one).
  • Navigate to the "Devices" section and click on "+ Device" in the top right corner.
  • Click on "Third Party device" and then select "ESP32" as the device type, specifying "ESP32 Dev Module" as shown in image 1.
  • Give it a name and download the file containing the device's security keys.
  • Go to the "Things" section and create a new one by clicking on "+ Things" in the top right corner.
  • In "Associated Device," select the device you just created.
  • In "Network," enter the name of your Wi-Fi network, the Wi-Fi password, and the device-specific secret key.

The Wi-Fi network should not be created by your phone, or the ESP32 board will not be able to connect to Arduino Cloud servers. I recommend using your home Wi-Fi network.

  • Add two "Cloud Variables" named MemoryW and TotalW configured as shown in images 2 and 3.

II. Incorporate the code

In the "Sketch" page, paste the code below to replace everything already written in the .ino page.

#include <EEPROM.h>
#include <HX711.h>
#include "thingProperties.h"


HX711 scale;


uint8_t DOUT  = 23;//for esp32
uint8_t CLK = 19;//for esp32 


float weight;
float TempoW = 0;
int Deci;
int Unit;
int Cent;
float calibration_factor = Your value; //you will have to put your calibration factor here after following the steps in section III.


void setup() {
  // Initialize serial and wait for port to open:
  Serial.begin(115200);
  EEPROM.begin(512);
  EEPROM.write(0,0);
  EEPROM.write(1,0);
  EEPROM.write(2,0);
  MemoryW = 0;
  TotalW = 0;
  Serial.println("HX711 calibration sketch");
  Serial.println("Remove all weight from scale");
  Serial.println("After readings begin, place known weight on scale");
  Serial.println("Press + or a to increase calibration factor");
  Serial.println("Press - or z to decrease calibration factor");
  scale.begin(DOUT, CLK);
  scale.tare(); //Reset the scale to 0
  long zero_factor = scale.read_average(); //Get a baseline reading
  Serial.print("Zero factor: "); //This can be used to remove the need to tare the scale. Useful in permanent scale projects.
  Serial.println(zero_factor);
  delay(1500);  // This delay gives the chance to wait for a Serial Monitor without blocking if none is found


  // Defined in thingProperties.h
  initProperties();


  // Connect to Arduino IoT Cloud
  ArduinoCloud.begin(ArduinoIoTPreferredConnection);
  
  /*
     The following function allows you to obtain more information
     related to the state of network and IoT Cloud connection and errors
     the higher number the more granular information you’ll get.
     The default is 0 (only errors).
     Maximum is 4
 */
  setDebugMessageLevel(4);
  ArduinoCloud.printDebugInfo();
}


void loop() {
  ArduinoCloud.update();
  // Your code here 
  scale.set_scale(calibration_factor);
  Serial.println("Reading: ");
  weight = (scale.get_units(20));
  if (weight<0){
    weight=0.00;
  }
  if (weight < MemoryW){
    delay(1000);
    weight = (scale.get_units(20));
    if (weight <= 0) {// check if average weight is negative (negatives become 0)
      if (TempoW > MemoryW);{
        MemoryW = TempoW;
      }
      Serial.print("MemoryW : ");
      Serial.println(MemoryW);
      Serial.print("TotalW : ");
      Serial.println(TotalW);
      TotalW = float(int(MemoryW*100))/100 + float(EEPROM.read(0))/100 + float(EEPROM.read(1)) + float(EEPROM.read(2)*100); // create new TotalW value
      Cent = int(TotalW/100);
      Serial.print("Cent : ");
      Serial.println(Cent);
      Unit = int(TotalW) - 100*Cent;
      Serial.print("Unit : ");
      Serial.println(Unit);
      Serial.print("Deci : ");
      Serial.println(Deci);
      Deci = int(TotalW*100) - 100*Unit - 1000*Cent;
      EEPROM.write(2,Cent); //store hundreds values and above
      EEPROM.write(1,Unit); //store units and multiples of ten
      EEPROM.write(0,Deci); //store decimal values
      EEPROM.commit(); //make memory permanent
      Serial.print("Somme : ");
      Serial.println(TotalW);
      MemoryW = 0;
      TempoW = 0;
      delay(20000); //wait for the captor to return to a stable value
    }
    else if (MemoryW > weight){
      TempoW = MemoryW;
      MemoryW = weight;
    }
  }
  if (MemoryW < weight){
    TempoW = MemoryW;
    MemoryW = weight;
  }
  TotalW = float(EEPROM.read(0))/100 + float(EEPROM.read(1)) + float(EEPROM.read(2)*100);
  Serial.print("Kilogram :");
  Serial.print( MemoryW); 
  Serial.println(" Kg");
  Serial.print(" Poids total :");
  Serial.print( TotalW); 
  Serial.println(" Kg");
  Serial.print(" calibration_factor : ");
  Serial.print(calibration_factor);
  Serial.println();
  Serial.println(" ");
  delay(1000); //Delay before repeating measurement
}

III. Obtain the Calibration Factor

The calibration factor (calibration_factor) may vary. You need to measure it with your setup.

  • Go back to "Home" on the Arduino Cloud website.
  • Go to "Sketches" and create a new sketch by clicking on the "Create" button in the top right corner.
  • Select the Device corresponding to the ESP32 board connected to the trash can and your computer.
  • Go to "Examples" and select "HX_calibration" from "From Libraries" under the HX711 category (see image 4).
  • Change the values 6 and 7 on lines 12 and 13 to 23 and 19, respectively.
  • Upload the code by clicking on the arrow and follow the steps to obtain the calibration factor (weights should be given in grams). Click on "Serial Monitor" to visualise what the ESP32 board is sending you.
  • Go to your "Thing" and change the calibration factor value, which is on line 15 of the .ino page.
  • Upload the code to the ESP32 board by clicking on the arrow.

L'App / the App

vALUE.png
Gauge.png
Chart.png

En français :

Pour ce projet, nous allons utiliser une fonctionnalité disponible sur Arduino Cloud pour visualiser nos données en temps réel. Pour ce faire :

  • Lorsque vous revenez à "Home" sur Arduino Cloud, cliquez sur "Dashboards" et créez-en un nouveau en cliquant sur "+Dashboards" en haut à droite.
  • Nommez votre nouveau tableau de bord et ajoutez une description si vous le souhaitez.
  • Cliquez sur le tableau de bord nouvellement créé pour l'ouvrir.
  • Ajoutez quatre widgets (Valeur, Jauge, Graphique et Note adhésive) à votre tableau de bord. Pour ce faire, cliquez sur "+ Ajouter" et sélectionnez les widgets appropriés.
  • Pour les widgets Valeur, Jauge et Graphique, modifiez-les comme sur les images 1, 2 et 3, respectivement, en cliquant sur les trois points puis sur "Modifier les paramètres" pour chacun.
  • Assurez-vous de configurer chaque widget en le liant à la variable Cloud correspondante. Cela vous permettra de voir les données en temps réel de votre poubelle basée sur ESP32.
  • Mettez ce lien sur le widget Note adhésive : "Accueil | Sensibin (ulyssehschool.wixsite.com)". Ce site Web vous permet de comparer vos résultats avec des statistiques et d'obtenir des conseils pour produire moins de déchets.

---------------------------------------------------------------------------------------------------------------------------

In English :

For this project, we will be using a functionality available on Arduino Cloud to visualize our data in real-time. To do so:

  • When you return to "Home" on Arduino Cloud, click on "Dashboards" and create a new one by clicking on "+Dashboards" in the top right corner.
  • Name your new dashboard and add a description if desired.
  • Click on the newly created dashboard to open it.
  • Add four widgets (Value, Gauge, Chart, and Sticky Note) to your dashboard. To do this, click on "+ Add" and select the appropriate widgets.
  • For the Value, Gauge, and Chart widgets, modify them as in images 1, 2, and 3, respectively, by clicking on the three dots and then "Edit Settings" for each.
  • Be sure to configure each widget by linking it to the corresponding Cloud Variable. This will allow you to see real-time data from your ESP32-based trash can.
  • Put this link on the Sticky Note widget: 'Accueil | Sensibin (ulyssehschool.wixsite.com)'. This website allows you to compare your results with statistics and obtain tips to produce less trash.

Utiliser La Poubelle / Use the Bin

En français :

Maintenant que l'objet est construit et le software fonctionnel, il ne reste plus qu'à le démarrer.

  • Branchez la carte ESP32 à une prise secteur grâce prise 5V avec un cable micro USB.
  • Appuyez sur le bouton Reset.
  • Regardez sur votre Dashboard Arduino les données obtenues par la poubelle.

---------------------------------------------------------------------------------------------------------------------------

In English :

Now that the object is built and the software is functional, all that's left is to start it up.

  • Plug the ESP32 board into a power outlet using the 5V adapter with a micro USB cable.
  • Press the Reset button.
  • Check your Arduino Dashboard for the data obtained by the trash can.