PROJECT REPORT

On

TITLE: Keypad Door Lock with

Arduino

School of Computational Sciences

Submitted By

Dhananjay Dange - 22458020031

Tanishq Dixit - 22458020042
Harshdeep Deore - 22458020036
Priyanka Darekar - 22458020032

School of Computational Sciences

JSPM University
Wagholi, Pune

Session: 2025 - 2026

Contents

1 Photographic Documentation 2

2 Abstract 4

3 Introduction 5
3.1 Definition and Context ............................................................................................................ 5
3.2 Historical Development ..........................................................................................................5
3.3 Project Objectives ...................................................................................................................5

4 System Design and Working Principle 6

4.1 Core Principle: Authentication by PIN ............................................................................... 6
4.2 System Architecture ............................................................................................................... 6
4.3 Workflow and State Diagram ................................................................................................ 7
4.4 Security Considerations......................................................................................................... 8

5 Hardware and Software Implementation 9

5.1 Hardware Components (Detailed) ........................................................................................ 9
5.1.1 Microcontroller: Arduino Uno.................................................................................. 9
5.1.2 Input Device: 4x4 Matrix Keypad ........................................................................... 9
5.1.3 Locking Mechanism: Servo Motor (SG90 or MG996R) ........................................ 9
5.1.4 Feedback System: 16x2 I2C LCD Display .............................................................10
5.1.5 Indicators: LEDs and Piezo Buzzer .......................................................................10
5.2 Software Implementation..................................................................................................... 11
5.2.1 Key Libraries............................................................................................................. 11
5.2.2 Control Logic and Program Flow (Pseudocode) .................................................. 11

6 System Analysis and Performance 14

6.1 Key Performance Specifications .......................................................................................... 14
6.2 Performance Testing Results ................................................................................................ 14

7 Applications and Scope 15

7.1 Current Applications ............................................................................................................ 15
7.2 Scope for Future Enhancement ........................................................................................... 15

8 Conclusion 17

9 References 18

1
1 Photographic Documentation

Figure 1: High-level system block diagram of the Arduino keypad lock.

Figure 2: Detailed circuit wiring schematic showing all connections.

2
 Figure 3: The 4x4 matrix keypad used for password input.

Figure 4: The servo motor adapted to actuate a deadbolt lock.

3
 Figure 5: A 16x2 I2C LCD display

.
2 Abstract
In an era of increasing demand for secure and convenient access control, traditional lock-and-key
systems are often proving to be insufficient. This project report details the design, development,
and implementation of a low-cost, high-security Keypad Door Lock system utilizing the Arduino
microcontroller platform. The system provides secure access to a restricted area by requiring a
user to enter a predefined numeric password via a matrix keypad.
The core of the project is an Arduino Uno, which serves as the central processing unit.
It interfaces with a 4x4 matrix keypad for user input and a 16x2 LCD display for providing
real-time feedback, such as "Enter PIN," "Access Granted," or "Access Denied." The locking
mechanism itself is actuated by a high-torque servo motor, which is controlled by the Arduino.
Upon successful validation of the user’s entered password, the Arduino sends a signal to the
servo to rotate, thereby retracting or engaging the door’s bolt.
This report provides a comprehensive analysis of the system’s architecture, beginning with
the fundamental principles of electronic access control. It dissects the major hardware com-
ponents, including the microcontroller, keypad scanning logic, and the mechanics of the servo-
driven lock. A significant portion is dedicated to the software implementation, detailing the
control logic developed in the Arduino IDE using C++. This includes password validation,
user feedback management, and error handling, such as implementing a temporary lockout after
multiple failed attempts to deter brute-force attacks.
Finally, the report explores the system’s performance, its various applications from domestic
to office environments, and its significant potential for future expansion. Enhancements such as
wireless connectivity, biometric integration, and access logging are discussed, highlighting the
system’s scalability and its role as a foundational project in the field of IoT and smart home
automation.

4
3 Introduction
3.1 Definition and Context
An electronic keypad door lock is an access control system that replaces the traditional mechan-
ical key with a numeric keypad. Users gain entry by inputting a correct personal identification
number (PIN) or password. This project, the "Keypad Door Lock with Arduino," is a practical
implementation of this concept, built using accessible, open-source hardware and software.
In the modern context, security is a paramount concern for homes, offices, and restricted
laboratories. While complex biometric and RFID systems exist, they often come at a high cost.
The Arduino-based keypad lock occupies a crucial middle-ground, offering a significant security
upgrade over mechanical locks while remaining affordable, customizable, and an excellent edu-
cational tool for understanding embedded systems. This system is a self-contained, offline access
control mechanism where the "authority" to grant access is decentralized to the device itself.

