Project 4

// High Frequency Sound Emitter with Solar/Battery Power, PIR Motion Sensor, and RTC Time Control
// Platform: Arduino Nano Type-C (ATmega328P compatible)
//
// ═══════════════════════════════════════════════════════════════════════════════
// BREADBOARD WIRING GUIDE — 400-Point Breadboard
// ═══════════════════════════════════════════════════════════════════════════════
//
// The 400-point breadboard has 30 rows, two power rails, and columns a–e (left)
// and f–j (right). The Arduino Nano Type-C is seated across the center gap,
// occupying columns d and g, rows 1–15 (adjust starting row to suit your build).
//
// ── ARDUINO NANO TYPE-C PIN LAYOUT ───────────────────────────────────────────
//
//   USB-C connector faces upward (top of board).
//   D13 is the first pin on the LEFT, D12 is the first pin on the RIGHT.
//
//   LEFT SIDE (column d)          RIGHT SIDE (column g)
//   ─────────────────────         ──────────────────────
//   d1  = D13  (built-in LED)     g1  = D12
//   d2  = D11  (PWM)              g2  = 3V3
//   d3  = D10  (PWM/SS)           g3  = REF  (AREF)
//   d4  = D9   (PWM)              g4  = A0
//   d5  = D8                      g5  = A1
//   d6  = D7                      g6  = A2
//   d7  = D6   (PWM)              g7  = A3
//   d8  = D5   (PWM)              g8  = A4   / SDA  ← DS3231 SDA
//   d9  = D4                      g9  = A5   / SCL  ← DS3231 SCL
//   d10 = D3   (PWM / INT1)       g10 = A6   (analog input only)
//   d11 = D2   (INT0)             g11 = A7   (analog input only)
//   d12 = GND                     g12 = 5V   output rail
//   d13 = RST                     g13 = RST  (second reset pin)
//   d14 = RX0  (D0) ← do not use  g14 = GND
//   d15 = VIN  (power in)         g15 = TX1  (D1) ← do not use
//
//   NOTE: RX0 = d14, TX1 = g15 on this board. Do NOT wire components to these
//         rows while Serial is active (USB communication uses them).
//
// ── POWER CHAIN ──────────────────────────────────────────────────────────────
//
//   [5V Solar Panel +] ──→ TP4056 IN+
//   [5V Solar Panel −] ──→ TP4056 IN−  (also connect to breadboard GND rail)
//   TP4056 B+          ──→ 18650 battery (+)
//   TP4056 B−          ──→ 18650 battery (−)
//   TP4056 OUT+        ──→ MT3608 IN+
//   TP4056 OUT−        ──→ MT3608 IN−   (GND rail)
//   MT3608 OUT+        ──→ Breadboard (+) power rail  [adjust pot to 5V]
//   MT3608 OUT−        ──→ Breadboard (−) power rail  (GND)
//   Arduino VIN (d15)  ──→ Breadboard (+) power rail
//   Arduino GND (d12)  ──→ Breadboard (−) power rail
//
// ── DS3231 RTC MODULE ────────────────────────────────────────────────────────
//
//   DS3231 VCC  ──→ (+) power rail
//   DS3231 GND  ──→ (−) power rail
//   DS3231 SDA  ──→ g8  (A4 / SDA)
//   DS3231 SCL  ──→ g9  (A5 / SCL)
//   DS3231 SQW  ──→ d11 (D2 — interrupt-capable INT0)
//   DS3231 RST  ──→ d9  (D4)
//   DS3231 32K  ──→ leave UNCONNECTED (not used in this sketch)
//
// ── HC-SR501 PIR SENSOR ──────────────────────────────────────────────────────
//
//   HC-SR501 VCC  ──→ (+) power rail
//   HC-SR501 GND  ──→ (−) power rail
//   HC-SR501 OUT  ──→ d5  (D8)
//
//   Tip: mount the PIR away from the breadboard using jumper wires for the
//        best field of view. The dome must face the detection area.
//
// ── ULTRASONIC SPEAKER + 2N2222 TRANSISTOR ───────────────────────────────────
//
//   Place the 2N2222 (TO-92 package, flat side facing you) on free rows:
//
//     Emitter  (left leg)   ──→ (−) power rail (GND)
//     Base     (middle leg) ──→ one end of 1kΩ resistor
//                               other end of 1kΩ ──→ d7 (D6, PWM)
//     Collector (right leg) ──→ Speaker (−) terminal
//
//   Speaker wiring:
//     Speaker (+) / VCC ──→ (+) power rail (5V)
//     Speaker (−)       ──→ 2N2222 Collector
//     Speaker DATA/SIG  ──→ d10 (D3, PWM tone output)
//
// ── TP4056 STATUS PIN ────────────────────────────────────────────────────────
//
//   TP4056 CHRG (open-drain) ──→ d4 (D9, internal pullup enabled)
//     LOW  = battery is actively charging
//     HIGH = battery full, or no solar input present
//
// ── COMPLETE PIN SUMMARY ─────────────────────────────────────────────────────
//
//   Breadboard | Arduino Pin | Function
//   ───────────┼─────────────┼────────────────────────────────────────
//   d1         | D13         | Built-in LED (avoid for user circuits)
//   d4         | D9  (PWM)   | TP4056 CHRG status (INPUT_PULLUP)
//   d5         | D8          | HC-SR501 PIR output (INPUT)
//   d6         | D7          | Push button — manual tone test (INPUT_PULLUP)
//   d7         | D6  (PWM)   | 2N2222 Base via 1kΩ resistor (OUTPUT)
//   d8         | D5  (PWM)   | (spare)
//   d9         | D4          | DS3231 RST — keep HIGH (OUTPUT)
//   d10        | D3  (PWM)   | Speaker DATA — tone() output (OUTPUT)
//   d11        | D2  (INT0)  | DS3231 SQW interrupt (INPUT_PULLUP)
//   d12        | GND         | Ground
//   d15        | VIN         | Power input from MT3608
//   g8         | A4 / SDA    | DS3231 SDA (I2C)
//   g9         | A5 / SCL    | DS3231 SCL (I2C)
//   g12        | 5V          | 5V output (for sensor power)
//
// ═══════════════════════════════════════════════════════════════════════════════

