How to Build an ESP32 Pet Treat Dispenser

/*
 * ESP32 Pet Treat Dispenser
 *
 * Hardware:
 *   - HX711 load cell amplifier  → GPIO32 (DOUT), GPIO33 (SCK)
 *   - SG90 servo (gate)          → GPIO18 (PWM)
 *   - SSD1306 OLED 128×64        → GPIO21 (SDA), GPIO22 (SCL)
 *   - Manual dispense button     → GPIO27 (active-low, INPUT_PULLUP)
 *   - Piezo buzzer               → GPIO26 (PWM)
 *
 * Libraries: bogde/HX711, ESP32Servo, Adafruit SSD1306, Adafruit GFX
 *
 * Power note: servo VCC → external 5 V supply; GND shared with ESP32.
 */

#include <Arduino.h>
#include <Wire.h>
#include <HX711.h>
#include <ESP32Servo.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

// ── Pin definitions ────────────────────────────────────────────────────────────
#define HX711_DOUT_PIN  32
#define HX711_SCK_PIN   33
#define SERVO_PIN       18
#define BUTTON_PIN      27
#define BUZZER_PIN      26
#define SDA_PIN         21
#define SCL_PIN         22

// ── Calibration & tuning ───────────────────────────────────────────────────────
// CALIBRATION_FACTOR: divide raw HX711 units by this value to get grams.
// How to calibrate:
//   1. Tare with an empty bowl (power cycle or hold button 3 s).
//   2. Place a known weight (e.g. 100 g) in the bowl.
//   3. Open Serial Monitor at 115200. The firmware prints raw units.
//   4. CALIBRATION_FACTOR = raw_units / known_grams.
//   5. Update the value below and re-flash.
const float CALIBRATION_FACTOR     = 420.0f;

// Grams of treats the servo should drop per dispense cycle.
const float TARGET_DISPENSE_GRAMS  = 10.0f;

// If the bowl already holds at least this many grams, skip dispensing.
const float BOWL_FULL_THRESHOLD_G  = 20.0f;

// Minimum time between dispensing cycles (ms). Prevents rapid re-feeding.
// Default: 5 minutes.
const unsigned long COOLDOWN_MS    = 5UL * 60UL * 1000UL;

// Servo angle when the gate is closed and open.
const int SERVO_CLOSED_DEG  = 0;
const int SERVO_OPEN_DEG    = 90;

// How long the servo stays open for one dispense pulse (ms).
const unsigned long GATE_OPEN_MS   = 600UL;

// ── OLED ───────────────────────────────────────────────────────────────────────
#define OLED_WIDTH  128
#define OLED_HEIGHT  64
#define OLED_ADDR   0x3C

// ── Globals ───────────────────────────────────────────────────────────────────
HX711           scale;
Servo           gateServo;
Adafruit_SSD1306 display(OLED_WIDTH, OLED_HEIGHT, &Wire, -1);

// State machine
unsigned long lastDispenseMs  = 0;    // millis() at the last successful dispense
unsigned long gateOpenedMs    = 0;    // millis() when gate was opened
bool          gateOpen        = false;
float         bowlWeightG     = 0.0f;
bool          oledAvailable   = false;
bool          scaleAvailable  = false;

// Button debounce
bool          lastButtonState = HIGH;
unsigned long lastDebounceMs  = 0;
const unsigned long DEBOUNCE_MS = 50;

// ── Forward declarations ───────────────────────────────────────────────────────
void     updateDisplay();
void     startDispense();
void     closeGate();
void     chirpBuzzer(int times);
float    readBowlWeight();
void     serialStatus();

// ── Setup ─────────────────────────────────────────────────────────────────────
void setup() {
    Serial.begin(115200);
    delay(200);
    Serial.println("=== ESP32 Pet Treat Dispenser ===");

    // I²C for OLED
    Wire.begin(SDA_PIN, SCL_PIN);

    // OLED init
    if (display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR)) {
        oledAvailable = true;
        display.clearDisplay();
        display.setTextColor(SSD1306_WHITE);
        display.setTextSize(1);
        display.setCursor(0, 0);
        display.println("Pet Treat Dispenser");
        display.println("Initialising...");
        display.display();
        Serial.println("OLED OK");
    } else {
        Serial.println("WARN: SSD1306 not found — check SDA/SCL on GPIO21/22");
    }

    // HX711 load cell
    scale.begin(HX711_DOUT_PIN, HX711_SCK_PIN);
    if (scale.is_ready()) {
        scale.set_scale(CALIBRATION_FACTOR);
        scale.tare();            // zero the scale with empty bowl
        scaleAvailable = true;
        Serial.println("HX711 OK — tared");
    } else {
        Serial.println("WARN: HX711 not ready — check wiring on GPIO32/33");
    }

    // Servo
    gateServo.attach(SERVO_PIN);
    gateServo.write(SERVO_CLOSED_DEG);
    Serial.println("Servo OK — gate closed");

    // Button
    pinMode(BUTTON_PIN, INPUT_PULLUP);

    // Buzzer
    pinMode(BUZZER_PIN, OUTPUT);
    digitalWrite(BUZZER_PIN, LOW);

    // Brief startup chirp
    chirpBuzzer(1);

    updateDisplay();
    Serial.println("Ready. Press button to dispense.");
}