3.2 Historical Development

The concept of access control is ancient, but its electronic form is a 20th-century innovation.

• Early Mechanical Locks: For millennia, the pin-tumbler lock (popularized in the 19th
century) was the standard.

• Early Electronic Access: The 1960s saw the development of the first keypad-based
systems, often bulky and used in high-security government and corporate facilities. These
were hard-wired and extremely expensive.

• Microcontroller Revolution: The advent of microprocessors and later microcontrollers

in the 1970s and 1980s allowed for smaller, more intelligent, and more affordable standalone
units.

• The DIY/Maker Movement: The introduction of platforms like Arduino in the mid-
2000s democratized the creation of such systems. It allowed students, hobbyists, and
engineers to build and customize their own security solutions, integrating various sensors
and actuators with relative ease. This project stands on the shoulders of this movement.

3.3 Project Objectives

The primary goals for the design and implementation of this project are as follows:

1. To Design a Secure System: Develop a robust access control system that is resistant
to casual tampering and unauthorized entry.

2. To Implement a Reliable Mechanism: Build a functional prototype where the hard-

ware and software work in harmony to reliably grant or deny access based on the correct
password.

3. To Provide User-Friendly Feedback: Integrate an LCD display and auditory/visual

indicators (LEDs, buzzer) to create an intuitive user experience.

4. To Utilize Low-Cost Components: Construct the entire system using widely available
and affordable electronics, making it a viable DIY solution.

5. To Create a Scalable Platform: Design the system with a modular approach, allowing
for future upgrades such as wireless control, data logging, or biometric integration.

5
4 System Design and Working Principle
4.1 Core Principle: Authentication by PIN
The fundamental principle of this system is "knowledge-based authentication." Access is granted
based on something the user knowsin this case, a secret password. The system operates on a
simple but effective logical premise:

• The system stores a master password in its non-volatile memory (or, for this prototype,
hard-coded in the software).

• A user wishing to gain access must input a password via the keypad.

• The system compares the user’s input against the stored master password.

• If, and only if, the two passwords match exactly, the system authenticates the user and
triggers the "unlock" action.

• If the passwords do not match, the system denies access and records a failed attempt.

4.2 System Architecture

The system is designed around a central microcontroller (the Arduino) that orchestrates all
other peripherals. The architecture can be broken down into three main blocks: Input, Process,
and Output.

Figure 6: Block Diagram: Input-Process-Output Architecture

• Input Block: This consists solely of the 4x4 matrix keypad. It is the human-machine
interface (HMI) for providing the authentication credentials.

• Processing Block: The Arduino Uno is the entire processing block. It runs the control
loop that scans the keypad, stores the input, performs the password comparison, and
makes the decision to grant or deny access.

• Output Block: This block comprises all components that act on the Arduino’s decision:

– Lock Actuator: The servo motor (or solenoid) that physically moves the lock.

6
 – Visual Feedback: The 16x2 LCD display (showing status messages) and two LEDs
(Red for locked/denied, Green for unlocked/granted).
– Auditory Feedback: A piezo buzzer that provides audible confirmation of key
presses and system status (e.g., a long beep for success, a triple-beep for failure).

4.3 Workflow and State Diagram

The system operates as a finite state machine, constantly in one of several defined states.

1. IDLE / LOCKED State: This is the default state. The system is secure. The red
"Locked" LED is on, the servo is in the "locked" position (e.g., 0 degrees), and the LCD
displays "System Locked" or "Enter PIN:". The system actively scans the keypad for the
first key press.

2. INPUT State: When a user begins pressing keys, the system transitions to this state.
Each key press is stored in a temporary character array or string. The key press is echoed
to the LCD as an asterisk (’*’) to prevent "shoulder surfing." The buzzer beeps briefly for
each key press.

