Digital Safe Security System Development

Executive Summary

The Digital Safe project has been successful in its goal of developing a reliable and straightforward security system. The goal of this project is to create a safe that can store several user combinations, each of which must be at least eight digits long. Microchip ATmega32 microcontroller for user input, EEPROM for secure code storage, membrane keypads for input, and LEDs for visual feedback and status indicator all work together to make the safe function. By storing user codes in EEPROM, they are safe from corruption during power outages and firmware upgrades. Up to six users can log into the system at once, and a timeout feature prevents unauthorized access after several failed login attempts. Microchip's Studio 7 makes firmware code writing, development, and debugging easy. HCI design concepts helped us create an easy-to-use solution. Technical knowledge, innovative design, and rigorous security standards made this project successful, creating a safe and easy-to-use Digital Safe.

1 Introduction

As technology and security concerns have grown, the requirement for trustworthy access control solutions has expanded. This strategy is supported by the Digital Safe project, which seeks to create a high-tech, user-friendly, and secure digital safe that can store and handle multiple user combinations. This introduction discusses the project's context, goals, and importance.

1.1 Scope of the Project

The Hardware-Software Digital Safe project attempts to design a system that only authorized users can access stored codes and maintains them secret. A Microchip ATmega32 microprocessor, membrane keypads, an EEPROM for user codes, and LEDs for visual feedback and status information run the operation. The project integrates various aspects to make the safe reliable and usable.

1.2 Aim of the Project

The goal of this project is to create a secure and convenient digital safe. Objectives of the project:

• Secure Storage: Store up to six eight-digit user combinations safely. Encrypted storage uses EEPROM to prevent data loss during power cycles or firmware changes.
• User-Friendly Interface: Use a membrane keypad to input codes and LEDs for visual feedback. The system's lock state and user input visual feedback are crucial.
• Security Features: Block system access for a certain time if a user enters a wrong passcode three times. This security prohibits unauthorized entrance.
• Programming Mode: Allow authorized users to change their access codes without outside help.
• User Identification: Determine who is using the system so you may give them specialized information and limit others.
• Integration: Properly integrating project components creates a reliable and secure digital safe.

1.3 Significance of the Project:

Access control, embedded systems, and security advancements make the Digital Safe project remarkable. A user-friendly, secure digital safe is needed now that privacy and data protection are more important than ever. In addition to microcontroller programming, this project uses HCI ideas to create a simple interface. EEPROM is needed to save user codes over time, hence the study examines its durability.

The Digital Safe project uses embedded technologies to teach user-centric design and safe access management. The next sections will explain the project's relevance and evolution by examining its technical aspects and concepts.

2 Background Study

In today's technologically advanced world, the creation of access control systems that are both safe and easy to use is an endeavour that is of the utmost importance. One such application is the Digital Safe, which is a storage device that allows only authorized users access to the assets or sensitive information that it stores. The goal of the Digital Safe project is to develop a safe that is able to safely store the combination information for a number of different users. This background research dives into essential technical and theoretical components that are necessary for comprehending the project's foundations in order to provide an accurate picture.

2.1 Microcontroller-Based Systems

Many contemporary applications, such as access control systems like the Digital Safe, are powered by embedded systems that are driven by microcontrollers. At the core of many current applications is the "Embedded System." According to Atmel Corporation (2005), the ATmega32 microcontroller, which is a member of the AVR family, was selected to serve as the central component of the project because of its dependability, adaptability, and abundant on-chip resources.

The ATmega32 has a number of features, including EEPROM memory, GPIO (General Purpose Input/Output) pins, timers, and UART (Universal Asynchronous Receiver-Transmitter), as well as an 8-bit RISC architecture. According to Atmel Corporation (2005), the safe would not be able to function without these components since they enable code storage, human interaction, and communication.

2.2 Membrane Keypads

To a significant extent, membrane keypads are required for user interaction with the Digital Safe. According to Hernandez (2018), the low profile, durability, and cost-effectiveness of membrane keypads have contributed to their widespread use. These keypads include numerous layers, each of which contains electrical traces, as well as a membrane that is responsive to pressure. It is possible to register a keypress by pressing a key, which causes a gap between the conductive traces to be bridged when the key is pushed.

It is very necessary, in order to successfully integrate membrane keypads into the system, to have an understanding of their pinout, wiring, and matrix structure. According to MikroElektronika (2019), the paperwork and datasheets provided by manufacturers give extremely helpful insights about these topics.

