Smart dustbin on an Arduino Uno

// Smart dustbin: a lid that opens by itself when a hand comes near, and a
// second sensor that says when the bin is full. On an Arduino Uno.
//
//   hand sensor   HC-SR04 on the front: TRIG -> pin 3, ECHO -> pin 2
//   fill sensor   HC-SR04 under the lid, looking down: TRIG -> 13, ECHO -> 12
//   lid servo     SG90: signal -> A3, VCC -> 5 V, GND -> GND
//   lights        traffic light module: green -> A0, yellow -> A1, red -> A2
//   piezo         pin 10 and GND
//
// The analog pins A0 to A3 work as ordinary digital pins too, which leaves
// the pins along the top for the two sensors.
//
// Hold a hand closer than 20 cm to the front and the lid swings open with a
// beep. It stays open while the hand is there and closes two seconds after
// it has gone. The green light means ready, yellow means the lid is open.
//
// While the lid is shut, the fill sensor looks down into the bin, 30 cm
// deep, once a second. The less space it measures, the fuller the bin. At 80
// percent the red light comes on, the Serial Monitor asks for it to be
// emptied, and the lid stays shut with a low buzz until it is.
//
// # Why the lid moves slowly
//
// servo.write(100) on its own would slam the lid open as fast as the motor
// can turn. Here the angle moves 2 degrees every 15 ms, so the lid takes about
// 0.7 seconds to open and does it smoothly, while loop() keeps reading the
// sensors in between. Every timer in this sketch works the same way: it
// remembers when something last happened with millis() and checks how long
// ago that was. Nothing ever waits in delay().

#include <Servo.h>

const uint8_t HAND_TRIG = 3;
const uint8_t HAND_ECHO = 2;
const uint8_t FILL_TRIG = 13;
const uint8_t FILL_ECHO = 12;
const uint8_t SERVO_PIN = A3;
const uint8_t GREEN = A0;
const uint8_t YELLOW = A1;
const uint8_t RED = A2;
const uint8_t PIEZO = 10;

const int HAND_CM = 20;       // a hand closer than this opens the lid
const int BIN_DEPTH_CM = 30;  // from the fill sensor to the bottom of the bin
const int FULL_PERCENT = 80;  // at this the lid stays shut
const int SHUT = 0;           // servo angles for the lid
const int OPEN = 100;
const unsigned long STAY_OPEN_MS = 2000;

Servo lid;
int lidAngle = SHUT;
int lidTarget = SHUT;
unsigned long lidStepAt = 0;
unsigned long handSeenAt = 0;
unsigned long handCheckAt = 0;
unsigned long fillCheckAt = 0;
bool lidOpen = false;
bool full = false;
int fillPercent = -100;  // nothing printed yet
unsigned int opens = 0;
bool handWasNear = false;

// One measurement in centimeters, or 0 if no echo came back in 25 ms
// (nothing closer than about 4 meters).
int measureCm(uint8_t trig, uint8_t echo) {
  digitalWrite(trig, LOW);
  delayMicroseconds(2);
  digitalWrite(trig, HIGH);
  delayMicroseconds(10);
  digitalWrite(trig, LOW);
  unsigned long us = pulseIn(echo, HIGH, 25000UL);
  // Sound goes there and back at 343 m/s: 58 microseconds a centimeter.
  return (int)(us / 58);
}

void showLights() {
  digitalWrite(RED, full ? HIGH : LOW);
  digitalWrite(YELLOW, lidOpen ? HIGH : LOW);
  digitalWrite(GREEN, !full && !lidOpen ? HIGH : LOW);
}

void openLid(int cm) {
  if (full) {
    // A low buzz: it is full and will not open.
    tone(PIEZO, 220, 300);
    Serial.println("bin full: please empty it");
    return;
  }
  lidOpen = true;
  lidTarget = OPEN;
  opens++;
  tone(PIEZO, 1320, 80);
  Serial.print("hand at ");
  Serial.print(cm);
  Serial.print(" cm: lid open (");
  Serial.print(opens);
  Serial.println(opens == 1 ? " time)" : " times)");
  showLights();
}

void closeLid() {
  lidOpen = false;
  lidTarget = SHUT;
  Serial.println("lid closed");
  showLights();
}

void checkHand(unsigned long now) {
  if (now - handCheckAt < 100) return;
  handCheckAt = now;
  int cm = measureCm(HAND_TRIG, HAND_ECHO);
  bool near = cm > 0 && cm < HAND_CM;
  if (near) {
    handSeenAt = now;
    // Only a hand that has just arrived opens the lid (or asks to), so a
    // hand held over a full bin beeps once, not ten times a second.
    if (!lidOpen && !handWasNear) openLid(cm);
  } else if (lidOpen && now - handSeenAt > STAY_OPEN_MS) {
    closeLid();
  }
  handWasNear = near;
}

void checkFill(unsigned long now) {
  // The fill sensor hangs under the lid, so it only sees into the bin when
  // the lid is shut and has finished moving.
  if (lidOpen || lidAngle != SHUT || now - fillCheckAt < 1000) return;
  fillCheckAt = now;
  int cm = measureCm(FILL_TRIG, FILL_ECHO);
  if (cm == 0 || cm > BIN_DEPTH_CM) cm = BIN_DEPTH_CM;  // nothing in it
  int percent = (BIN_DEPTH_CM - cm) * 100 / BIN_DEPTH_CM;
  // Print only a change of 10 percent or more, so the monitor stays readable.
  if (abs(percent - fillPercent) >= 10) {
    fillPercent = percent;
    Serial.print("bin ");
    Serial.print(percent);
    Serial.println("% full");
  }
  bool nowFull = percent >= FULL_PERCENT;
  if (nowFull != full) {
    full = nowFull;
    Serial.println(full ? "bin full: please empty it" : "bin emptied: ready");
    showLights();
  }
}

void moveLid(unsigned long now) {
  if (lidAngle == lidTarget || now - lidStepAt < 15) return;
  lidStepAt = now;
  lidAngle += lidTarget > lidAngle ? 2 : -2;
  lid.write(lidAngle);
}

void setup() {
  Serial.begin(115200);
  pinMode(HAND_TRIG, OUTPUT);
  pinMode(HAND_ECHO, INPUT);
  pinMode(FILL_TRIG, OUTPUT);
  pinMode(FILL_ECHO, INPUT);
  pinMode(RED, OUTPUT);
  pinMode(YELLOW, OUTPUT);
  pinMode(GREEN, OUTPUT);
  pinMode(PIEZO, OUTPUT);
  lid.attach(SERVO_PIN);
  lid.write(SHUT);
  showLights();
  Serial.println("Smart dustbin ready: hold a hand near the front sensor.");
}

void loop() {
  unsigned long now = millis();
  checkHand(now);
  checkFill(now);
  moveLid(now);
}