3. VALIDATION State: The user signals the end of their input by pressing a designated
key (e.g., ’#’). The system enters this state, where it compares the user’s input string
against the stored master password.

4. ACCESS GRANTED State: If the input matches the master password, the system
enters this temporary state.

• The red LED turns off, the green "Unlocked" LED turns on.
• The LCD displays "Access Granted".
• The buzzer plays a happy, success-tone.
• The Arduino sends a PWM signal to the servo to move to the "unlocked" position
(e.g., 90 or 180 degrees).
• The system pauses for a set duration (e.g., 5-7 seconds) to allow the user to open the
door.

5. ACCESS DENIED State: If the input does not match the master password, the system
enters this temporary state.

• The red LED flashes.

• The LCD displays "Access Denied".
• The buzzer plays a low, error-tone.
• The system increments a "failed attempt" counter.
• The system immediately returns to the IDLE / LOCKED state to await new input.

6. RELOCK Sequence: After the pause in the ACCESS GRANTED state, the system
automatically transitions back to the IDLE / LOCKED state by re-engaging the lock
(moving the servo back to 0 degrees), turning the green LED off, and turning the red LED
on.

7
4.4 Security Considerations
For a system of this nature, security is the primary design driver.

• Password Obfuscation: Displaying asterisks (’*’) on the LCD instead of the actual
digits entered is a critical, basic security feature.

• Password Storage: In this prototype, the password is hard-coded into the Arduino’s
program memory. In a more advanced system, this would be stored in the Arduino’s
EEPROM, allowing it to be changed without reprogramming the device.

• Brute-Force Mitigation: To prevent an attacker from rapidly trying all possible combi-
nations, a simple security feature is implemented. After a set number of consecutive failed
attempts (e.g., 3 or 5), the system enters a temporary "Lockout" state for a period (e.g.,
60 seconds), during which it will not accept any input. This exponentially increases the
time required to brute-force the password.

• Physical Security: The electronic components, especially the Arduino and wiring, must
be housed on the secure (internal) side of the door to prevent physical tampering.

8
5 Hardware and Software Implementation
5.1 Hardware Components (Detailed)
A careful selection of components is required to balance cost, reliability, and ease of use.

5.1.1 Microcontroller: Arduino Uno

The Arduino Uno, based on the ATmega328P microcontroller, is the "brain" of the project.
• Digital I/O Pins: It has 14 digital I/O pins, which are more than sufficient to interface
with the keypad (8 pins), LCD (I2C - 2 pins), servo (1 pin), LEDs (2 pins), and buzzer (1
pin).
• PWM Output: It features 6 pins capable of Pulse Width Modulation (PWM), which is
essential for the precise angular control of the servo motor.
• Power: It can be powered via USB or an external DC power supply (7-12V), which can
also be used to power the other peripherals like the servo.
• Ecosystem: Its vast libraries and strong community support drastically reduce develop-
ment time.

5.1.2 Input Device: 4x4 Matrix Keypad

This is the user’s primary input device.
• Design: It consists of 16 buttons arranged in a 4x4 grid. Internally, these buttons are
connected to a matrix of 4 rows and 4 columns.
• Operation: To read a key press, the Arduino must scan the keypad. It does this by
setting one row (or column) to HIGH (or LOW) at a time and then reading the state
of all columns (or rows). If a button is pressed, it will complete the circuit between its
corresponding row and column, allowing the Arduino to detect which key was pressed.
• Interfacing: This requires 8 digital pins from the Arduino (4 for rows, 4 for columns).

5.1.3 Locking Mechanism: Servo Motor (SG90 or MG996R)

The servo motor is the electromechanical component that performs the physical action of locking
or unlocking.
• Servo vs. Solenoid: A solenoid is a simple two-position (in/out) actuator. A servo
motor, however, allows for precise angular control. This is advantageous for adapting to
an existing deadbolt, as it can be programmed to rotate the exact amount needed (e.g.,
90 degrees) to turn the bolt. A high-torque servo (like the MG996R) is preferred over a
standard (SG90) for the force required to move a real lock.
• Control (PWM): The servo is controlled by a PWM signal. The width of the pulse, not
the voltage, dictates its position.
– A ~1ms pulse typically corresponds to 0 degrees (Locked).
– A ~1.5ms pulse corresponds to 90 degrees (Neutral).
– A ~2ms pulse corresponds to 180 degrees (Unlocked).
• Power: Servos can draw significant current, especially under load. It is critical to power
the servo from an external power supply, not from the Arduino’s 5V pin, to avoid system
instability and resets. The grounds, however, must be connected.

9
5.1.4 Feedback System: 16x2 I2C LCD Display
This display provides essential information to the user.

• I2C Interface: Using an I2C (Inter-Integrated Circuit) version of the LCD is highly
recommended. A standard 16x2 LCD requires 6 or more digital pins. The I2C module
(often a PCF8574 chip) attached to the back of the LCD acts as a "backpack," allowing the
Arduino to control the entire display using only two pins: SDA (Data) and SCL (Clock).

• Function: It is used to display prompts ("Enter PIN:"), status ("Access Granted"), and
errors ("Access Denied"), making the system far more user-friendly.

5.1.5 Indicators: LEDs and Piezo Buzzer

These simple components provide immediate, unambiguous feedback.

• LEDs: A red LED (connected to a digital pin via a 220Ω resistor) indicates the "Locked"
or "Error" state. A green LED (similarly connected) indicates the "Unlocked" state.

• Buzzer: A simple piezo buzzer provides auditory feedback. It can be driven from a digital
pin to create tones. This is used for key-press confirmation and for distinct success/failure
sounds.

10
5.2 Software Implementation
The software, or "sketch," is developed in the Arduino IDE using a simplified version of C++.
The logic is built around several key libraries.

5.2.1 Key Libraries

• Keypad.h: This is a standard library for interfacing with matrix keypads. It abstracts
the complex row/column scanning logic into simple function calls. It handles key presses,
holds, and provides a simple ‘[Link]()‘ function.

• Servo.h: This is the standard Arduino library for controlling servo motors. It simplifies
the generation of the precise PWM signals. Key functions include ‘[Link](pin)‘ and
‘[Link](angle)‘.

• LiquidCrystal_I2C.h: This library is used to communicate with the I2C-enabled LCD.

It provides simple commands like ‘[Link]()‘, ‘[Link]()‘, ‘[Link](col, row)‘,
and ‘[Link]("Message")‘.

5.2.2 Control Logic and Program Flow (Pseudocode)

Below is a high-level pseudocode representation of the main program loop.

// --- Includes ---

#include <Keypad.h>
#include <Servo.h>
#include <LiquidCrystal_I2C.h>

// --- Definitions ---

DEFINE MasterPassword = "1234"
DEFINE PasswordLength = 4
DEFINE ServoPin = 9
DEFINE GreenLedPin = 7
DEFINE RedLedPin = 8
DEFINE BuzzerPin = 6
DEFINE ServoLockedAngle = 0
DEFINE ServoUnlockedAngle = 90
DEFINE LockoutAttempts = 3
DEFINE LockoutDuration = 60000 // 60 seconds

// --- Global Variables ---

String currentInput = ""
int failedAttempts = 0

// --- Objects ---

Keypad myKeypad = ...
Servo myServo = ...
LiquidCrystal_I2C lcd = ...

// --- SETUP FUNCTION (Runs once) ---

FUNCTION setup():
Initialize LCD ([Link](), [Link]())
Initialize Servo ([Link](ServoPin))
Initialize LEDs/Buzzer as OUTPUT

11
 CALL lockDoor()
[Link]("System Locked")
DELAY(2000)
[Link]()
[Link]("Enter PIN:")

// --- MAIN LOOP FUNCTION (Runs forever) ---

FUNCTION loop():
char key = [Link]()

IF (key IS NOT NULL):

IF (key == ’*’):
CALL clearInput() // Reset function
ELSE IF (key == ’#’):
CALL checkPassword() // Validate function
ELSE:
// Append key to string and hide it
currentInput += key
[Link]("*")
PLAY_TONE(BuzzerPin, 500, 100) // key press beep
END IF
END IF

// --- HELPER FUNCTIONS ---

FUNCTION checkPassword():
IF (currentInput == MasterPassword):
CALL grantAccess()
ELSE:
CALL denyAccess()
END IF
CALL clearInput()

FUNCTION grantAccess():
failedAttempts = 0
[Link]()
[Link]("Access Granted!")
digitalWrite(GreenLedPin, HIGH)
digitalWrite(RedLedPin, LOW)
PLAY_TONE(BuzzerPin, 1000, 500) // Success beep

[Link](ServoUnlockedAngle)

DELAY(5000) // Hold door open for 5 seconds

CALL lockDoor()

FUNCTION denyAccess():
failedAttempts++
[Link]()
[Link]("Access Denied!")
digitalWrite(RedLedPin, HIGH) // Flash red

12
 PLAY_TONE(BuzzerPin, 300, 1000) // Error beep
DELAY(100)
digitalWrite(RedLedPin, LOW)

DELAY(2000)

IF (failedAttempts >= LockoutAttempts):

CALL systemLockout()
END IF

FUNCTION lockDoor():
[Link](ServoLockedAngle)
digitalWrite(GreenLedPin, LOW)
digitalWrite(RedLedPin, HIGH)
[Link]()
[Link]("Enter PIN:")

FUNCTION clearInput():
currentInput = ""
[Link](0, 1)
[Link](" ") // Clear second line
[Link](0, 1)

FUNCTION systemLockout():
[Link]()
[Link]("System Locked!")
[Link](0, 1)
[Link]("Try again later.")
digitalWrite(RedLedPin, HIGH)

DELAY(LockoutDuration) // Wait for 60 seconds

failedAttempts = 0
CALL lockDoor() // Reset to normal locked state

13
6 System Analysis and Performance
6.1 Key Performance Specifications
The evaluation of this system is based on several key metrics that define its effectiveness and
usability.

• Response Time: This is the latency between the user pressing the final password key
(’#’) and the system’s corresponding action (servo movement or error tone). In testing, this
is nearly instantaneous (< 100ms), as the ATmega328P can perform the string comparison
and initiate I/O commands very rapidly. The most significant "delay" is the physical time
it takes the servo to move, which is typically 1-2 seconds.

• Power Consumption:

– Idle State: The system’s idle power draw is minimal, dominated by the Arduino, the
LCD backlight, and the red "Locked" LED. This is typically in the 50-70mA range.
– Active State: Power consumption peaks when the servo motor is actuating. A high-
torque servo like the MG996R can have a stall current of over 2 Amperes, though its
operational current when moving a deadbolt is closer to 500-800mA. This peak draw
is transient, lasting only for the 1-2 seconds of servo movement. This highlights the
necessity of a robust external power supply (e.g., 5V, 2A).

• Reliability: The system’s reliability is contingent on its components.

– Software: The single-threaded control loop is extremely stable, as it does not rely on
complex interrupts or multitasking, eliminating risks of race conditions or deadlocks.
– Hardware: The primary points of failure are mechanical. The keypad buttons have
a finite life (e.g., >100,000 presses), but the most likely component to fail is the servo
motor, as its internal plastic or metal gears can wear down or strip over thousands
of cycles.

• Security Level: The system provides strong protection against casual, non-destructive
entry.

– Brute-Force Vulnerability: With a 4-digit numeric password, there are 104 (10,000)
possible combinations. Without a lockout, an attacker could try all combinations.
– Mitigation: With the implemented 3-attempt, 60-second lockout, an attacker can
only make 3 attempts per minute. To try all 10,000 combinations, it would take, on
average (5,000 attempts): (5000/3) × 1 minute ≈ 1667 minutes ≈ 27.7 hours This
makes brute-force attacks highly impractical. Increasing the password length to 6
digits (106 combinations) would make it effectively impossible.

6.2 Performance Testing Results

A test bench was created to validate the system’s functionality.
The system passed all functional tests, demonstrating its reliability and adherence to the
design specifications.

14
 Table 1: System Performance Test Results
Test Case Expected Outcome Actual Outcome
Enter Correct PIN Access Granted, Servo Unlock Pass
Enter Incorrect PIN (1st) Access Denied, Red Flash Pass
Enter Incorrect PIN (3rd) System Lockout for 60s Pass
Press ’*’ (Clear) Input buffer cleared Pass
Idle State (1 hour) System stable, remains locked Pass
Servo Load Test Servo successfully moves deadbolt Pass

7 Applications and Scope

7.1 Current Applications
The simplicity and low cost of this system make it adaptable for a wide variety of "light" to
"medium" security applications.

• Home Security: It is an ideal solution for interior doors, such as a home office, a personal
workshop, a wine cellar, or a closet used to store sensitive items. It provides a significant
step up from standard, non-locking door knobs.

• Office and Lab Access: In a small business or university setting, the system can be used
to secure rooms that are not intended for general public access, such as a server closet, a
supply room, or a research lab containing valuable equipment.

• Rental and Guest Access (e.g., Airbnb): The system is well-suited for short-term
rental properties. The host can change the password (by reprogramming the Arduino)
between guests, eliminating the problem of copied or unreturned physical keys.

• Secure Containers: The design can be scaled down to secure smaller containers, such
as a personal safe, a lockbox for documents, or a tool chest.

7.2 Scope for Future Enhancement

This project serves as a robust foundation for a much more advanced "smart lock" system. The
modular nature of the Arduino platform allows for numerous high-impact upgrades.

• Dynamic Password Management: The most critical upgrade would be to store the
password in the Arduino’s internal EEPROM. A "master" mode could be programmed,
allowing an administrator (by entering a master PIN) to change the user-level PIN directly
from the keypad, without needing to connect a computer and reprogram the device.

• Wireless Connectivity (IoT):

– Bluetooth: Adding a simple HC-05 or HC-06 Bluetooth module would allow the
lock to be controlled from a custom smartphone app, providing a secondary, wireless
method of entry.
– Wi-Fi: Replacing the Arduino Uno with an ESP8266 (like a NodeMCU) or ESP32
would connect the lock to the internet. This would enable powerful features like
remote unlocking from anywhere in the world, sending alerts (e.g., email or push
notification) on failed login attempts, and integrating with smart home systems like
Google Assistant or Amazon Alexa.

15
• Multi-Factor Authentication (MFA): Security could be dramatically enhanced by
adding a second authentication factor.

– RFID/NFC: An RFID reader (like the MFRC522) could be added, requiring the
user to both enter the correct PIN and scan a valid RFID card or fob.
– Biometrics: A fingerprint sensor (like the FPM10A/R307) could be integrated,
offering a highly secure and convenient "one-touch" entry method, either replacing or
supplementing the keypad.

• Access Logging: By adding an SD card module or using the Wi-Fi module to log to
a cloud database, the system could record a timestamp of every successful and failed
access attempt. This audit trail is invaluable for security monitoring in an office or lab
environment.

16
8 Conclusion
This project successfully achieved its objective of designing, building, and testing a secure, low-
cost keypad door lock system based on the Arduino platform. The final prototype functions
reliably, providing a user-friendly and effective method of access control that is a significant
improvement over traditional mechanical locks.
The system’s design, centered on an Arduino Uno, a matrix keypad, an I2C LCD, and
a servo motor, proved to be a robust and well-integrated solution. The software, developed
with standard Arduino libraries, effectively handles user input, password validation, and actu-
ator control. The inclusion of critical features like password obfuscation on the display and a
brute-force-mitigating lockout timer demonstrates a strong consideration for real-world security
principles, even in a prototype-level device.
The hardware implementation highlighted the importance of component selection, particu-
larly the need for a high-torque servo motor and an independent power supply to handle the
mechanical load of a physical lock. The software logic, built as a finite state machine, is stable
and responds instantly to user input, providing clear and immediate feedback for all actions.
More than just a standalone device, this project serves as a scalable and modular platform.
The ease with which it can be expandedto include wireless connectivity, biometric sensors,
or data loggingshowcases the power of the open-source hardware ecosystem. It demonstrates
that sophisticated electronic security is no longer the exclusive domain of high-cost commercial
products but can be achieved by students, hobbyists, and small businesses.
In conclusion, the Arduino-based keypad lock is a successful marriage of simple electronics,
straightforward programming, and practical mechanical actuation. It is a testament to the
versatility of the Arduino platform and a powerful example of how embedded systems can be
used to create tangible, useful, and intelligent solutions to everyday problems.

17
9 References
• Banzi, M. (2011). Getting Started with Arduino. O’Reilly Media/Make Books.

• Scherz, P., & Monk, S. (2016). Practical Electronics for Inventors (4th ed.). McGraw-Hill
Education.

• Monk, S. (2013). Programming Arduino Next Steps: Going Further with Sketches. McGraw-
Hill Education TAB.

• Arduino LLC. (2024). Official Arduino Language Reference. Retrieved from https://
[Link]/reference/en/

• SparkFun Electronics. (2020). Keypad Tutorial. Retrieved from [Link]

com/tutorials/keypad-tutorial

• Adafruit Industries. (2021). Adafruit Motor Selection Guide. Retrieved from https:
//[Link]/adafruit-motor-selection-guide/servo-motors

• Last Minute Engineers. (2022). Interfacing 16x2 I2C LCD with Arduino. Retrieved from
[Link]

• Bell, C. (2013). Beginning Sensor Networks with Arduino and Raspberry Pi. Apress.

• Anderson, R. (2020). Security Engineering: A Guide to Building Dependable Distributed

Systems (3rd ed.). Wiley.

• ATmega328P Datasheet. (2021). Microchip Technology Inc. Retrieved from https://

[Link]/downloads/en/DeviceDoc/Atmel-7810-Automotive-Microcontrollers-ATmega
[Link]

18