Smartbin hat

smartbin

a sorting head that drops into a normal trash can and puts recyclables in the right side by itself.

demo video: https://www.youtube.com/shorts/8E3T3RMJy3o

what it does

you drop something on the pan. the load cell feels the weight change, the camera photographs the item, and a small neural net running on a pi zero w decides what it is. a servo tilts the pan and the item slides into the recycling side or the trash side. if the net is not sure, it goes to trash.

why

• public recycling bins get contaminated really easily
• if enough non-recyclable stuff ends up in one, the facility can reject the whole load, so all of it goes to landfill anyway
• basically every recycling project i've seen is an app that tells you which bin to use
• i wanted the bin to just do it, so the person doesn't have to care

how it works

item lands on the pan
   -> load cell reading rises above the threshold and settles
   -> camera captures a frame
   -> numpy cnn returns one of 7 classes plus a confidence
   -> the weight nudges the result (a 600 g "paper" is unlikely)
   -> jurisdiction file maps the class to recycle or trash
   -> below the confidence threshold it goes to trash
   -> "no_object" means a false trigger, so the pan stays level
   -> servo tilts, item slides, pan returns level, scale re-zeroes
   -> event written to sqlite, served as json by a small api

the mapping lives in firmware/config/jurisdiction.yaml, so a different county's rules are a config change.

hardware

the full parts list with prices is BOM.csv.

the board

65 x 45 mm, 2 layers, pi zero hat footprint. fully routed, ground plane poured, drc clean.

• the hx711 runs at 3.3 v, not 5 v, so the gpio can read it without level shifting
• the two grounds meet at exactly one point, so a stalling servo cannot brown out the pi
• the servo is on gpio12 because that pin is a hardware pwm channel

source files are in PCB/: .kicad_pro, .kicad_sch, .kicad_pcb, schematic.pdf, and gerbers.zip.

the mechanics

the classifier

the pi zero w has no tflite or onnx wheels, so the classifier runs in plain numpy from a single .npz file (firmware/smartbin/nn.py and firmware/smartbin/graphnet.py). accuracy matters more than speed here, so the model is the mobilenetv3large at 224 px with batch norm folded into the convolutions and the weights stored as fp16. the numpy version gives the same answers as keras, within 0.011 in probability.

to make it faster, i removed the hidden channels with the smallest weights and then trained the smaller network against the full model (ml/prune.py). the model on the bin removes 60 percent of them and runs at 160 px, which cuts the compute from 214m to 69m multiply-adds. a gentler version that removes 50 percent and keeps 224 px is also in the repo.

python ml/cache.py --manifest <manifest.csv> --root <dataset root>   decode crops once at 224 px
python ml/export_teacher.py --teacher <teacher.weights.h5>           write firmware/models/smartbin-teacher.npz
python ml/prune.py --ratio 0.6 --size 160 --epochs 20 --out firmware/models/smartbin-fast.npz
python ml/distill.py --teacher <teacher.weights.h5>                  optional, train the small student instead

results on the held-out splits (accuracy):

the model on the bin is 3.0 mb and takes about 17 ms per image in numpy on a laptop. i have not timed it on the zero w yet, and i expect roughly 2 to 3 seconds per image there. all of the models are in firmware/models/ and can be selected in firmware/config/device.yaml.

running it on the pi

install the python packages from apt, because a zero w has no wheels for them:

sudo apt install git python3-venv python3-numpy python3-pil python3-yaml python3-lgpio \
  python3-picamera2 python3-fastapi python3-uvicorn python3-pydantic python3-pydantic-core
git clone https://github.com/DagaVedant/SmartBin.git ~/SmartBin
python3 -m venv --system-site-packages ~/SmartBin/.venv

the servo uses the pi's hardware pwm, so add this to /boot/firmware/config.txt and reboot:

dtoverlay=pwm,pin=12,func=4

then calibrate, once each. the servo needs root because /sys/class/pwm is root-only.

cd ~/SmartBin/firmware
sudo ~/SmartBin/.venv/bin/python -m smartbin.calibrate servo
~/SmartBin/.venv/bin/python -m smartbin.calibrate scale --grams 47

the scale step asks you to empty the pan, then place a known mass (47 g here) on it, and stores the result in firmware/config/scale_cal.json.

run it:

sudo ~/SmartBin/.venv/bin/python -m smartbin

or install it as a service:

sudo cp ~/SmartBin/firmware/smartbin.service /etc/systemd/system/
sudo systemctl enable --now smartbin