Overview

Every school has the same three bins and the same problem. Someone stands over garbage, recycling and organics holding a coffee cup with a plastic lid and a paper sleeve, and puts the whole thing in whichever bin is closest. One wrong item in the organics bin can send the whole bag to landfill. The signs above the bins do not fix this, because nobody reads signs while holding trash.

This project puts a camera above a small tray. Set the item down, the camera looks at it, a light comes on over the bin it belongs in, and a short message says why: lid off, cup in organics, lid in recycling. The person learns the rule at the moment they need it. The system does not sort the trash. The person still does. The system just makes the right choice the obvious one.

It is three projects in one. A research project, because you cannot classify waste until you know your hauler’s rules and what people at your school actually throw out. A machine-learning project, because the classifier is only as good as the photos you train it on. And a product design project, because a camera in a hallway needs a housing that survives, an interaction that people understand in one second, and a privacy story you can defend.

Assessment

Criterion Developing Proficient Exemplary
Waste audit Rules copied from a website, no counts Hauler’s rules confirmed, one station audited, top contaminants counted from the bins Audit shapes the class list and the dataset; the five hardest items are tested on purpose
Dataset and model Few photos, one background, no test set 60+ per class at the station, varied angles and lighting, confusion matrix from held-out photos Weak classes found from the matrix and fixed with more data; model handles the cup-lid-sleeve case
Interaction design Lights with no explanation, no unsure state State diagram covers idle, result, unsure and timeout; a first-time user understands it unassisted Unsure state teaches the rule; message wording tested and revised with users
Hardware and code Works on the bench when someone helps it Runs unattended for a school day, recovers from a power cut, code in a repo with a README Boot-to-running with no keyboard; logs counts (not images) for the test record
Housing Loose parts, visible wiring, blocks the bins Mounts without modifying the station, wiring hidden, camera fixed at a repeatable height and angle Looks like a product; survives being bumped; tray colour and lighting chosen to help the classifier
Testing and privacy Demonstrated once on the bench Three-day install, before-and-after sort rates, a v2 change from the data, notice posted Measurable improvement in correct sorting; the notice answers every question users actually asked

The model’s accuracy on the bench matters less than the correct-sort rate at the station. A 95% classifier nobody understands loses to an 85% classifier with a clear unsure state.

Steps

Week 1: Audit the station

  1. Pick one waste station your team can reach every day. Photograph it as it is. Read the signs and note whether they match the hauler’s current rules; they often do not.
  2. Find the hauler’s rules. Municipal or contracted, they publish a list. Write the three-bin list for your school in plain language, one item per line, and get someone from facilities to confirm it.
  3. Audit the bins. With gloves and a tarp, sort one day’s contents from each bin into right and wrong. Count and photograph. Repeat once more on a different day. Record the five items most often in the wrong bin.
  4. Write the class list. Start with the hauler’s three bins. Decide now how you will handle multi-part items: a cup with a lid is two answers, and the system has to say so.
  5. Sketch three ways the station could tell someone which bin: lights, a screen, a projected arrow, a sound. Pick one direction and defend it in a paragraph.

Week 2: Build the dataset

  1. Set up the photo rig where the camera will actually live: a fixed height above a fixed tray, in the hallway’s real light. If the final camera will be a Pi camera, shoot with that camera, not a phone.
  2. Collect items. Clean examples of each class from the sample box, then dirty examples from the audit. Aim for the real mix: the crumpled, the half-full, the sleeve still on the cup.
  3. Photograph at least 60 per class. Rotate the item, flip it, move it around the tray, shoot with the hallway lights on and off, with a hand entering and leaving frame. Add an empty tray class so the model knows idle.
  4. Hold back one in five photos, chosen at random, as the test set. Do not look at them again until the model is trained.
  5. Label carefully. One wrong label in the organics folder costs more than ten missing photos.

Week 3: Train and measure

  1. Train in Teachable Machine (image project, export to TensorFlow Lite or TensorFlow.js) or Edge Impulse (which will also export directly for an ESP32-CAM). Default settings first.
  2. Run every held-out photo through the model and fill in a confusion matrix: rows are the true class, columns are what the model said. The diagonal is right; everything else is a story.
  3. Read the matrix. Where does organics get called garbage? Photograph twenty more of exactly that item and retrain. Repeat until the worst class is above 85% on held-out photos, or you can explain why it cannot be.
  4. Set a confidence threshold. Below it, the answer is unsure. Pick the threshold from the test set: the point where being wrong starts to happen more than being unsure is annoying.
  5. Run the model live on a laptop with the webcam on the rig. Try the five hardest items from the audit. Write down what happens.

Week 4: Design the interaction and the hardware

  1. Draw the state machine. Idle (tray empty) → item detected → classifying → result (which bin, one line of why) → hold for 4 seconds or until the tray is empty → idle. Add unsure and timeout. Every arrow has a trigger.
  2. Decide what each state looks and sounds like. One light over one bin is the minimum. A short message on a small display does the teaching. A sound is optional and should be quiet; this is a hallway.
  3. Choose the platform. A Raspberry Pi with a camera module runs a TensorFlow Lite model and drives LEDs from GPIO. An ESP32-CAM with an Edge Impulse export is cheaper and simpler but slower and lower resolution. Either way, the outputs can be a separate Arduino Nano listening over serial, which keeps the wiring simple.
  4. Wire it on the bench: camera, board, LEDs over three positions, display, power. Get the state machine running with the model before any enclosure exists.
  5. Make it boot to running. Pull the power, plug it back in, and it should be classifying within a minute with no keyboard or screen attached.

Week 5: Housing and install

  1. Measure the station. Where can a tray sit so people use it without blocking the bins? How high does the camera need to be to see the whole tray and nothing else? Where can power come from?
  2. In Fusion, model the camera, board, display and LEDs as reference bodies from measured dimensions. Design a camera pod, an arm, a tray with a lip, and a signage panel around them. Parameters for camera height, tray size and mounting offsets.
  3. Design for the build: pod and brackets 3D-printed, oriented for strength where the arm meets the pod; signage panel laser-cut with the notice engraved; all wiring inside or clipped along an edge.
  4. Print, cut, assemble, fit the electronics. Cable-manage it. Tug on everything.
  5. Post the privacy notice, mount the system, power it, and leave it. Photograph the station on day one.

Week 6: Test, measure, revise

  1. Run the install for at least three full days. Log counts only: how many items classified, how many unsure, which class. Watch the station for twenty minutes at a busy time each day, from far enough away that people ignore you. Write down what they do.
  2. Audit the bins again, the same way as week 1. Compare the wrong-item count before and after.
  3. Sort what went wrong into two lists: things the model got wrong, and things people did anyway. They have different fixes. One is more photos; the other is the message wording, the light, or the placement.
  4. Make one v2 change from the data and run it for one more day.
  5. Hand in the test record, the repo, the Fusion file and the station, and present the before-and-after numbers to facilities. If it worked, ask them what it would take to keep it there.

Stretch options