Password-Protected Alarm System

The system is structured around a 4-state Finite State Machine (FSM) running on the ATmega328P. All peripherals are driven using direct register manipulation.

Hardware Modules:

• ATmega328P (Arduino Nano) — central processing unit, 16 MHz, 5V
• PIR Sensor (HC-SR501) — motion detection for automatic arming
• Servo Motor SG90 — actuates the physical door lock mechanism (PC0)
• Passive Buzzer — variable-frequency acoustic feedback via GPIO toggle (PD7)
• 4x Password Buttons — 4-digit code input (PD3, PD4, PB0, PB1)
• Start/Reset Button — alarm trigger and system reset (PD2)
• Arming Button — PIR sensor arm/disarm toggle (PB4)
• Password Change Button — enters secure password-change mode (PC1)
• Green LED — correct password / system disarmed indicator (PD5)
• Red LED — active alarm indicator (PD6)
• PIR Status LED — visual indicator when PIR is armed (PB2)
• 16×2 LCD (HD44780 + PCF8574 I2C adapter) — real-time status messages (A4/A5)

Bill of Materials:

Electrical Notes:

• All push buttons use internal pull-up resistors (DDRx bit = 0, PORTx bit = 1). Buttons are active-low: connected between pin and GND. No external resistors needed.
• LEDs are connected through 220Ω current-limiting resistors to GND. At 5V with a 2V LED forward voltage: (5V − 2V) / 220Ω ≈ 13.6 mA, well within the 40 mA/pin limit of the ATmega328P.
• The SG90 servo is powered directly from the Arduino Nano 5V pin. For heavier loads, a separate 5V supply is recommended.
• The LCD I2C adapter (PCF8574) typically includes pull-up resistors on SDA/SCL. Default I2C address: 0x27.
• The HC-SR501 PIR outputs a digital HIGH (3.3–5V) when motion is detected, directly compatible with the 5V ATmega328P input.

Software Design:

• Toolchain: avr-gcc + avrdude (bare-metal, no Arduino Framework)
• Editor: VS Code with C and AVR Utils extensions
• Debugging: UART serial output (9600 baud) + LED state indicators
• Target: ATmega328P on Arduino Nano (16 MHz, 5V)

Password Validation FSM:

The system uses a finite state machine with 4 states:

^ State ^ Code ^ Description ^

FSM Transitions:

• 0 → 1: Start button pressed (PD2) OR PIR armed + motion detected (PB3)
• 1 → 0 (success): 4 digits entered, password correct → servo opens, system resets
• 1 → 2 (failure): Timer expires (30s) OR wrong password entered
• 2 → 0: Correct password entered even in alarm state → system resets
• 0 → 3: Password-change button pressed (PC1)
• 3 → 0: Old password verified + new password saved to EEPROM

The project uses exclusively bare-metal avr-libc — no Arduino Framework. This choice provides full control over peripheral registers, deterministic timing, smaller code size, and compatibility with any AVR toolchain (avr-gcc + avrdude).

<avr/io.h>
Provides symbolic definitions for all ATmega328P peripheral registers (DDRx, PORTx, PINx, TCCRx, OCRx, TWCR, UBRR0, etc.). Without this header, raw hexadecimal register addresses would be required, making the code unportable and unreadable. It is an absolute necessity for any bare-metal AVR project.

<util/delay.h>
Provides _delay_ms() and _delay_us(), computed at compile time based on F_CPU = 16000000UL. Used in:

• LCD initialization sequence (precise 50 ms, 5 ms, 150 µs boot delays required by HD44780 spec)
• Servo soft-PWM pulse generation (1000 µs / 1500 µs control pulses)
• Button debouncing (50 ms after edge detection)
• Buzzer tone generation (500 µs toggle = 1 kHz; 330 µs ≈ 1.5 kHz; 250 µs = 2 kHz)

A hardware timer alternative would be more CPU-efficient for long waits, but for short and precise initialization delays, _delay_us() is the correct approach.

