Published February 15, 2022 © MIT

Lane Tech PCL - Trash Containment Unit

A trash can lid that seals the garbage from the rest of the world.

IntermediateShowcase (no instructions)7 hours68

Things used in this project

Hardware components

Particle Argon

Solderless Breadboard Half Size

Ultrasonic Sensor - HC-SR04 (Generic)

High Performance Servo

5 mm LED: Red

5 mm LED: Yellow

5 mm LED: Green

Software apps and online services

Particle Build Web IDE

Story

Introduction

This project was intended to address one of my most recurring issues: having lots of hideous trash in my trash can. What is the reasonable solution? Cover it with a lid! Out of sight out of mind, right? Well, the issue was that the lid would require manual opening, so this looked like a job for my home automation project. I decided to build a custom cardboard-prototyped lid which would serve to completely obscure visible trash while also providing an effortless way to insert various detritus. Here is a video of the functional prototype in action:

Project demonstration

As you can see, it works pretty well. The ultrasonic sensor concealed next to the entry flap is used to detect objects that enter the entry area. The sensor is fairly reliable, but it has one caveat: it does not detect non-dense / lighter objects such as tissues. This can be seen demonstrated in this video:

Tissue demonstration

Additionally the lights on the side allow the user to gauge how full the can is at a glance. It utilizes a second ultrasonic sensor located underneath the lid to achieve this.

Fill level demonstration

Process

The process of designing and constructing the can was long but rewarding. I started out by measuring the size of my trash can, the argon, the servo, and then partitioning out a large enough area to hold all the circuitry.

Partitioned design document

Once I had all the dimensions figured out, I moved on and created the base of the lid.

The lid base + ring

Creating the outer ring from cardboard was an interesting but difficult process. I cut evenly spaced scores into one side of a cardboard strip, which caused it to become flexible enough for me to bend into a circle. Once this was done, I cut out the majority of the other cardboard pieces I had designed in my design document.

After that, I began testing code for the ultrasonic sensor and implementing a rudimentary servo-sensor system on my argon, which would eventually function as the entry flap mechanism.

The argon/servo/ultrasonic sensor system

Once I got that working, I began to piece everything together and integrate the argon and its components into the lid itself. I taped the argon and servo into their final positions, and I routed the ultrasonic sensor through a support platform where it would eventually be looking right into the entry area.

The integrated argon circuit

At this point, I also had started working on linking up the fill level LEDs (displayed in the previous image). I cut a hole in the bottom of the lid for the second ultrasonic sensor and linked it up to the argon. Once the LEDs and ultrasonic fill level sensor were fully linked and tested, I routed the LEDs through a cardboard wall, as well as cut a hole in the same wall for the power cord to fit through.

The lid with the argon, components, and fill lights integrated

Once all that was done, I needed to start working on the entry flap before I could put the final walls to close off the lid. I went through many design and testing iterations of the flap because it was a challenge to find a design that was sturdy and reliable. My trash can is mainly used to throw away napkins, bottles, and cans, so I knew the flap needed to be sturdy, but it did not need to support that much weight. Eventually, I landed on a design that utilized two paperclips. I suck each paperclip all the way through the flap, through the holes in the servo attachment, bent around the bottom of the flap, and then I hot glued everything together.

Paperclip entry flap design

In the end, it provided a relatively sturdy platform that I was not worried would easily break. Now that all of the lid components were complete, it was time to finalize the structure. Once I added the fourth and final wall, I also added interior walls to protect the circuitry from any airborne waste.

Interior walls of the lid

Conclusion

After I had completed this project, I had learned a significant amount. Although I had tried to design and plan for everything, I realized that one can't plan for everything, and it is important to be flexible and ready for any obstacle that comes your way. For anyone who is trying to recreate this project, I would try and make larger and more sturdy entry flap. Even though the flap was sufficient for my use case, it would have been a better final product if it had been bigger and supported more weight. I would also ensure that calculated dimensions properly account for cardboard thickness.

Completed product

Trash Can Source Code

#define entryTrigPin 2
#define entryEchoPin 3
#define fillTrigPin 7
#define fillEchoPin 6
#define greenLed1 9
#define greenLed2 10
#define yellowLed1 11
#define yellowLed2 12
#define redLed 13
#define servoData 5