#include <Wire.h>
#include <RTClib.h>

// ── Pin Definitions ───────────────────────────────────────────────────────────

#define DS3231_SQW_PIN           2   // DS3231 SQW  → d11 (INT0, interrupt-capable)
#define SPEAKER_PWM_PIN          3   // Speaker DATA → d10 (PWM tone output)
#define DS3231_RST_PIN           4   // DS3231 RST  → d9  (keep HIGH)
#define TP4056_STATUS_PIN        9   // TP4056 CHRG → d4  (open-drain, INPUT_PULLUP)
#define PIR_PIN                  8   // HC-SR501 OUT → d5 (digital motion output)
#define BUTTON_PIN               7   // Push button  → d6 (active LOW, INPUT_PULLUP)
#define TRANSISTOR_BASE_PIN      6   // 2N2222 Base  → d7 (via 1kΩ resistor)
// A4 (g8) = SDA  — hardware I2C, no #define needed
// A5 (g9) = SCL  — hardware I2C, no #define needed
// D0 (d14) / D1 (g15) — reserved for USB Serial, do NOT wire components here

// ── Time Window Configuration ─────────────────────────────────────────────────
// 24-hour format. Edit these four values to set the PIR active window.
// Example below: active from 20:00 (8 PM) to 23:59 (midnight).
// For an overnight window (e.g. 22:00–06:00) the code handles the wraparound.
int activeStartHour   = 20;
int activeStartMinute =  0;
int activeEndHour     = 23;
int activeEndMinute   = 59;

// ── Tone / Timing Settings ────────────────────────────────────────────────────
#define TONE_FREQUENCY    20000UL   // Hz — upper edge of human hearing range
#define TONE_DURATION_MS   5000UL   // ms — how long the tone plays per trigger
#define PIR_COOLDOWN_MS   10000UL   // ms — quiet period after tone before re-arming

// ── RTC Object ────────────────────────────────────────────────────────────────
RTC_DS3231 rtc;

// ── Runtime State ─────────────────────────────────────────────────────────────
bool          speakerActive   = false;
unsigned long toneStartTime   = 0;
unsigned long lastTriggerTime = 0;
bool          pirArmed        = false;
bool          rtcAvailable    = false;

// Button debounce
bool          lastButtonState  = HIGH;  // HIGH = not pressed (pullup)
unsigned long lastDebounceTime = 0;
const unsigned long DEBOUNCE_DELAY = 50; // ms

// Periodic status print
unsigned long lastStatusPrint    = 0;
const unsigned long STATUS_INTERVAL = 30000; // ms

