#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <ESP32Servo.h>

// === PIN ASSIGNMENTS ===
#define PIR_PIN     16    // PIR Sensor
#define SERVO_PIN   13    // Servo Motor
#define SDA_PIN     15    // LCD SDA
#define SCL_PIN     14    // LCD SCL

LiquidCrystal_I2C lcd(0x27, 16, 2);
Servo feederServo;
bool hasFed = false;
unsigned long lastFeedTime = 0;
const unsigned long cooldownPeriod = 10000; // 10 seconds cooldown

void setup() {
  Serial.begin(115200);

  // LCD Initialization
  Wire.begin(SDA_PIN, SCL_PIN);
  lcd.begin(16, 2);
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("Pet Feeder Ready");
  lcd.setCursor(0, 1);
  lcd.print("Warming PIR...");

  // PIR sensor setup with internal pull-down
  pinMode(PIR_PIN, INPUT_PULLDOWN);
  delay(10000);  // Warm-up delay for PIR sensor
  Serial.println("✅ PIR Warmed up.");

  // Servo initialization
  feederServo.setPeriodHertz(50);
  feederServo.attach(SERVO_PIN);
  feederServo.write(0);  // Closed

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Waiting for pet...");
}

void loop() {
  // Debounce: read PIR twice to confirm motion
  int motion = digitalRead(PIR_PIN);
  delay(50);
  int confirm = digitalRead(PIR_PIN);
  unsigned long currentTime = millis();

  if (motion == HIGH && confirm == HIGH && !hasFed) {
    hasFed = true;
    lastFeedTime = currentTime;

    Serial.println("🎯 Motion Confirmed!");
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Pet Detected");
    lcd.setCursor(0, 1);
    lcd.print("Dispensing...");

    // Dispense food via servo
    feederServo.write(90);
    delay(1500);
    feederServo.write(0);
    delay(500);

    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Feeding Done!");
    delay(3000);

    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Waiting...");
  }

  // Reset feeding flag after cooldown
  if (hasFed && (currentTime - lastFeedTime > cooldownPeriod)) {
    hasFed = false;
    Serial.println("⏳ Cooldown complete. Ready for next detection.");
  }

  delay(200);
}

#include "esp_camera.h"
#include "FS.h"
#include "SD_MMC.h"


#define PIR_PIN 13  // GPIO connected to PIR OUT


// CAMERA MODEL - AI Thinker
#define PWDN_GPIO_NUM     32
#define RESET_GPIO_NUM    -1
#define XCLK_GPIO_NUM      0
#define SIOD_GPIO_NUM     26
#define SIOC_GPIO_NUM     27


#define Y9_GPIO_NUM       35
#define Y8_GPIO_NUM       34
#define Y7_GPIO_NUM       39
#define Y6_GPIO_NUM       36
#define Y5_GPIO_NUM       21
#define Y4_GPIO_NUM       19
#define Y3_GPIO_NUM       18
#define Y2_GPIO_NUM        5
#define VSYNC_GPIO_NUM    25
#define HREF_GPIO_NUM     23
#define PCLK_GPIO_NUM     22


int photoIndex = 0;
bool motionPreviouslyDetected = false;
unsigned long lastCaptureTime = 0;
const unsigned long captureCooldown = 10000; // 10 sec cooldown between photos


void startCamera() {
  camera_config_t config;
  config.ledc_channel = LEDC_CHANNEL_0;
  config.ledc_timer   = LEDC_TIMER_0;
  config.pin_d0       = Y2_GPIO_NUM;
  config.pin_d1       = Y3_GPIO_NUM;
  config.pin_d2       = Y4_GPIO_NUM;
  config.pin_d3       = Y5_GPIO_NUM;
  config.pin_d4       = Y6_GPIO_NUM;
  config.pin_d5       = Y7_GPIO_NUM;
  config.pin_d6       = Y8_GPIO_NUM;
  config.pin_d7       = Y9_GPIO_NUM;
  config.pin_xclk     = XCLK_GPIO_NUM;
  config.pin_pclk     = PCLK_GPIO_NUM;
  config.pin_vsync    = VSYNC_GPIO_NUM;
  config.pin_href     = HREF_GPIO_NUM;
  config.pin_sscb_sda = SIOD_GPIO_NUM;
  config.pin_sscb_scl = SIOC_GPIO_NUM;
  config.pin_pwdn     = PWDN_GPIO_NUM;
  config.pin_reset    = RESET_GPIO_NUM;
  config.xclk_freq_hz = 20000000;
  config.pixel_format = PIXFORMAT_JPEG;

  config.frame_size   = FRAMESIZE_SVGA; // try FRAMESIZE_VGA if needed
  config.jpeg_quality = 10;
  config.fb_count     = 1;


  esp_err_t err = esp_camera_init(&config);
   if (err != ESP_OK) {
      Serial.printf("Camera init failed with error 0x%x", err);
      while (true);
  }
}