<avr/eeprom.h>
Provides eeprom_update_byte() and eeprom_read_byte() for safe access to the 1 KB internal EEPROM of the ATmega328P. Critically, eeprom_update_byte() (unlike eeprom_write_byte()) checks whether the existing value equals the new value before performing a write. This extends EEPROM lifetime (rated ~100,000 write cycles per cell) — important when the same password bytes might be rewritten repeatedly. Used to persist the 4-digit password across power cycles.

Block Design

The implementation is directly based on concepts from the following laboratories:

Laboratory 0 — GPIO
Used for all digital inputs and outputs. Pin direction is set via DDRx, output values via PORTx, and input states read via PINx. Internal pull-ups (PORTx |= (1 « Pxy) with DDRx &= ~(1 « Pxy)) eliminate the need for external resistors on all 6 buttons. LED driving, buzzer toggling, and servo signal generation all rely on basic GPIO operations.

Laboratory 1 — UART
Integrated for real-time debugging. Every significant state transition (alarm activation, key press, password change, arming) generates a descriptive UART message transmitted at 9600 baud. Initialization uses the formula UBRR = F_CPU / 16 / BAUD − 1 = 103 for 9600 baud at 16 MHz. Transmission uses polling on the UDRE0 flag in UCSR0A.

Laboratory 2 — Interrupts
Timer1 uses the hardware CTC overflow flag (OCF1A in TIFR1) checked by polling in the main loop. This decouples the 1-second countdown from the rest of the loop execution, ensuring temporal accuracy independent of code execution time. The flag is cleared by writing a logical 1 to it (TIFR1 |= (1 « OCF1A)) — the AVR write-1-to-clear mechanism. Button edge detection (comparing current and previous state) provides interrupt-like single-trigger behaviour without ISR overhead.

Laboratory 3 — Timers
Timer1 is configured in CTC mode (WGM12 = 1) with prescaler 1024 (CS12 = 1, CS10 = 1) and OCR1A = 15624, generating a precise 1 Hz event: 16,000,000 / 1024 / (15624 + 1) = 1 Hz. TCNT1 is reset to 0 at alarm activation, and the OCF1A flag is polled each main loop iteration to count elapsed seconds for the 30-second countdown.

Laboratory 6 — I2C
The HD44780 LCD with PCF8574 I2C adapter is controlled via a manually implemented I2C driver (no third-party library). Hardware TWI registers used: TWBR = 12 for ~400 kHz fast mode, TWSR = 0 for prescaler 1, TWCR for start/stop/write control. Each LCD character requires 2 I2C transactions (upper nibble + lower nibble), each including an enable pulse. This custom implementation allows full control over I2C address, backlight, and LCD command timing.

The main while(1) loop is organized as a sequential state machine. Each iteration evaluates the current state and performs the appropriate actions:

while(1) {
    // 1. Update PIR indicator LED (state-independent)
    // 2. In state 0: check Arming button (PB4) and Password-Change button (PC1)
    // 3. Check alarm trigger: Start button (PD2) OR PIR + motion (PB3)
    // 4. In state 1: check Timer1 flag (TIFR1) → decrement countdown, beep
    // 5. In states 1 and 2: read keypad → validate password
    // 6. In state 2: toggle buzzer (PD7) for continuous alarm
    // 7. In state 3: two-step password change sub-FSM
}

Key interactions between functionalities:

• State 0 → 1 transition: Triggered by Start button (PD2, reset_efectuat = 1) OR PIR armed + motion detected (PB3 HIGH). Resets TCNT1 = 0, secunde = 0, taste_apasate = 0.
• State 1 → 0 (success): 4 keys entered, password matches parola_setata[]. Servo opens, reset_efectuat = 0 (blocks new start until RESET is pressed).
• State 1 → 2 (failure): Countdown reaches 30 seconds OR wrong 4-digit password entered.
• State 0 → 3: Password-change button (PC1) pressed. Enters two-step sub-automaton.
• System reset: Start button (PD2) pressed in state 0 with reset_efectuat = 0 → confirms reset, sets reset_efectuat = 1.
• EEPROM interaction: Password is read from EEPROM at boot (eeprom_citeste_parola()) and written only when explicitly changed (eeprom_salveaza_parola()).

Schematics

Detailed pin mapping with justification for each choice:

^ Arduino Nano Pin ^ AVR Pin ^ Direction ^ Connected Component ^ Justification ^