// ── Helper: is current time within the active window? ─────────────────────────
bool isWithinActiveWindow() {
    if (!rtcAvailable) {
        return true; // Failsafe: always active when RTC is unavailable
    }
    DateTime now = rtc.now();
    int current = (int)now.hour() * 60 + (int)now.minute();
    int start   = activeStartHour * 60 + activeStartMinute;
    int end     = activeEndHour   * 60 + activeEndMinute;

    if (start <= end) {
        // Same-day window  (e.g. 20:00 – 23:59)
        return (current >= start && current <= end);
    } else {
        // Overnight window (e.g. 22:00 – 06:00)
        return (current >= start || current <= end);
    }
}

// ── Helper: start emitting the high-frequency tone ────────────────────────────
void startTone() {
    if (!speakerActive) {
        speakerActive = true;
        toneStartTime = millis();
        digitalWrite(TRANSISTOR_BASE_PIN, HIGH); // Switch transistor ON
        tone(SPEAKER_PWM_PIN, TONE_FREQUENCY);   // Begin tone on D3
        Serial.print(F("Motion detected! Emitting "));
        Serial.print(TONE_FREQUENCY);
        Serial.println(F(" Hz tone."));
    }
}

// ── Helper: stop the tone and begin cooldown ──────────────────────────────────
void stopTone() {
    if (speakerActive) {
        speakerActive   = false;
        lastTriggerTime = millis();
        noTone(SPEAKER_PWM_PIN);
        digitalWrite(SPEAKER_PWM_PIN,      LOW); // Ensure D3 is LOW
        digitalWrite(TRANSISTOR_BASE_PIN,  LOW); // Switch transistor OFF
        Serial.println(F("Tone stopped. Cooldown started."));
    }
}

// ── Helper: print current RTC time and window status ──────────────────────────
void printCurrentTime() {
    if (!rtcAvailable) {
        Serial.println(F("RTC not available."));
        return;
    }
    DateTime now = rtc.now();
    Serial.print(F("Time: "));
    if (now.hour()   < 10) Serial.print('0');
    Serial.print(now.hour());   Serial.print(':');
    if (now.minute() < 10) Serial.print('0');
    Serial.print(now.minute()); Serial.print(':');
    if (now.second() < 10) Serial.print('0');
    Serial.print(now.second());
    Serial.print(F("  Window: "));
    if (activeStartHour   < 10) Serial.print('0');
    Serial.print(activeStartHour);   Serial.print(':');
    if (activeStartMinute < 10) Serial.print('0');
    Serial.print(activeStartMinute);
    Serial.print(F(" – "));
    if (activeEndHour   < 10) Serial.print('0');
    Serial.print(activeEndHour);     Serial.print(':');
    if (activeEndMinute < 10) Serial.print('0');
    Serial.print(activeEndMinute);
    Serial.print(F("  Active: "));
    Serial.println(isWithinActiveWindow() ? F("YES") : F("NO"));
}

// ── Helper: print TP4056 charge status ────────────────────────────────────────
void printPowerStatus() {
    // CHRG pin is open-drain: LOW = charging, HIGH = full / no solar input
    bool charging = (digitalRead(TP4056_STATUS_PIN) == LOW);
    Serial.print(F("Battery: "));
    Serial.println(charging ? F("CHARGING") : F("FULL / NOT CHARGING"));
}