2.3 EEPROM for Secure Code Storage

A primary need for the functioning of the Digital Safe is the safekeeping of user access codes. When it comes to non-volatile data storage, EEPROM (Electrical Erasable Programmable Memory) is the storage medium of choice. According to Atmel Corporation (2005), it permits the electrical writing and erasing of data, which ensures the data's permanence even after power cycles.

Because the ATmega32 microcontroller incorporates an EEPROM memory block, it is simple and straightforward to save user codes in a protected environment. According to Atmel Corporation's research from 2005, having a solid grasp of the EEPROM write and read operations, addressing techniques, and durability characteristics is essential for efficient code storage.

2.4 LED Displays for Visual Feedback

LEDs, which stand for light-emitting diodes, play a vital part in both the user feedback and the system status indicating processes. LEDs have a low power consumption, a long lifespan, and are simple for microcontrollers to operate. LEDs are utilized in the Digital Safe to display the entered numbers as well as indicate the state of user locks, which may be either locked or unlocked.

According to Pletcher and Cutler (2017), efficient implementation requires a comprehensive knowledge of LED interface, multiplexing methods, and the application of current-limiting resistors. In addition, choosing the right LED kinds and specifications is essential for achieving optimal performance (MikroElektronika, 2020).

2.5 Code Validation and Security

When it comes to access control systems like Digital Safe, security is of the utmost importance. The use of code validation procedures helps to prevent unwanted access by ensuring that input codes are consistent with stored codes. A timeout mechanism provides an extra layer of security by preventing users from accessing the system after a certain number of unsuccessful tries.

According to Schneier (1996), having knowledge of coding techniques and the construction of algorithms for code validation is vital. Even though more complex security measures such as hashing and cryptographic techniques are applicable in some cases, the project chooses to use a more straightforward approach to code validation. According to Anderson (2008), timeout mechanisms draw their motivation from traditional security systems.

2.6 Programming Environments

The integrated development environment (IDE) for AVR microcontrollers known as Microchip Studio 7 is going to serve as the primary tool for authoring, building, and debugging firmware code. It is very necessary, in order to build projects quickly and effectively, to have a solid understanding of the IDE as well as its interface with the ATmega32.

Microchip Technology Inc. cites the official documentation and lessons offered by Microchip Studio 7 as useful references (Microchip Technology Inc., 2021). According to MikroElektronika (2019), one may learn AVR-specific toolchains, libraries, and debugging procedures by consulting online resources and participating in community forums.

2.7 User Experience and Human-Computer Interaction (HCI)

When creating the user interface for the Digital Safe, it is essential to consider both the user experience as well as the concepts of Human-Computer Interaction (HCI). (Shneiderman, 2016) Concepts like feedback systems, input validation, and intuitive user interfaces contribute to the safe's user-friendliness and accessibility.

According to Dix et al. (2004), the human-computer interaction literature, user interface design principles, and best practices in usability engineering give advice in the process of developing a safe that has an interface that is both user-friendly and secure.

2.8 Multiple User Support and System Architecture

The architecture of the Digital Safe project is meant to allow several users, each of which will have their own unique access code. Important factors to consider during the design phase of a system include effectively managing user data and maintaining data isolation.

According to Hoffer et al. (2012), decisions on data structures and access control within the project are informed by general software architectural principles, ideas of database management, and literature about the design of multi-user systems.

A complete understanding of microcontroller-based systems, user input through keypad, safe code storage, visual feedback via LEDs, code validation, and user experience design concepts is required for the creation of the Digital Safe project. In addition, an expert level of knowledge in the programming environment of Microchip Studio 7 is required. Digital Safe seeks to achieve its goal of developing an access control system that is safe, user-friendly, and effective by combining these many theoretical and practical underpinnings.

In the next sections of this report on the project, we will investigate the design, execution, obstacles, and outcomes of Digital Safe, illustrating how these background insights were applied to accomplish the project's aims to be successful.

3 Technical Work and Results

The goal of the Digital Safe project was to develop a trustworthy digital safe by employing an ATmega32 microcontroller, a membrane keypad for the user's input, and LEDs for the user to get response from the safe. The following sections detail the technical work that was completed as well as the outcomes that were obtained:

3.1 The initialization of the hardware:

The project started off by putting the gear through its first setup. The ATmega32 microcontroller was utilized, and its input and output ports were programmed to take input from a keypad and provide LED output respectively. The code made sure that all of the LEDs were off to begin with, establishing a fresh state.

