Published March 30, 2024 © GPL3+

Smart Trash Buddy

Community trash pickups can be optimized better using Smart Trash Buddy

IntermediateFull instructions providedOver 1 day797

1st Place

The Future of Resilience Contest

Things used in this project

Hardware components

Microchip AVR-IoT WG Development Board

SparkFun Distance Sensor Breakout - 4 Meter, VL53L1X

SparkFun Triple Axis Digital Accelerometer Breakout - ADXL313 (Qwiic)

Battery, 3.7 V

Software apps and online services

Arduino IDE

Amazon Web Services AWS IoT

Hand tools and fabrication machines

3D Printer (generic)

Story

Garbage Pickups

Usually, there is a certain day for trash pickups in different areas. Let's say the day that there is supposed to be a trash pickup, not a lot of people in the area have much trash in their bin, but there is more trash in other areas where their trash day is some other day. That makes the trash pickup on that day unbeneficial. There needs to be a better way to optimize the pickups to be faster and get to the houses that are more needed of a trash pickup.

Littering is also another concern when it comes to garbage. If the dumpster falls, that can create a big mess really quickly with birds taking the trash and winds blowing it in different directions. But since it is a public dumpster, it is unlikely that someone would bother to pick it up. 🚮.

Trash route optimization

Optimizing trash routes involves using some types of distance sensors to measure the level of trash in each can. This data is then processed and used with an algorithm to optimize trash pickup routes, making sure that the fullest cans are taken first. Additionally, accelerometers can be used in a way to detect if a trash can has fallen over. All of this sensor data is stored in a dashboard, providing real-time updates for authorities, allowing for efficient and effective waste management.

Littering

When litter is left on the ground, it can be carried by wind and water, ultimately ending up in natural habitats such as rivers, streams, and oceans. This can harm wildlife, contaminate water sources, and degrade the overall beauty of the environment. Additionally, litter can take a long time to decompose, contributing to pollution and creating hazards for animals and humans.This is more applicable for urban areas or cities such as New York and Boston, where there are apartments that have a big dumpster for everyone. Properly securing trash in cans and disposing of it responsibly can help reduce these negative effects. If it is known that the trash can tips over after a certain point, then it will notify the authorities via some form of SMS.

Ideal Concept

Distance Sensor - Using a sensor to be able to tell how much trash is in the can would be useful to tell who needs a pick up more urgently than others. There would also need to be an algorithm to makethe routings quicker.

Accelerometer - A sensor that can tell if the trash can is tipping over a threshold, then will notify the authorities to take further action as soon as possible.

Real Time Data - I might not have enough time to work on this with the time left in the contest, but I might still add a dashboard which is a map of all the devices and the quickest route that the algorithm chooses for pickup.

I drew this diagram from Procreate

This is kind of a diagram of how my project works in short. There is a phone to the right which represents the notifications that will be sent when the can has fallen. There will also be a dashboard that will have the trash percentage for all of the devices on a map.

Introducing Smart Trash Buddy

I was thinking of using either an ultrasonic sensor or Time of Flight, but since ultrasonic sensor is based on sound and different materials that could come from the trash would affect the sensor readings to not make it accurate. Time of Flight sensor is based on light, and since this device will go inside the trash can, it is not going to matter since it is already dark. So using the Time of Flight sensor, I am able to get a percentage of how much trash there is in each can. Then using a certain algorithm, I can optimize the pickup to have the shortest route based off of cans that need emptying first.

Using the accelerometer, I can be able to determine once I set a threshold, if the trash can has fallen.

All of this sensor data will be saved in a dashboard, which is a map of all the devices in the area. The authorities will have real time data just from the dashboard, since the data will be refreshing every few minutes.

SIM Card Activation

The very first step is to set up the sim in order for our board to connect to internet using cellular.

Make sure you first have noted down the number on your card, you will be needing that in later steps. Then you can go ahead and put the card in the back of the board in this orientation:

Once you inserted the card in your board, make sure you attach the antenna.

Now that you have gotten through this first step of the hardware, follow this tutorial for more on how to register the sim card. This is what I followed and it is very straightforward.

Application architecture

IoT Core

The data is being sent through Iot Core and Lambda will call for the IoT Rule to send the data to AppSync, which I will explain later. Then from AppSync, the data will then be saved in DynamoDB for for later references.

AppSync

AppSync is used for data communication between data and the cloud. AppSync is built on GraphQL and backed by DynamoDB. For the route optimization, I have used AWS Location Services.

Frontend

My dad helped me with this part, since I am still learning how to create a frontend. We are using React to create the frontend, which is the dashboard where I will have all the devices on a map.

optimized route

Project Explanation And Demo

Limitations

The memory footprint was low, so I couldn't be able to use any machine learning models to tell if the trash can is falling, it would have made it a little easier.

Code

TrashBuddyV1