void setup() {
  Serial.begin(115200);
  delay(1000);

  pinMode(PIR_PIN, INPUT);

  startCamera();

if (!SD_MMC.begin()) {
  Serial.println("SD Card Mount Failed");
  return;
}


if (SD_MMC.cardType() == CARD_NONE) {
  Serial.println("No SD card attached");
  return;
}


Serial.println("System ready. Waiting for motion...");
}


void loop() {
  bool motionDetected = digitalRead(PIR_PIN) == HIGH;


  if (motionDetected && !motionPreviouslyDetected && millis() - lastCaptureTime > captureCooldown) {
    Serial.write('A');


    camera_fb_t * fb = esp_camera_fb_get();
    if (!fb) {
      Serial.println("Camera capture failed");
      return;
    }


    String path = "/photo" + String(photoIndex++) + ".jpg";
    File file = SD_MMC.open(path, FILE_WRITE);
    if (!file) {
      Serial.println("Failed to open file");
      esp_camera_fb_return(fb);
      return;
    }


    file.write(fb->buf, fb->len);
    file.close();
    esp_camera_fb_return(fb);


    Serial.println("Photo saved to: " + path);


    lastCaptureTime = millis(); // start cooldown
  }


  motionPreviouslyDetected = motionDetected;
  delay(10000); // 10 secs delay
  }

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

    // === OLED Setup ===
    #define SCREEN_WIDTH 128
    #define SCREEN_HEIGHT 64
    #define OLED_ADDRESS 0x3C


    Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);


    // === Servo Setup ===
    #define SERVO_PIN 25
    Servo myServo;


    void setup() {
      Serial.begin(115200);


      // Initialize OLED
      if (!display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDRESS)) {
        Serial.println(F("OLED not found"));
        while (1);
      }


      display.clearDisplay();
      display.setTextSize(1);
      display.setTextColor(SSD1306_WHITE);
      display.setCursor(30, 25);
      display.println("OLED Ready");
      display.display();
      delay(1000);


      // Initialize Servo
      myServo.setPeriodHertz(50);
      myServo.attach(SERVO_PIN);
      myServo.write(0);
      Serial.println("Servo Ready");
      delay(1000);
    }

    void open(){
    for (int i = 3; i > 0; i--) {
        display.clearDisplay();
        display.setTextSize(1);
        display.setCursor(25, 15);
        display.println("DISPENSING IN...");
        display.setTextSize(2);
        display.setCursor(60, 35);
        display.print(i);
        display.display();
        delay(1000);
      }


      // Dispense (Open Servo)
      myServo.write(90);
      display.clearDisplay();
      display.setTextSize(1);
      display.setCursor(34, 28);
      display.println("DISPENSING...");
      display.display();
      Serial.println("Dispensing...");
      delay(1000);


      // Countdown to Close
      for (int i = 3; i > 0; i--) {
        display.clearDisplay();
        display.setTextSize(1);
        display.setCursor(30, 15);
        display.println("CLOSING IN...");
        display.setTextSize(2);
        display.setCursor(60, 35);
        display.print(i);
        display.display();
        delay(1000);
      }


      // Close Servo
      myServo.write(0);
      display.clearDisplay();
      display.setTextSize(1);
      display.setCursor(44, 28);
      display.println("DONE!");
      display.display();
      Serial.println("Dispense Complete");
      }

      void loop() {
      byte recv=0;
      if (Serial.available()){
        recv = Serial.read();
        if (recv == 'A'){
        open();
        }
      }
    }