3.2 User Code Management:

The management of user codes was at the centre of the digital safe's primary operation. It was possible for up to six individuals to save their own unique eight-digit codes. These codes were written into the EEPROM memory so that they would remain intact even after power cycles or modifications to the firmware. To reading and writing user codes to EEPROM, the readUserCode and writeUserCode methods were developed and implemented. A programming mode was also available for users to utilize in order to alter their codes.

3.3 Keypad Input Handling:

It was necessary to input codes using the membrane keypad. The readKeypad function would scan the keypad matrix to check for any key presses. To determine which key had been depressed, it used a matrix-based method and then returned the appropriate character. Users were able to enter their codes in a safe manner because to this capability.

3.4 LED Feedback:

LEDs were used to offer users feedback on their actions. Every individual has their very own individual LED that indicated whether their lock was open or closed. In addition to that, there were eight LEDs utilized for the purpose of displaying the digits that were being input on the keypad. The displayUserLEDs function was responsible for controlling the user-specific LEDs and either locking or unlocking the safe associated with the appropriate user. The LED array displays the inputted digits thanks to the displayDigitLEDs function.

3.5 User Authentication and Timeout:

The validate Code method was used to check if the user codes were correct. The user was permitted access, and their LED would signal a successful unlock if the code entered matched one of the user codes that had been previously recorded. If an incorrect code was input, the safe would indicate an error and then wait the specified amount of time before allowing another try.

3.6 Programming Mode:

The project incorporated a programming mode that enables users with the appropriate permissions to alter their programs. Users were able to enter their new eight-digit code using the keypad when they were in programming mode. After successfully entering the code, the LED on their device would flash to signify success, and the EEPROM would be updated with the new code. This innovation offered an additional degree of protection while also improving the user experience.

3.7 Results and Achievements:

The Digital Safe initiative was effective in achieving most of its primary goals. It offered a safe way for up to six users to save and retrieve their digital codes and allowed easy access to those codes. The LED feedback mechanism of the safe efficiently conveyed the lock state, and the timeout function boosted security by limiting the number of erroneous codes entering attempts.

4 Discussion and Conclusion

After much hard work, the Digital Safe project team has created a reliable and straightforward digital safe solution. In this section, we'll go through what we accomplished, what we learned, and where we can go from here.

4.1 Achievements:

Secure User Code Management: The project-maintained user codes securely, enabling up to six users to save and access eight-digit codes in an encrypted manner. The EEPROM storage of user codes ensured their durability during reboots and firmware upgrades.

User-Friendly Keypad Input: Entering access codes using a membrane keypad was a simple and straightforward process. The scanning mechanism of the keypad, based on a matrix, properly identified keystrokes, which greatly improved the user experience.

Clear LED Feedback: Users received unambiguous feedback thanks to the usage of LEDs. There was an individual LED for each user, which lit up in response to the lock being in the locked or unlocked position. In addition, an array of LEDs displayed the entered numbers, making the process of entering a code straightforward.

User Authentication and Timeout: A timeout mechanism and verified user codes prevented unwanted access. This reinforced the system's defenses against brute-force attacks.

Programming Mode: In the programming mode, a user with the proper permissions can modify their own code. Users now have the extra convenience of being able to change their own access codes whenever they choose.

4.2 Lessons Learned:

EEPROM Management: Proper preparation is required for managing EEPROM memory, particularly in the areas of addressing and data validation. To protect the integrity of the code, the team learnt how to read and write to EEPROM more quickly and effectively.

User Interface Design: The project stressed the value of a user-friendly interface design. While the usage of a keypad for input and an LED display for response worked well, there is room for improvement in the user interface.

Code Validation: While the current process of code validation is useful, it has room for improvement. Future revisions may incorporate enhanced security measures like rate restriction and temporary lockouts for incorrect login attempts.

4.3 Possible Future Works:

Future efforts may concentrate on developing additional security measures for the digital vault. To better safeguard user codes, it may be necessary to employ multi-factor authentication, encryption, or biometric recognition technologies.

User Management: Admins can add or delete users by integrating user management features into the system. This is helpful if you need to regulate user access on the go.

Adding the ability to remotely access and monitor the digital safe would significantly increase its usefulness. Remote access and alerts on intrusion attempts were available to safe owners.

The programming mode might be upgraded to provide for more sophisticated code recovery options and time-based code modifications.