// ── Loop ──────────────────────────────────────────────────────────────────────
void loop() {
    unsigned long now = millis();

    // ── 1. Close gate after GATE_OPEN_MS ──────────────────────────────────────
    if (gateOpen && (now - gateOpenedMs >= GATE_OPEN_MS)) {
        closeGate();
    }

    // ── 2. Read scale at moderate rate (every 200 ms) ─────────────────────────
    static unsigned long lastScaleRead = 0;
    if (scaleAvailable && (now - lastScaleRead >= 200)) {
        lastScaleRead = now;
        bowlWeightG = readBowlWeight();
    }

    // ── 3. Button debounce ────────────────────────────────────────────────────
    bool rawBtn = digitalRead(BUTTON_PIN);
    if (rawBtn != lastButtonState) {
        lastDebounceMs = now;
    }
    lastButtonState = rawBtn;

    if ((now - lastDebounceMs >= DEBOUNCE_MS) && rawBtn == LOW) {
        // Rising-edge detected after debounce — trigger dispense
        lastDebounceMs = now + 500;   // prevent immediate re-trigger

        Serial.println("Button pressed");

        if (gateOpen) {
            Serial.println("Gate already open — ignoring");
        } else if (now - lastDispenseMs < COOLDOWN_MS && lastDispenseMs != 0) {
            unsigned long remaining = (COOLDOWN_MS - (now - lastDispenseMs)) / 1000;
            Serial.printf("Cooldown active — %lu s remaining\n", remaining);
            chirpBuzzer(2);   // double-chirp = denied
            updateDisplay();
        } else if (scaleAvailable && bowlWeightG >= BOWL_FULL_THRESHOLD_G) {
            Serial.printf("Bowl full (%.1f g) — skipping dispense\n", bowlWeightG);
            chirpBuzzer(2);
            updateDisplay();
        } else {
            startDispense();
        }
    }

    // ── 4. Refresh OLED every second ──────────────────────────────────────────
    static unsigned long lastDisplayUpdate = 0;
    if (now - lastDisplayUpdate >= 1000) {
        lastDisplayUpdate = now;
        updateDisplay();
        serialStatus();
    }
}

// ── Helpers ───────────────────────────────────────────────────────────────────

float readBowlWeight() {
    if (!scale.is_ready()) return bowlWeightG;  // return last known value
    float w = scale.get_units(3);               // average 3 readings
    if (w < 0) w = 0;
    return w;
}

void startDispense() {
    Serial.println("Dispensing...");
    gateServo.write(SERVO_OPEN_DEG);
    gateOpen      = true;
    gateOpenedMs  = millis();
    lastDispenseMs = millis();
    chirpBuzzer(1);
    updateDisplay();
}

void closeGate() {
    gateServo.write(SERVO_CLOSED_DEG);
    gateOpen = false;
    Serial.println("Gate closed");
    updateDisplay();
}

void chirpBuzzer(int times) {
    for (int i = 0; i < times; i++) {
        digitalWrite(BUZZER_PIN, HIGH);
        delay(80);
        digitalWrite(BUZZER_PIN, LOW);
        if (i < times - 1) delay(120);
    }
}

void updateDisplay() {
    if (!oledAvailable) return;

    unsigned long now = millis();
    display.clearDisplay();
    display.setTextSize(1);
    display.setTextColor(SSD1306_WHITE);

    // ── Header ────────────────────────────────────────────────────────────────
    display.setCursor(0, 0);
    display.println("  Pet Treat Dispenser");
    display.drawLine(0, 10, OLED_WIDTH - 1, 10, SSD1306_WHITE);

    // ── Bowl weight ───────────────────────────────────────────────────────────
    display.setCursor(0, 14);
    if (scaleAvailable) {
        display.printf("Bowl: %.1f g", bowlWeightG);
        if (bowlWeightG >= BOWL_FULL_THRESHOLD_G) {
            display.setCursor(0, 24);
            display.println("  [Bowl full]");
        }
    } else {
        display.println("Bowl: -- (no sensor)");
    }

    // ── Gate status ───────────────────────────────────────────────────────────
    display.setCursor(0, 36);
    display.print("Gate: ");
    display.println(gateOpen ? "OPEN" : "closed");

    // ── Cooldown / last feed ──────────────────────────────────────────────────
    display.setCursor(0, 48);
    if (lastDispenseMs == 0) {
        display.println("Last feed: --");
    } else if (now - lastDispenseMs < COOLDOWN_MS) {
        unsigned long remainSec = (COOLDOWN_MS - (now - lastDispenseMs)) / 1000;
        if (remainSec >= 60) {
            display.printf("Cooldown: %lu m", remainSec / 60);
        } else {
            display.printf("Cooldown: %lu s", remainSec);
        }
    } else {
        display.println("Ready to feed");
    }

    display.display();
}

void serialStatus() {
    unsigned long now = millis();
    Serial.printf("[%.1f s] Bowl: %.1f g | Gate: %s | Cooldown: ",
        now / 1000.0f,
        bowlWeightG,
        gateOpen ? "OPEN" : "closed");

    if (lastDispenseMs == 0) {
        Serial.println("none");
    } else if (now - lastDispenseMs < COOLDOWN_MS) {
        Serial.printf("%lu s remaining\n",
            (COOLDOWN_MS - (now - lastDispenseMs)) / 1000);
    } else {
        Serial.println("ready");
    }
}

// Run this and build other cool things at schematik.io