#include <Wire.h>
#include "SparkFun_VL53L1X.h"
#include <SparkFunADXL313.h>
#include <log.h>
#include <ecc608.h>
#include <led_ctrl.h>
#include <lte.h>
#include <mqtt_client.h>
#include <low_power.h>

#define SHUTDOWN_PIN 2
#define INTERRUPT_PIN 3

SFEVL53L1X distanceSensor;
ADXL313 myAdxl;

const char MQTT_SUB_TOPIC_FMT[] PROGMEM = "smarttrash/%s/sensors";
const char MQTT_PUB_TOPIC_FMT[] PROGMEM = "smarttrash/%s/sensors";
const char AWS_PAYLOAD_FMT [] PROGMEM = "{\"d\": %f, \"acc\": %f, \"bat\":%f}";

char mqtt_sub_topic[128];
char mqtt_pub_topic[128];
char aws_payload_data[128];

bool initTopics() {
    ATCA_STATUS status = ECC608.begin();

  if (status != ATCA_SUCCESS) {
    Log.errorf(F("Failed to initialize ECC, error code: %X\r\n"), status);
    return false;
  }

  // Find the thing ID and set the publish and subscription topics
  uint8_t thing_name[128];
  size_t thing_name_length = sizeof(thing_name);

  status = ECC608.readProvisionItem(AWS_THINGNAME, thing_name, &thing_name_length);

  if (status != ATCA_SUCCESS) {
    Log.errorf(
      F("Could not retrieve thingname from the ECC, error code: %X\r\n"),
      status);
    return false;
  }
  Log.infof(F("Thing name %s\r\n"), thing_name);

  snprintf_P(mqtt_sub_topic,
             sizeof(mqtt_sub_topic),
             MQTT_SUB_TOPIC_FMT,
             thing_name);
  snprintf_P(mqtt_pub_topic,sizeof(mqtt_pub_topic),MQTT_PUB_TOPIC_FMT,thing_name);

  return true;
}

void setup() {
  
  LedCtrl.begin();
  LedCtrl.startupCycle();

  Log.begin(115200);
  Log.info(F("Starting HTTP Get Time Example\r\n"));

  Wire1.begin();
  
  if (distanceSensor.begin(Wire1) != 0) //Begin returns 0 on a good init
  {
    while (1)
      ;
  }
  
  if (myAdxl.begin(0x1D , Wire1) == false) //Begin communication over I2C
  {

    while (1); //Freeze
  }
  
  Log.info("Sensor initialized");
  myAdxl.measureModeOn();
  
  LowPower.configurePowerDown();

  LedCtrl.on(Led::USER);
  Lte.begin();
  Log.infof("Connected to operator: %s\r\n", Lte.getOperator().c_str());

}

void loop() {
  LedCtrl.toggle(Led::DATA);
  distanceSensor.startRanging();
  while (!distanceSensor.checkForDataReady())
  {
    delay(1);
  }
  
  int distance = distanceSensor.getDistance(); //Get the result of the measurement from the sensor
  distanceSensor.clearInterrupt();
  distanceSensor.stopRanging();
  float distanceInches = distance * 0.0393701;
  double totalAcc = 0;
  float voltage = LowPower.getSupplyVoltage();

  Log.infof(F("Distance(inch): %f \r\n"), distanceInches);
 // Log.infof(F("%f \r\n"), distanceInches);
  
  
  if(myAdxl.dataReady()){
    myAdxl.readAccel(); 
      int x = myAdxl.x ; int y= myAdxl.y ; int z= myAdxl.z;
      Log.infof(F("X: %d Y: %d Z: %d \r\n"), x,y,z);
      

     totalAcc = sqrt(pow(x,2) + pow(y,2)+ pow(z,2));
     Log.infof(F("Movement: %f \r\n"), totalAcc);
  }
  


if (initTopics()) {
    delay(500);
    Log.infof(F("Initialization of AWS was successful"));
    
    if (MqttClient.beginAWS()) {
      Log.infof(F("Connected to AWS"));
      delay(500);
      snprintf_P(aws_payload_data,
                 sizeof(aws_payload_data),
                 AWS_PAYLOAD_FMT,
                 distanceInches, totalAcc, voltage);
      const bool published_successfully =
      MqttClient.publish(mqtt_pub_topic, aws_payload_data);

      if (published_successfully) {
        Log.infof(F("Published successfully"));
      }

    } else {
      Log.infof(F("MQTT connect failed"));
      LedCtrl.on(Led::ERROR);
      delay(5000);

    }
  } else {
    Log.infof(F("Initialization of AWS  failed"));
  }

  MqttClient.end();
  LowPower.powerDown(5*60);

  
}

Credits

Sashrika Das

4 projects • 32 followers

I am a 9th grade student, passionate about technology.

Thanks to Mithun Das.

Comments

Awards

1st Place

The Future of Resilience Contest

Smart Trash Buddy