// ── setup() ──────────────────────────────────────────────────────────────────
void setup() {
    Serial.begin(9600);
    Serial.println(F("=========================================="));
    Serial.println(F("  High Frequency Pest Deterrent System   "));
    Serial.println(F("  Solar + 18650 + PIR + DS3231 Time Gate "));
    Serial.println(F("=========================================="));
    Serial.println();

    // DS3231 SQW is open-drain output — internal pullup prevents floating input
    pinMode(DS3231_SQW_PIN,          INPUT_PULLUP);

    // DS3231 RST: drive HIGH to keep the RTC running
    pinMode(DS3231_RST_PIN,          OUTPUT);
    digitalWrite(DS3231_RST_PIN,     HIGH);

    // PIR sensor: 3.3V TTL output, safe for 5V Arduino input
    pinMode(PIR_PIN,                 INPUT);

    // Speaker tone output and transistor switch — both LOW at startup
    pinMode(SPEAKER_PWM_PIN,         OUTPUT);
    pinMode(TRANSISTOR_BASE_PIN,     OUTPUT);
    digitalWrite(SPEAKER_PWM_PIN,    LOW);
    digitalWrite(TRANSISTOR_BASE_PIN,LOW);
    noTone(SPEAKER_PWM_PIN);

    // TP4056 CHRG is open-drain — internal pullup reads HIGH when not charging
    pinMode(TP4056_STATUS_PIN,       INPUT_PULLUP);

    // Push button: active LOW, internal pullup (no external resistor needed)
    pinMode(BUTTON_PIN,              INPUT_PULLUP);

    // ── DS3231 initialisation ─────────────────────────────────────────────
    Wire.begin();
    if (!rtc.begin()) {
        Serial.println(F("WARNING: DS3231 not found on I2C bus!"));
        Serial.println(F("  SDA → g8 (A4)   SCL → g9 (A5)"));
        Serial.println(F("  Running in failsafe mode — PIR always active."));
        rtcAvailable = false;
    } else {
        rtcAvailable = true;
        Serial.println(F("DS3231 found and initialised."));

        if (rtc.lostPower()) {
            Serial.println(F("RTC lost power — setting clock to compile time."));
            rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
        }

        // Disable SQW square-wave output (saves power, reduces I2C noise)
        rtc.writeSqwPinMode(DS3231_OFF);

        printCurrentTime();
    }

    printPowerStatus();

    // Print the configured active window
    Serial.println();
    Serial.println(F("PIR active window (24-hour format):"));
    Serial.print(F("  Start : "));
    if (activeStartHour   < 10) Serial.print('0');
    Serial.print(activeStartHour);   Serial.print(':');
    if (activeStartMinute < 10) Serial.print('0');
    Serial.println(activeStartMinute);
    Serial.print(F("  End   : "));
    if (activeEndHour   < 10) Serial.print('0');
    Serial.print(activeEndHour);     Serial.print(':');
    if (activeEndMinute < 10) Serial.print('0');
    Serial.println(activeEndMinute);
    Serial.println(F("  Edit activeStartHour / activeEndHour in code to change."));
    Serial.println();

    // HC-SR501 warm-up (30–60 s recommended in the field; 10 s for bench testing)
    Serial.println(F("PIR warm-up: 10 s (use 30-60 s for field deployment)"));
    for (int i = 10; i > 0; i--) {
        Serial.print(i);
        Serial.print(F("s "));
        delay(1000);
    }
    Serial.println();
    Serial.println(F("System ready. Monitoring for motion..."));
    Serial.println(F("Press button on D7 (breadboard d6) to manually test tone."));
    Serial.println();
}

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

    // ── Periodic status output (every 30 s) ──────────────────────────────
    if (now - lastStatusPrint >= STATUS_INTERVAL) {
        lastStatusPrint = now;
        printCurrentTime();
        printPowerStatus();
        Serial.print(F("PIR armed: "));
        Serial.print(pirArmed ? F("YES") : F("NO"));
        Serial.print(F("  Speaker: "));
        Serial.println(speakerActive ? F("ON") : F("OFF"));
    }

    // ── Debounced push button (active LOW) ────────────────────────────────
    // Press to manually test the tone regardless of time window or PIR state.
    {
        bool reading = digitalRead(BUTTON_PIN);
        if (reading != lastButtonState) {
            lastDebounceTime = now;
        }
        if ((now - lastDebounceTime) >= DEBOUNCE_DELAY) {
            if (reading == LOW && lastButtonState == HIGH) {
                Serial.println(F("Button pressed — manual tone test."));
                startTone();
            }
        }
        lastButtonState = reading;
    }

    // ── Manage tone duration ──────────────────────────────────────────────
    if (speakerActive) {
        if (now - toneStartTime >= TONE_DURATION_MS) {
            stopTone();
        }
        // Skip PIR check while tone is playing to avoid immediate re-trigger
        return;
    }

    // ── Enforce time window ───────────────────────────────────────────────
    if (!isWithinActiveWindow()) {
        if (pirArmed) {
            pirArmed = false;
            Serial.println(F("Outside active window. PIR disarmed."));
        }
        return;
    }

    // ── Cooldown management ───────────────────────────────────────────────
    if (lastTriggerTime > 0) {
        if (now - lastTriggerTime < PIR_COOLDOWN_MS) {
            // Still cooling down — keep PIR disarmed
            pirArmed = false;
            return;
        } else {
            // Cooldown expired — re-arm
            if (!pirArmed) {
                pirArmed = true;
                Serial.println(F("Cooldown complete. PIR re-armed."));
            }
        }
    } else {
        // First pass after startup — arm immediately
        if (!pirArmed) {
            pirArmed = true;
        }
    }

    // ── PIR motion detection ──────────────────────────────────────────────
    // HC-SR501 OUT is HIGH when motion is detected
    if (pirArmed && digitalRead(PIR_PIN) == HIGH) {
        startTone();
    }
}