Digital Safe has successfully completed its key goals of providing safe code storage and access management. With the right hardware and the right software, it is possible to create a digital safe that works. In the future, projects involving safe access control systems can benefit from the insights gained during this one. To adapt to shifting requirements and user expectations, future work can improve security and user control capabilities.

References

Anderson, R. (2008). Security Engineering: A Guide to Building Dependable Distributed Systems. Wiley.

Atmel Corporation. (2005). ATmega32A [Data Sheet]. https://www.microchip.com/wwwproducts/en/ATmega32A

Dix, A., Finlay, J., Abowd, G. D., & Beale, R. (2004). Human-Computer Interaction. Pearson.

Hernandez, A. (2018). Membrane Keypad Tutorial for Arduino, Raspberry Pi, and MSP430. Electronics-Lab. https://www.electronics-lab.com/project/membrane-keypad-tutorial-arduino-raspberry-pi-msp430/

Hoffer, J. A., Ramesh, V., & Topi, H. (2012). Modern Database Management. Pearson.

MikroElektronika. (2019). Keypad 4x4 Board. https://www.mikroe.com/keypad-4x4-board

MikroElektronika. (2020). LED 7-segment displays. [https://www.mikroe.com/led-7-segment-displays](https://www.mikroe.com/led-7-se

Appendix

#include <avr/io.h>

#include <avr/eeprom.h>

#include <util/delay.h>

#include <string.h>

#define KEYPAD_PORT PORTA

#define KEYPAD_PIN PINA

#define KEYPAD_DDR DDRA

#define LED_PORT PORTB

#define LED_DDR DDRB

#define LED_PORT1 PORTD

#define LED_DDR1 DDRD

#define MAX_USERS 6

#define CODE_LENGTH 8

#define TIMEOUT_DURATION 5000

#define LED_USER1 PB0

#define LED_USER2 PB1

#define LED_USER3 PB2

#define LED_USER4 PB3

#define LED_USER5 PB4

#define LED_USER6 PB5

#define LED_DIGIT1 PD0

#define LED_DIGIT2 PD1

#define LED_DIGIT3 PD2

#define LED_DIGIT4 PD3

#define LED_DIGIT5 PD4

#define LED_DIGIT6 PD5

#define LED_DIGIT7 PD6

#define LED_DIGIT8 PD7

char userCodes[MAX_USERS][CODE_LENGTH];

char enteredCode[CODE_LENGTH];

int currentUser = -1;

int programmingMode = 0;

void readUserCode(int userIndex, char* code) {

// Calculate the EEPROM address for the given user index

uint16_t eepromAddress = userIndex * CODE_LENGTH;

// Read the user code from EEPROM

eeprom_read_block((void*)code, (const void*)eepromAddress, CODE_LENGTH);

}

void initialize() {

// Initialize keypad pins

KEYPAD_DDR = 0xF0; // Columns as inputs, rows as outputs

KEYPAD_PORT = 0x0F; // Enable pull-up resistors on rows

// Initialize LED pins

LED_DDR = 0xFF; // Set all LED pins as outputs

LED_PORT = 0x00; // Turn off all LEDs

LED_DDR1 = 0xFF; // Set all LED pins as outputs

LED_PORT1 = 0x00; // Turn off all LEDs

// Load user codes from EEPROM into userCodes

for (int i = 0; i < MAX_USERS; i++) {

readUserCode(i, userCodes[i]);

}

// Additional peripheral initialization as needed

}

void writeUserCode(int userIndex, char* code) {

// Calculate the EEPROM address for the given user index

uint16_t eepromAddress = userIndex * CODE_LENGTH;

// Write the user code to EEPROM

eeprom_write_block((const void*)code, (void*)eepromAddress, CODE_LENGTH);

}

char readKeypad() {

// Define the keypad matrix and corresponding keys

char keypadKeys[4][4] = {

{'1', '2', '3', 'A'},

{'4', '5', '6', 'B'},

{'7', '8', '9', 'C'},

{'*', '0', '#', 'D'}

};

// Set the columns as inputs and pull them high

KEYPAD_DDR |= 0x0F; // Set the lower 4 bits as outputs

KEYPAD_PORT |= 0xF0; // Pull-up resistors for the upper 4 bits

// Iterate through the rows and check for key presses

for (int row = 0; row < 4; row++) {

// Enable one row at a time and check the columns

KEYPAD_PORT = (KEYPAD_PORT & 0xF0) | (0x01 << row);

// Check the columns for a low signal (key press)

for (int col = 4; col < 8; col++) {

if (!(KEYPAD_PIN & (1 << col))) {

// Key pressed, return the corresponding character

return keypadKeys[row][col - 4];

}

}

}

// No key pressed

return '\0';

}

void initializeLEDs() {

// Set LED pins as outputs

DDRB |= (1 << LED_USER1) | (1 << LED_USER2) | (1 << LED_USER3) |

(1 << LED_USER4) | (1 << LED_USER5) | (1 << LED_USER6) |

(1 << LED_DIGIT1) | (1 << LED_DIGIT2);

// Turn off all LEDs initially

PORTB &= ~((1 << LED_USER1) | (1 << LED_USER2) | (1 << LED_USER3) |

(1 << LED_USER4) | (1 << LED_USER5) | (1 << LED_USER6) |

(1 << LED_DIGIT2) | (1 << LED_DIGIT3) | (1 << LED_DIGIT4) | (1 << LED_DIGIT5) |

(1 << LED_DIGIT6) | (1 << LED_DIGIT7) | (1 << LED_DIGIT8));

}

void displayUserLEDs(int userIndex, char status)

{

switch (status) {

case 0:

// Lock the user (Turn off LED)

LED_PORT &= ~(1 << userIndex);

break;

case 1:

// Unlock the user (Turn on LED)

LED_PORT |= (1 << userIndex);

break;

default:

// Invalid status

break;

}

}

void displayDigitLEDs(char digit)

{

const uint8_t digitPatterns[10] =

{

0b00111111, // 0

0b00000110, // 1

0b01011011, // 2

0b01001111, // 3

0b01100110, // 4

0b01101101, // 5

0b01111101, // 6

0b00000111, // 7

0b01111111, // 8

0b01101111 // 9

};

if (digit >= '0' && digit <= '9')

{

int digitIndex = digit - '0';

uint8_t segmentPattern = digitPatterns[digitIndex];

DDRD = 0xFF;

PORTD = segmentPattern;

}

}

int validateCode(char* code) {

// Implement code to validate the entered code

for (int i = 0; i < MAX_USERS; i++) {

if (strcmp(code, userCodes[i]) == 0) {

return i; // Return the user index if code is valid

}

}

return -1; // Code is invalid

}

void changeUserCode(int userIndex) {

char newCode[CODE_LENGTH];

// Get the new code from the user via the keypad (customize this part)

for (int i = 0; i < CODE_LENGTH; i++) {

newCode[i] = readKeypad();

// Display the entered digit on the digit LEDs

displayDigitLEDs(newCode[i]);

_delay_ms(500); // Delay to show the digit

}

// Write the new code to EEPROM for the specified user

writeUserCode(userIndex, newCode);

// Optionally, provide feedback to the user

displayUserLEDs(userIndex, 1); // Indicate success (customize this part)

// Delay to show success feedback (customize this part)

_delay_ms(1000);

// Turn off the LED for the specified user

displayUserLEDs(userIndex, 0);

}

int main() {

initialize();

int programmingUser = -1; // User index for programming mode

while (1) {

char keyPressed = readKeypad();

if (keyPressed != '\0') {

// Handle keypad input

if (currentUser == -1) {

// Determine the current user (not implemented in this code)

// Check if a programming mode key is pressed (e.g., '*' and '#')

if (keyPressed == '*' && programmingUser != -1) {

programmingMode = 1;

}

// Display user selection logic here (not implemented in this code)

} else {

// Check for programming mode key

if (programmingUser != -1 && keyPressed == '#') {

programmingMode = 1;

}

// Process the entered code

enteredCode[strlen(enteredCode)] = keyPressed;

// Check for code completion

if (strlen(enteredCode) <= CODE_LENGTH) {

int userIndex = validateCode(enteredCode);

if (userIndex != -1) {

// Code is valid, unlock the safe and indicate the user

displayUserLEDs(userIndex, 1);

currentUser = userIndex;

} else {

// Code is invalid, display error and reset

displayUserLEDs(currentUser, 0);

_delay_ms(TIMEOUT_DURATION);

}

}

// Clear entered code when it reaches the maximum length

if (strlen(enteredCode) == CODE_LENGTH) {

memset(enteredCode, 0, CODE_LENGTH);

}

// Check for programming mode exit

if (programmingMode && keyPressed == '*') {

programmingMode = 0;

}

// Enter programming mode if user is authorized

if (programmingMode && programmingUser != -1) {

changeUserCode(programmingUser);

programmingMode = 0; // Exit programming mode

}

}

}

}

return 0;

}