Name: Dascalu Stefan-Nicolae
Group: 331CA

eSafe is a digital lockbox implemented on an Arduino Uno. It uses a 4×4 matrix keypad for PIN entry, an SG90 servo for a mechanical latch, a DS1307 real-time clock (I²C) to enforce access windows, and a 16×2 I²C LCD to display status and time. Three wrong PIN attempts trigger an alarm tone and flashing red LED; valid entries drive the servo to unlock, light a green LED, and display “UNLOCKED.”

This project integrates functionalities from three labs:

• Lab 2 (Interrupts & GPIO): keypad row-change detection
• Lab 3 (Timers): debounce via Timer 2 CTC and alarm timing
• Lab 6 (I²C): shared bus for LCD and RTC

Below are both the abstract block diagram and the detailed wiring schematic with an Arduino Uno:

In Tinkercad I used a generic 7-segment I²C display; the real build uses the DS1307 module on the same SDA/SCL, so no rewiring or code changes are needed.

• Keypad: row-interrupt + Timer 2 CTC debounce
• Buzzer: tone/noTone alarm, driven directly from Arduino pin
• LEDs: status indicators with resistors
• Servo: 50 Hz PWM; relocked non-blocking after 5 s
• LCD/RTC: HD44780 via PCF8574; DS1307 battery-backed timekeeper
• Power: on-board 5 V regulator (~500 mA); peak draw ~270 mA

* ~200 lines of custom C++ on Arduino Uno integrating all core features * PIN entry with 4×4 matrix scan, three-strike alarm, and time-based lockout fully tested * Live clock updates, non-blocking unlock/relock, and persistent last-unlock log verified in hardware

* Non-blocking relock (Lab 3 – Timers): replaced `delay(5000)` with a `millis()` timestamp so the 5 s unlock interval doesn’t freeze the clock display. * Interrupt-driven keypad (Lab 2 – GPIO/Interrupts): uses pin-change interrupts on rows and Timer2 CTC for debounce to guarantee responsive PIN capture. * Shared I²C bus (Lab 6 – I²C): demonstrates multi-device communication between the DS1307 RTC and the PCF8574-based LCD expander.

1. updateDisplay()

1. called once per second (via `millis()`), updates HH:MM:SS, renders PIN asterisks or “Last HH:MM”
2. never blocks, so UI remains responsive

2. handleKey()

1. ‘C’ clears entry, digits append to buffer (with asterisks), ‘D’ validates PIN
2. on correct PIN, calls `unlockDoor()`; on wrong, increments counter or triggers alarm

3. unlockDoor()

1. moves servo to unlock angle, lights green LED + buzzer for 1 s
2. sets `lockRestoreMs = millis() + 5000` for non-blocking relock in `loop()`
3. logs timestamp in `lastUnlock` for display

4. loop()

1. checks `millis()` vs. `lockRestoreMs` to relock servo without pausing
2. updates display hourly and polls keypad
3. validated by toggling between allowed/outside hours and using a stopwatch for timing

* Debounce tuning: Timer2 CTC interval set to 60 ms based on oscilloscope measurements of switch bounce. * Servo angles: adjusted to 20° (unlock) and 110° (lock) for mechanical reliability. * Blocking calls minimized: only a 1 s buzzer delay remains; all longer waits use non-blocking `millis()` logic.

eSafe demonstrates integration of GPIO, interrupts, timers, PWM, and I²C into a user-friendly digital safe. Non-blocking design ensures smooth UI and reliable timekeeping.

• ATmega328P Datasheet
• DS1307 RTC Datasheet
• LiquidCrystal_I2C Library Guide
• Keypad Library Reference
• PlatformIO Documentation
• https://github.com/stefan-dascalu/esafe