4 Solenoid combination lock

Hey Guys,

I'm just learning this stuff so bear with me if this is a total trainwreck...

I wanted to build a combination lock with 4 solenoid outputs so the user can enter one of 4 stored passwords and it and open whichever lock corresponds to that code.  I also want to make it so the master password can be entered allowing a change of password to any of the 4 lock combinations.  I started with the keypad combination program with lcd project i found on the dronebot youtube video and got that fully working.  

I tried to modify it but that totally didn't work and my knowledge of programming is beginner level, so I called my brother who knows some programming but isn't too familiar with C and he gave it a crack. I sent him the original code and he modified it.   That's the code posted here.  

The equipment I'm using is a 4x4 matrix keypad, lcd display with i2c backpack, arduino uno, 4 relay opto coupled (5V control), and 4 12V lock solenoids powered by a benchtop power supply.  

When I enter the correct master password into the program it will print "master password not supported yet" as intended.  

When I entered any of the pre programmed stored user passwords it prints "wrong password" then returns to the beginning of the loop.  I intended it to compare the input to a stored pw and output on the associated pin to relay.  

Any ideas?

/*
Matrix Keypad Combination Lock Demo
keypad-demo-lock.ino
Combination lock using 4x4 matrix membrane keypad with Arduino
Results on LCD display
Drives relay

DroneBot Workshop 2020
https://dronebotworkshop.com

Based upon code from https://www.circuitbasics.com/

*/

// Include Arduino Wire library for I2C
#include <Wire.h>
// Include LCD display library for I2C
#include <LiquidCrystal_I2C.h>
// Include Keypad library
#include <Keypad.h>
// EEPROM library
#include <EEPROM.h>

// Length of master_password password + 1 for null character
#define PASSWORD_LENGTH 8
// Character to hold master_password password input
char user_input[PASSWORD_LENGTH];

// Passwords
char master_password[PASSWORD_LENGTH] = "123A456";
#define NUM_USER_PASSWORDS 4
char user_passwords[NUM_USER_PASSWORDS][PASSWORD_LENGTH] = {"1111111", "2222222", "3333333", "4444444"};

// Pins connected to lock relay inputs. Pins 10-13 are available.
int lock_outputs[NUM_USER_PASSWORDS] = {10, 11, 12, 13};

// Counter for character entries
byte user_input_count = 0;

// Constants for row and column sizes
#define ROWS 4
#define COLS 4

// Array to represent keys on keypad
char hexaKeys[ROWS][COLS] = {
{'1', '2', '3', 'A'},
{'4', '5', '6', 'B'},
{'7', '8', '9', 'C'},
{'*', '0', '#', 'D'}
};

// Connections to Arduino
byte rowPins[ROWS] = {9, 8, 7, 6};
byte colPins[COLS] = {5, 4, 3, 2};

// Create keypad object
Keypad customKeypad = Keypad(makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS);

// Create LCD object
LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
// Setup LCD with backlight and initialize
lcd.init();
lcd.backlight();

// Set all lock_outputs as an OUTPUT pin
for (int output = 0; output++; output < NUM_USER_PASSWORDS) {
pinMode(lock_outputs[output], OUTPUT);
}

// Write the user passwords to EEPROM.
// For each password
for (int password_number = 0; password_number++; password_number < NUM_USER_PASSWORDS) {
// For each character in this password
int password_starting_address = password_number * PASSWORD_LENGTH;
for (int password_char = 0; password_char++; password_char < PASSWORD_LENGTH) {
int eeprom_address = password_starting_address + password_char;
// Write the current character to memory.
EEPROM.update(eeprom_address, user_passwords[password_number][password_char]);
}
}
}

// Loop forever.
void loop() {
// Initialize LCD and print
lcd.setCursor(0, 0);
lcd.print("Enter Password:");
digitalWrite(lock_outputs[0], HIGH);

// Look for keypress
readKeypad(user_input);

// See if we have reached the password length
if (user_input_count == PASSWORD_LENGTH - 1) {
lcd.clear();

// Compare the user-supplied password with stored passwords.
int match_found = checkPassword(user_input);

// Password is incorrect.
if (match_found < 0) {
lcd.print("Incorrect Password");
delay(1000);
}

// Clear user_input and LCD display
lcd.clear();
clearUserInput();
}
}

// Determine if the entered password is a match and do something if it is.
int checkPassword(char user_input[]) {
// If this is a master password match, do something...
if (!strcmp(user_input, master_password)) {
handleMasterPassword();
return 12345; // Just a random number.
}

// Check all the stored user passwords.
char storedUserPassword[PASSWORD_LENGTH];
for (int stored_password = 0; stored_password++; stored_password < NUM_USER_PASSWORDS) {

// Get the current stored password, one char at a time.
int password_starting_address = stored_password * PASSWORD_LENGTH;
for (int password_char = 0; password_char++; password_char < PASSWORD_LENGTH) {
int eeprom_address = password_starting_address + password_char;
// Write the current character to memory.
EEPROM.get(eeprom_address, storedUserPassword[password_char]);
}

// If this is a user match, open the proper relay.
if (!strcmp(user_input, storedUserPassword)) {
lcd.print("Dispensing Key!");
delay(5000);

int output_pin = lock_outputs[stored_password];

// Turn on relay for 5 seconds
digitalWrite(output_pin, LOW);
delay(5000);
digitalWrite(output_pin, HIGH);
return stored_password;
}
}

return -1;
}

void clearUserInput() {
// Go through array and clear user_input
while (user_input_count != 0) {
user_input[user_input_count--] = 0;
}
return;
}

// Handle a master password input.
void handleMasterPassword() {
lcd.print("Master Pass not supported yet");
delay(5000);
return false;

// TODO: Write some logic to enable the master password to program a user password slot.
lcd.print("Enter the user password number to set:");
int password_number = customKeypad.getKey();

if (setUserPassword(password_number)) {
lcd.print("Success!");
} else {
lcd.print("You suck!");
}
}

// Read input and set a new user password in the specified slot.
bool setUserPassword(int password_number) {
// Get the new password.
char message[64];
snprintf(message, sizeof(message), "Enter the user password for slot #%d", password_number);
lcd.print(message);
// Read `PASSWORD_LENGTH` keys
while (user_input_count < PASSWORD_LENGTH - 1) {
readKeypad(user_input);
}

// Validate passcode entry by getting the password again.
lcd.clear();
snprintf(message, sizeof(message), "Re-Enter the user password for slot #%d", password_number);
lcd.print(message);
// Read `PASSWORD_LENGTH` inputs
char user_input2[PASSWORD_LENGTH];
// Read `PASSWORD_LENGTH` keys
while (user_input_count < PASSWORD_LENGTH - 1) {
readKeypad(user_input2);
}

// Don't write to EEPROM if the passwords don't match.
if (strcmp(user_input, user_input2)) {
return false;
}

// Entry complete; write to EEPROM.
int password_starting_address = password_number * PASSWORD_LENGTH;
for (int password_char = 0; password_char++; password_char < PASSWORD_LENGTH) {
int eeprom_address = password_starting_address + password_char;
// Write the current character to memory.
EEPROM.update(eeprom_address, user_input[password_char]);
}

return true;
}

// Reads one character from the keypad into the `user_input` array.
void readKeypad(char input[]) {
// Look for keypress
char customKey = customKeypad.getKey();
if (customKey) {
// Enter keypress into array and increment counter
input[user_input_count] = customKey;
lcd.setCursor(user_input_count, 1);
lcd.print(input[user_input_count]);
user_input_count++;
}
}