#define fillLevel0 25 // The first threshold that determines when the can starts to qualify as 'filled'
#define fillLevel1 20
#define fillLevel2 15
#define fillLevel3 10
#define fillLevel4 5 // The threshold that determines the most filled the can is allowed to get

#define microsecondsPerSecond 1000000 

Servo lidServo;

bool lidOpen = false;
int fillLevel = 0; // The distance (in cm) between the contents of the trash can and the lid
bool sensorState = false; // false: idle, true: sending
uint64_t lastTime = 0; // Timekeeping variable

void setup()
{
    pinMode(entryTrigPin, OUTPUT);
    pinMode(entryEchoPin, INPUT);
    pinMode(fillTrigPin, OUTPUT);
    pinMode(fillEchoPin, INPUT);
    
    pinMode(greenLed1, OUTPUT);
    pinMode(greenLed2, OUTPUT);
    pinMode(yellowLed1, OUTPUT);
    pinMode(yellowLed2, OUTPUT);
    pinMode(redLed, OUTPUT);
    
    lidServo.attach(servoData);
}

void loop()
{
    // Get and store the current time in microseconds
    uint64_t currentTime = micros();
    
    // If the sensor state is set to idle and the time elapsed since the last sensor
    // pulse is at least one second, begin another sensor pulse
    if (!sensorState && currentTime - lastTime >= microsecondsPerSecond)
    {
        // Trigger both ultrasonic sensors
        digitalWrite(entryTrigPin, HIGH);
        digitalWrite(fillTrigPin, HIGH);
        
        // Update state
        sendingState = true;
        lastTime = currentTime;
    }
    
    // Otherwise if the sensor state is set to sending and 10 microseconds has been
    // elapsed, start listening for the returning ultrasonic waves
    else if (sensorState && currentTime - lastTime >= 10)
    {
        long duration, distance;
        
        // Stop triggering the lid sensor
        digitalWrite(entryTrigPin, LOW);
        
        // Measure the duration of the return wave
        duration = pulseIn(entryEchoPin, HIGH);
        
        // Do some math with the speed of sound to get the distance (in cm) to the detected object 
        distance = (duration / 2) / 29.1;
        
        // Open the lid if the distance is less than 11 cm
        lidOpen = distance < 11;
        
        // Stop triggering the fill sensor
        digitalWrite(fillTrigPin, LOW);
        
        // Measure the duration of the return wave
        duration = pulseIn(fillEchoPin, HIGH);
        
        // Do some math with the speed of sound to get the distance (in cm) to the can contents
        distance = (duration / 2) / 29.1;
        
        // Set the fill level to that distance
        fillLevel = distance;
        
        // Update state
        sensorState = false;
        lastTime = currentTime;
    }

    // Turn on the fill level LEDs based on the measured distance from the bottom
    // ultrasonic sensor. As the trash can fills up, the distance (in cm) will decrease.
    // Here we assign the LEDs to arbitrary fill values based on the height of my trash
    // can (about 1 ft)
    digitalWrite(greenLed1, fillLevel < fillLevel0 ? HIGH : LOW);
    digitalWrite(greenLed2, fillLevel < fillLevel1 ? HIGH : LOW);
    digitalWrite(yellowLed1, fillLevel < fillLevel2 ? HIGH : LOW);
    digitalWrite(yellowLed2, fillLevel < fillLevel3 ? HIGH : LOW);
    digitalWrite(redLed, fillLevel < fillLevel4 ? HIGH : LOW);
    
    // Rotate the servo to match the lidOpen state. The servo will only rotate open
    // if the fill level does not exceed the lowest threshold (not too full)
    lidServo.write(lidOpen && fillLevel >= fillLevel4 ? 50 : 140);
}

Credits

Evan Thompson

1 project • 0 followers

Embed the widget on your own site

Lane Tech PCL - Trash Containment Unit

Lane Tech PCL - Trash Containment Unit

Things used in this project

Hardware components

Software apps and online services

Story

Introduction

Process

Conclusion

Code

Trash Can Source Code

Credits

Evan Thompson

Comments

Related tags