Keypad Door Lock with Changeable Code

Control a solenoid/relay or whatever your locking system, and change the passcode by the keypad only, no program reupload.

Apr 14, 2019

•

76240 views

•

41 respects

Components and supplies

Generic push button

1 Channel Relay

4x4 Keypad Matrix

LCD i²c

Arduino UNO

Linear solenoid lock

IRF510N MOSFET

Tools and machines

Breadboard, 170 Pin

10 Pc. Jumper Wire Kit, 5 cm Long

Project description

Code

Keypad_doorlock_solenoid.ino

arduino

Remember to upload the code first then uncomment line 62 to 64 and reupload, it's done only once.

1/* This code works with 4x4 Keypad Matrix, LCD ic, IRF510N transistor   and a push button
2 * It's a lock where the transistor drives a solenoid lock   you can open either with correct code
3 * or by the push button from inside
4   * The code can be changed directly by the keypad and doesn't require uploading code   again
5 * Code is stored in EEPROM
6 * Refer to www.surtrtech.com for more details   
7 */
8
9#include <Keypad.h>
10#include <EEPROM.h>
11#include <LiquidCrystal_I2C.h>
12
13#define   Solenoid 11             //Actually the Gate of the transistor that controls the   solenoid
14#define O_Button 10             //Push Button
15
16#define I2C_ADDR   0x27           //I2C adress, you should use the code to scan the adress first (0x27)   here
17#define BACKLIGHT_PIN 3         // Declaring LCD Pins
18#define En_pin   2
19#define Rw_pin 1
20#define Rs_pin 0
21#define D4_pin 4
22#define D5_pin   5
23#define D6_pin 6
24#define D7_pin 7
25
26const byte numRows= 4;          //number   of rows on the keypad
27const byte numCols= 4;          //number of columns on   the keypad
28
29char keymap[numRows][numCols]= 
30{
31{'1', '2', '3', 'A'},   
32{'4', '5', '6', 'B'}, 
33{'7', '8', '9', 'C'},
34{'*', '0', '#', 'D'}
35};
36
37char   keypressed;                 //Where the keys are stored it changes very often
38char   code[]= {'6','6','0','1'};  //The default code, you can change it or make it a 'n'   digits one
39
40char code_buff1[sizeof(code)];  //Where the new key is stored
41char   code_buff2[sizeof(code)];  //Where the new key is stored again so it's compared   to the previous one
42
43short a=0,i=0,s=0,j=0;          //Variables used later
44
45byte   rowPins[numRows] = {9,8,7,6}; //Rows 0 to 3 //if you modify your pins you should   modify this too
46byte colPins[numCols]= {5,4,3,2}; //Columns 0 to 3
47
48LiquidCrystal_I2C   lcd(I2C_ADDR,En_pin,Rw_pin,Rs_pin,D4_pin,D5_pin,D6_pin,D7_pin);
49Keypad myKeypad=   Keypad(makeKeymap(keymap), rowPins, colPins, numRows, numCols);
50
51void setup()
52          {
53          lcd.begin (16,2);
54          lcd.setBacklightPin(BACKLIGHT_PIN,POSITIVE);
55           lcd.setBacklight(HIGH); //Lighting backlight
56          lcd.home ();
57           lcd.print("Standby");      //What's written on the LCD you can change
58           
59          pinMode(Solenoid,OUTPUT);
60          pinMode(O_Button,INPUT);
61                       
62//          for(i=0 ; i<sizeof(code);i++){        //When   you upload the code the first time keep it commented
63//            EEPROM.get(i,   code[i]);             //Upload the code and change it to store it in the EEPROM
64//              }                                  //Then uncomment this for loop and   reupload the code (It's done only once)
65
66         }
67
68
69void loop()
70{
71
72   keypressed = myKeypad.getKey();               //Constantly waiting for a key to   be pressed
73    if(keypressed == '*'){                      // * to open the lock
74             lcd.clear();
75            lcd.setCursor(0,0);
76            lcd.print("Enter   code");            //Message to show
77            GetCode();                          //Getting   code function
78                  if(a==sizeof(code))           //The GetCode function   assign a value to a (it's correct when it has the size of the code array)
79                  OpenDoor();                    //Open lock function if code is correct
80                  else{
81                   lcd.clear();               
82                  lcd.print("Wrong");           //Message to print when the code is wrong
83                  }
84            delay(2000);
85             lcd.clear();
86            lcd.print("Standby");             //Return   to standby mode it's the message do display when waiting
87        }
88
89     if(keypressed   == '#'){                  //To change the code it calls the changecode function
90       ChangeCode();
91      lcd.clear();
92      lcd.print("Standby");                 //When   done it returns to standby mode
93     }
94
95     if(digitalRead(O_Button)==HIGH){       //Opening by the push button
96       digitalWrite(Solenoid,HIGH);
97       delay(3000);                         //Opens for 3s you can change
98       digitalWrite(Solenoid,LOW);
99      
100     }
101         
102}
103
104void GetCode(){                  //Getting   code sequence
105       i=0;                      //All variables set to 0
106       a=0;
107        j=0; 
108                                     
109     while(keypressed !=   'A'){                                     //The user press A to confirm the code   otherwise he can keep typing
110           keypressed = myKeypad.getKey();                         
111              if(keypressed != NO_KEY && keypressed != 'A' ){       //If the char   typed isn't A and neither "nothing"
112              lcd.setCursor(j,1);                                  //This   to write "*" on the LCD whenever a key is pressed it's position is controlled   by j
113              lcd.print("*");
114              j++;
115            if(keypressed   == code[i]&& i<sizeof(code)){            //if the char typed is correct a and i   increments to verify the next caracter
116                 a++;                                              //Now   I think maybe I should have use only a or i ... too lazy to test it -_-'
117                 i++;
118                  }
119            else
120                a--;                                               //if   the character typed is wrong a decrements and cannot equal the size of code []
121             }
122            }
123    keypressed = NO_KEY;
124
125}
126
127void   ChangeCode(){                      //Change code sequence
128      lcd.clear();
129       lcd.print("Changing code");
130      delay(1000);
131      lcd.clear();
132       lcd.print("Enter old code");
133      GetCode();                      //verify   the old code first so you can change it
134      
135            if(a==sizeof(code)){       //again verifying the a value
136            lcd.clear();
137            lcd.print("Changing   code");
138            GetNewCode1();            //Get the new code
139            GetNewCode2();             //Get the new code again to confirm it
140            s=0;
141              for(i=0   ; i<sizeof(code) ; i++){     //Compare codes in array 1 and array 2 from two previous   functions
142              if(code_buff1[i]==code_buff2[i])
143              s++;                                 //again this how we verifiy, increment s whenever   codes are matching
144              }
145                  if(s==sizeof(code)){             //Correct is always the size of the array
146                  
147                    for(i=0 ; i<sizeof(code) ; i++){
148                  code[i]=code_buff2[i];          //the code array now receives the new code
149                  EEPROM.put(i,   code[i]);        //And stores it in the EEPROM
150                  
151                  }
152                   lcd.clear();
153                  lcd.print("Code Changed");
154                   delay(2000);
155                  }
156                  else{                          //In case the new codes aren't matching
157                  lcd.clear();
158                   lcd.print("Codes are not");
159                  lcd.setCursor(0,1);
160                   lcd.print("matching !!");
161                  delay(2000);
162                   }
163            
164          }
165          
166          else{                      //In case the old code is wrong you can't change it
167          lcd.clear();
168           lcd.print("Wrong");
169          delay(2000);
170          }
171}
172
173void   GetNewCode1(){                      
174  i=0;
175  j=0;
176  lcd.clear();
177  lcd.print("Enter   new code");   //tell the user to enter the new code and press A
178  lcd.setCursor(0,1);
179   lcd.print("and press A");
180  delay(2000);
181  lcd.clear();
182  lcd.setCursor(0,1);
183   lcd.print("and press A");     //Press A keep showing while the top row print   ***
184             
185         while(keypressed != 'A'){            //A to confirm   and quits the loop
186             keypressed = myKeypad.getKey();
187               if(keypressed   != NO_KEY && keypressed != 'A' ){
188                lcd.setCursor(j,0);
189                lcd.print("*");                //On the new code you can show * as I did or change it to keypressed   to show the keys
190                code_buff1[i]=keypressed;     //Store caracters   in the array
191                i++;
192                j++;                    
193                 }
194                }
195keypressed = NO_KEY;
196}
197
198void   GetNewCode2(){                         //This is exactly like the GetNewCode1 function   but this time the code is stored in another array
199  i=0;
200  j=0;
201  
202   lcd.clear();
203  lcd.print("Confirm code");
204  lcd.setCursor(0,1);
205  lcd.print("and   press A");
206  delay(3000);
207  lcd.clear();
208  lcd.setCursor(0,1);
209  lcd.print("and   press A");
210
211         while(keypressed != 'A'){
212             keypressed   = myKeypad.getKey();
213               if(keypressed != NO_KEY && keypressed !=   'A' ){
214                lcd.setCursor(j,0);
215                lcd.print("*");
216                 code_buff2[i]=keypressed;
217                i++;
218                j++;                     
219                }
220                }
221keypressed = NO_KEY;
222}
223
224void   OpenDoor(){             //Lock opening function open for 3s
225  lcd.clear();
226   lcd.print("Welcome");       //With a message printed
227  digitalWrite(Solenoid,HIGH);
228   delay(3000);
229  digitalWrite(Solenoid,LOW);
230}
231
232

/* This code works with 4x4 Keypad Matrix, LCD ic, IRF510N transistor   and a push button
 * It's a lock where the transistor drives a solenoid lock   you can open either with correct code
 * or by the push button from inside
   * The code can be changed directly by the keypad and doesn't require uploading code   again
 * Code is stored in EEPROM
 * Refer to www.surtrtech.com for more details   
 */

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

#define   Solenoid 11             //Actually the Gate of the transistor that controls the   solenoid
#define O_Button 10             //Push Button

#define I2C_ADDR   0x27           //I2C adress, you should use the code to scan the adress first (0x27)   here
#define BACKLIGHT_PIN 3         // Declaring LCD Pins
#define En_pin   2
#define Rw_pin 1
#define Rs_pin 0
#define D4_pin 4
#define D5_pin   5
#define D6_pin 6
#define D7_pin 7

const byte numRows= 4;          //number   of rows on the keypad
const byte numCols= 4;          //number of columns on   the keypad

char keymap[numRows][numCols]= 
{
{'1', '2', '3', 'A'},   
{'4', '5', '6', 'B'}, 
{'7', '8', '9', 'C'},
{'*', '0', '#', 'D'}
};

char   keypressed;                 //Where the keys are stored it changes very often
char   code[]= {'6','6','0','1'};  //The default code, you can change it or make it a 'n'   digits one

char code_buff1[sizeof(code)];  //Where the new key is stored
char   code_buff2[sizeof(code)];  //Where the new key is stored again so it's compared   to the previous one

short a=0,i=0,s=0,j=0;          //Variables used later

byte   rowPins[numRows] = {9,8,7,6}; //Rows 0 to 3 //if you modify your pins you should   modify this too
byte colPins[numCols]= {5,4,3,2}; //Columns 0 to 3

LiquidCrystal_I2C   lcd(I2C_ADDR,En_pin,Rw_pin,Rs_pin,D4_pin,D5_pin,D6_pin,D7_pin);
Keypad myKeypad=   Keypad(makeKeymap(keymap), rowPins, colPins, numRows, numCols);

void setup()
          {
          lcd.begin (16,2);
          lcd.setBacklightPin(BACKLIGHT_PIN,POSITIVE);
           lcd.setBacklight(HIGH); //Lighting backlight
          lcd.home ();
           lcd.print("Standby");      //What's written on the LCD you can change
           
          pinMode(Solenoid,OUTPUT);
          pinMode(O_Button,INPUT);
                       
//          for(i=0 ; i<sizeof(code);i++){        //When   you upload the code the first time keep it commented
//            EEPROM.get(i,   code[i]);             //Upload the code and change it to store it in the EEPROM
//              }                                  //Then uncomment this for loop and   reupload the code (It's done only once)

         }


void loop()
{

   keypressed = myKeypad.getKey();               //Constantly waiting for a key to   be pressed
    if(keypressed == '*'){                      // * to open the lock
             lcd.clear();
            lcd.setCursor(0,0);
            lcd.print("Enter   code");            //Message to show
            GetCode();                          //Getting   code function
                  if(a==sizeof(code))           //The GetCode function   assign a value to a (it's correct when it has the size of the code array)
                  OpenDoor();                    //Open lock function if code is correct
                  else{
                   lcd.clear();               
                  lcd.print("Wrong");           //Message to print when the code is wrong
                  }
            delay(2000);
             lcd.clear();
            lcd.print("Standby");             //Return   to standby mode it's the message do display when waiting
        }

     if(keypressed   == '#'){                  //To change the code it calls the changecode function
       ChangeCode();
      lcd.clear();
      lcd.print("Standby");                 //When   done it returns to standby mode
     }

     if(digitalRead(O_Button)==HIGH){       //Opening by the push button
       digitalWrite(Solenoid,HIGH);
       delay(3000);                         //Opens for 3s you can change
       digitalWrite(Solenoid,LOW);
      
     }
         
}

void GetCode(){                  //Getting   code sequence
       i=0;                      //All variables set to 0
       a=0;
        j=0; 
                                     
     while(keypressed !=   'A'){                                     //The user press A to confirm the code   otherwise he can keep typing
           keypressed = myKeypad.getKey();                         
              if(keypressed != NO_KEY && keypressed != 'A' ){       //If the char   typed isn't A and neither "nothing"
              lcd.setCursor(j,1);                                  //This   to write "*" on the LCD whenever a key is pressed it's position is controlled   by j
              lcd.print("*");
              j++;
            if(keypressed   == code[i]&& i<sizeof(code)){            //if the char typed is correct a and i   increments to verify the next caracter
                 a++;                                              //Now   I think maybe I should have use only a or i ... too lazy to test it -_-'
                 i++;
                  }
            else
                a--;                                               //if   the character typed is wrong a decrements and cannot equal the size of code []
             }
            }
    keypressed = NO_KEY;

}

void   ChangeCode(){                      //Change code sequence
      lcd.clear();
       lcd.print("Changing code");
      delay(1000);
      lcd.clear();
       lcd.print("Enter old code");
      GetCode();                      //verify   the old code first so you can change it
      
            if(a==sizeof(code)){       //again verifying the a value
            lcd.clear();
            lcd.print("Changing   code");
            GetNewCode1();            //Get the new code
            GetNewCode2();             //Get the new code again to confirm it
            s=0;
              for(i=0   ; i<sizeof(code) ; i++){     //Compare codes in array 1 and array 2 from two previous   functions
              if(code_buff1[i]==code_buff2[i])
              s++;                                 //again this how we verifiy, increment s whenever   codes are matching
              }
                  if(s==sizeof(code)){             //Correct is always the size of the array
                  
                    for(i=0 ; i<sizeof(code) ; i++){
                  code[i]=code_buff2[i];          //the code array now receives the new code
                  EEPROM.put(i,   code[i]);        //And stores it in the EEPROM
                  
                  }
                   lcd.clear();
                  lcd.print("Code Changed");
                   delay(2000);
                  }
                  else{                          //In case the new codes aren't matching
                  lcd.clear();
                   lcd.print("Codes are not");
                  lcd.setCursor(0,1);
                   lcd.print("matching !!");
                  delay(2000);
                   }
            
          }
          
          else{                      //In case the old code is wrong you can't change it
          lcd.clear();
           lcd.print("Wrong");
          delay(2000);
          }
}

void   GetNewCode1(){                      
  i=0;
  j=0;
  lcd.clear();
  lcd.print("Enter   new code");   //tell the user to enter the new code and press A
  lcd.setCursor(0,1);
   lcd.print("and press A");
  delay(2000);
  lcd.clear();
  lcd.setCursor(0,1);
   lcd.print("and press A");     //Press A keep showing while the top row print   ***
             
         while(keypressed != 'A'){            //A to confirm   and quits the loop
             keypressed = myKeypad.getKey();
               if(keypressed   != NO_KEY && keypressed != 'A' ){
                lcd.setCursor(j,0);
                lcd.print("*");                //On the new code you can show * as I did or change it to keypressed   to show the keys
                code_buff1[i]=keypressed;     //Store caracters   in the array
                i++;
                j++;                    
                 }
                }
keypressed = NO_KEY;
}

void   GetNewCode2(){                         //This is exactly like the GetNewCode1 function   but this time the code is stored in another array
  i=0;
  j=0;
  
   lcd.clear();
  lcd.print("Confirm code");
  lcd.setCursor(0,1);
  lcd.print("and   press A");
  delay(3000);
  lcd.clear();
  lcd.setCursor(0,1);
  lcd.print("and   press A");

         while(keypressed != 'A'){
             keypressed   = myKeypad.getKey();
               if(keypressed != NO_KEY && keypressed !=   'A' ){
                lcd.setCursor(j,0);
                lcd.print("*");
                 code_buff2[i]=keypressed;
                i++;
                j++;                     
                }
                }
keypressed = NO_KEY;
}

void   OpenDoor(){             //Lock opening function open for 3s
  lcd.clear();
   lcd.print("Welcome");       //With a message printed
  digitalWrite(Solenoid,HIGH);
   delay(3000);
  digitalWrite(Solenoid,LOW);
}

Keypad_doorlock_relay.ino

arduino

Remember to upload the code first then uncomment line 62 to 64 and reupload, it's done only once.

1/* This code works with 4x4 Keypad Matrix, LCD ic, relay module and a   push button
2 * It's a lock where the relay can control a lock you can open either   with correct code
3 * or by the push button from inside
4 * The code can be   changed directly by the keypad and doesn't require uploading code again
5 * Code   is stored in EEPROM
6 * Refer to www.surtrtech.com for more details 
7 */
8
9#include   <Keypad.h>
10#include <EEPROM.h>
11#include <LiquidCrystal_I2C.h>
12
13#define   Relay 11                //Controls the Relay
14#define O_Button 10             //Push   Button
15
16#define I2C_ADDR 0x27           //I2C adress, you should use the code   to scan the adress first (0x27) here
17#define BACKLIGHT_PIN 3         // Declaring   LCD Pins
18#define En_pin 2
19#define Rw_pin 1
20#define Rs_pin 0
21#define   D4_pin 4
22#define D5_pin 5
23#define D6_pin 6
24#define D7_pin 7
25
26const   byte numRows= 4;          //number of rows on the keypad
27const byte numCols=   4;          //number of columns on the keypad
28
29char keymap[numRows][numCols]=   
30{
31{'1', '2', '3', 'A'}, 
32{'4', '5', '6', 'B'}, 
33{'7', '8', '9', 'C'},
34{'*',   '0', '#', 'D'}
35};
36
37char keypressed;                 //Where the keys are   stored it changes very often
38char code[]= {'6','6','0','1'};  //The default code,   you can change it or make it a 'n' digits one
39
40char code_buff1[sizeof(code)];   //Where the new key is stored
41char code_buff2[sizeof(code)];  //Where the new   key is stored again so it's compared to the previous one
42
43short a=0,i=0,s=0,j=0;           //Variables used later
44
45byte rowPins[numRows] = {9,8,7,6}; //Rows   0 to 3 //if you modify your pins you should modify this too
46byte colPins[numCols]=   {5,4,3,2}; //Columns 0 to 3
47
48LiquidCrystal_I2C lcd(I2C_ADDR,En_pin,Rw_pin,Rs_pin,D4_pin,D5_pin,D6_pin,D7_pin);
49Keypad   myKeypad= Keypad(makeKeymap(keymap), rowPins, colPins, numRows, numCols);
50
51void   setup()
52         {
53          lcd.begin (16,2);
54          lcd.setBacklightPin(BACKLIGHT_PIN,POSITIVE);
55           lcd.setBacklight(HIGH); //Lighting backlight
56          lcd.home ();
57           lcd.print("Standby");      //What's written on the LCD you can change
58           
59          pinMode(Relay,OUTPUT);
60          pinMode(O_Button,INPUT);
61                       
62//          for(i=0 ; i<sizeof(code);i++){        //When   you upload the code the first time keep it commented
63//            EEPROM.get(i,   code[i]);             //Upload the code and change it to store it in the EEPROM
64//              }                                  //Then uncomment this for loop and   reupload the code (It's done only once)
65
66         }
67
68
69void loop()
70{
71
72   keypressed = myKeypad.getKey();               //Constantly waiting for a key to   be pressed
73    if(keypressed == '*'){                      // * to open the lock
74             lcd.clear();
75            lcd.setCursor(0,0);
76            lcd.print("Enter   code");            //Message to show
77            GetCode();                          //Getting   code function
78                  if(a==sizeof(code))           //The GetCode function   assign a value to a (it's correct when it has the size of the code array)
79                  OpenDoor();                    //Open lock function if code is correct
80                  else{
81                   lcd.clear();               
82                  lcd.print("Wrong");           //Message to print when the code is wrong
83                  }
84            delay(2000);
85             lcd.clear();
86            lcd.print("Standby");             //Return   to standby mode it's the message do display when waiting
87        }
88
89     if(keypressed   == '#'){                  //To change the code it calls the changecode function
90       ChangeCode();
91      lcd.clear();
92      lcd.print("Standby");                 //When   done it returns to standby mode
93     }
94
95     if(digitalRead(O_Button)==HIGH){       //Opening by the push button
96       digitalWrite(Relay,LOW);
97       delay(3000);                         //Opens for 3s you can change
98       digitalWrite(Relay,HIGH);
99      
100     }
101         
102}
103
104void GetCode(){                  //Getting   code sequence
105       i=0;                      //All variables set to 0
106       a=0;
107        j=0; 
108                                     
109     while(keypressed !=   'A'){                                     //The user press A to confirm the code   otherwise he can keep typing
110           keypressed = myKeypad.getKey();                         
111              if(keypressed != NO_KEY && keypressed != 'A' ){       //If the char   typed isn't A and neither "nothing"
112              lcd.setCursor(j,1);                                  //This   to write "*" on the LCD whenever a key is pressed it's position is controlled   by j
113              lcd.print("*");
114              j++;
115            if(keypressed   == code[i]&& i<sizeof(code)){            //if the char typed is correct a and i   increments to verify the next caracter
116                 a++;                                              //Now   I think maybe I should have use only a or i ... too lazy to test it -_-'
117                 i++;
118                  }
119            else
120                a--;                                               //if   the character typed is wrong a decrements and cannot equal the size of code []
121             }
122            }
123    keypressed = NO_KEY;
124
125}
126
127void   ChangeCode(){                      //Change code sequence
128      lcd.clear();
129       lcd.print("Changing code");
130      delay(1000);
131      lcd.clear();
132       lcd.print("Enter old code");
133      GetCode();                      //verify   the old code first so you can change it
134      
135            if(a==sizeof(code)){       //again verifying the a value
136            lcd.clear();
137            lcd.print("Changing   code");
138            GetNewCode1();            //Get the new code
139            GetNewCode2();             //Get the new code again to confirm it
140            s=0;
141              for(i=0   ; i<sizeof(code) ; i++){     //Compare codes in array 1 and array 2 from two previous   functions
142              if(code_buff1[i]==code_buff2[i])
143              s++;                                 //again this how we verifiy, increment s whenever   codes are matching
144              }
145                  if(s==sizeof(code)){             //Correct is always the size of the array
146                  
147                    for(i=0 ; i<sizeof(code) ; i++){
148                  code[i]=code_buff2[i];          //the code array now receives the new code
149                  EEPROM.put(i,   code[i]);        //And stores it in the EEPROM
150                  
151                  }
152                   lcd.clear();
153                  lcd.print("Code Changed");
154                   delay(2000);
155                  }
156                  else{                          //In case the new codes aren't matching
157                  lcd.clear();
158                   lcd.print("Codes are not");
159                  lcd.setCursor(0,1);
160                   lcd.print("matching !!");
161                  delay(2000);
162                   }
163            
164          }
165          
166          else{                      //In case the old code is wrong you can't change it
167          lcd.clear();
168           lcd.print("Wrong");
169          delay(2000);
170          }
171}
172
173void   GetNewCode1(){                      
174  i=0;
175  j=0;
176  lcd.clear();
177  lcd.print("Enter   new code");   //tell the user to enter the new code and press A
178  lcd.setCursor(0,1);
179   lcd.print("and press A");
180  delay(2000);
181  lcd.clear();
182  lcd.setCursor(0,1);
183   lcd.print("and press A");     //Press A keep showing while the top row print   ***
184             
185         while(keypressed != 'A'){            //A to confirm   and quits the loop
186             keypressed = myKeypad.getKey();
187               if(keypressed   != NO_KEY && keypressed != 'A' ){
188                lcd.setCursor(j,0);
189                lcd.print("*");                //On the new code you can show * as I did or change it to keypressed   to show the keys
190                code_buff1[i]=keypressed;     //Store caracters   in the array
191                i++;
192                j++;                    
193                 }
194                }
195keypressed = NO_KEY;
196}
197
198void   GetNewCode2(){                         //This is exactly like the GetNewCode1 function   but this time the code is stored in another array
199  i=0;
200  j=0;
201  
202   lcd.clear();
203  lcd.print("Confirm code");
204  lcd.setCursor(0,1);
205  lcd.print("and   press A");
206  delay(3000);
207  lcd.clear();
208  lcd.setCursor(0,1);
209  lcd.print("and   press A");
210
211         while(keypressed != 'A'){
212             keypressed   = myKeypad.getKey();
213               if(keypressed != NO_KEY && keypressed !=   'A' ){
214                lcd.setCursor(j,0);
215                lcd.print("*");
216                 code_buff2[i]=keypressed;
217                i++;
218                j++;                     
219                }
220                }
221keypressed = NO_KEY;
222}
223
224void   OpenDoor(){             //Lock opening function open for 3s
225  lcd.clear();
226   lcd.print("Welcome");       //With a message printed
227  digitalWrite(Relay,LOW);
228   delay(3000);
229  digitalWrite(Relay,HIGH);
230}
231
232

/* This code works with 4x4 Keypad Matrix, LCD ic, relay module and a   push button
 * It's a lock where the relay can control a lock you can open either   with correct code
 * or by the push button from inside
 * The code can be   changed directly by the keypad and doesn't require uploading code again
 * Code   is stored in EEPROM
 * Refer to www.surtrtech.com for more details 
 */

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

#define   Relay 11                //Controls the Relay
#define O_Button 10             //Push   Button

#define I2C_ADDR 0x27           //I2C adress, you should use the code   to scan the adress first (0x27) here
#define BACKLIGHT_PIN 3         // Declaring   LCD Pins
#define En_pin 2
#define Rw_pin 1
#define Rs_pin 0
#define   D4_pin 4
#define D5_pin 5
#define D6_pin 6
#define D7_pin 7

const   byte numRows= 4;          //number of rows on the keypad
const byte numCols=   4;          //number of columns on the keypad

char keymap[numRows][numCols]=   
{
{'1', '2', '3', 'A'}, 
{'4', '5', '6', 'B'}, 
{'7', '8', '9', 'C'},
{'*',   '0', '#', 'D'}
};

char keypressed;                 //Where the keys are   stored it changes very often
char code[]= {'6','6','0','1'};  //The default code,   you can change it or make it a 'n' digits one

char code_buff1[sizeof(code)];   //Where the new key is stored
char code_buff2[sizeof(code)];  //Where the new   key is stored again so it's compared to the previous one

short a=0,i=0,s=0,j=0;           //Variables used later

byte rowPins[numRows] = {9,8,7,6}; //Rows   0 to 3 //if you modify your pins you should modify this too
byte colPins[numCols]=   {5,4,3,2}; //Columns 0 to 3

LiquidCrystal_I2C lcd(I2C_ADDR,En_pin,Rw_pin,Rs_pin,D4_pin,D5_pin,D6_pin,D7_pin);
Keypad   myKeypad= Keypad(makeKeymap(keymap), rowPins, colPins, numRows, numCols);

void   setup()
         {
          lcd.begin (16,2);
          lcd.setBacklightPin(BACKLIGHT_PIN,POSITIVE);
           lcd.setBacklight(HIGH); //Lighting backlight
          lcd.home ();
           lcd.print("Standby");      //What's written on the LCD you can change
           
          pinMode(Relay,OUTPUT);
          pinMode(O_Button,INPUT);
                       
//          for(i=0 ; i<sizeof(code);i++){        //When   you upload the code the first time keep it commented
//            EEPROM.get(i,   code[i]);             //Upload the code and change it to store it in the EEPROM
//              }                                  //Then uncomment this for loop and   reupload the code (It's done only once)

         }


void loop()
{

   keypressed = myKeypad.getKey();               //Constantly waiting for a key to   be pressed
    if(keypressed == '*'){                      // * to open the lock
             lcd.clear();
            lcd.setCursor(0,0);
            lcd.print("Enter   code");            //Message to show
            GetCode();                          //Getting   code function
                  if(a==sizeof(code))           //The GetCode function   assign a value to a (it's correct when it has the size of the code array)
                  OpenDoor();                    //Open lock function if code is correct
                  else{
                   lcd.clear();               
                  lcd.print("Wrong");           //Message to print when the code is wrong
                  }
            delay(2000);
             lcd.clear();
            lcd.print("Standby");             //Return   to standby mode it's the message do display when waiting
        }

     if(keypressed   == '#'){                  //To change the code it calls the changecode function
       ChangeCode();
      lcd.clear();
      lcd.print("Standby");                 //When   done it returns to standby mode
     }

     if(digitalRead(O_Button)==HIGH){       //Opening by the push button
       digitalWrite(Relay,LOW);
       delay(3000);                         //Opens for 3s you can change
       digitalWrite(Relay,HIGH);
      
     }
         
}

void GetCode(){                  //Getting   code sequence
       i=0;                      //All variables set to 0
       a=0;
        j=0; 
                                     
     while(keypressed !=   'A'){                                     //The user press A to confirm the code   otherwise he can keep typing
           keypressed = myKeypad.getKey();                         
              if(keypressed != NO_KEY && keypressed != 'A' ){       //If the char   typed isn't A and neither "nothing"
              lcd.setCursor(j,1);                                  //This   to write "*" on the LCD whenever a key is pressed it's position is controlled   by j
              lcd.print("*");
              j++;
            if(keypressed   == code[i]&& i<sizeof(code)){            //if the char typed is correct a and i   increments to verify the next caracter
                 a++;                                              //Now   I think maybe I should have use only a or i ... too lazy to test it -_-'
                 i++;
                  }
            else
                a--;                                               //if   the character typed is wrong a decrements and cannot equal the size of code []
             }
            }
    keypressed = NO_KEY;

}

void   ChangeCode(){                      //Change code sequence
      lcd.clear();
       lcd.print("Changing code");
      delay(1000);
      lcd.clear();
       lcd.print("Enter old code");
      GetCode();                      //verify   the old code first so you can change it
      
            if(a==sizeof(code)){       //again verifying the a value
            lcd.clear();
            lcd.print("Changing   code");
            GetNewCode1();            //Get the new code
            GetNewCode2();             //Get the new code again to confirm it
            s=0;
              for(i=0   ; i<sizeof(code) ; i++){     //Compare codes in array 1 and array 2 from two previous   functions
              if(code_buff1[i]==code_buff2[i])
              s++;                                 //again this how we verifiy, increment s whenever   codes are matching
              }
                  if(s==sizeof(code)){             //Correct is always the size of the array
                  
                    for(i=0 ; i<sizeof(code) ; i++){
                  code[i]=code_buff2[i];          //the code array now receives the new code
                  EEPROM.put(i,   code[i]);        //And stores it in the EEPROM
                  
                  }
                   lcd.clear();
                  lcd.print("Code Changed");
                   delay(2000);
                  }
                  else{                          //In case the new codes aren't matching
                  lcd.clear();
                   lcd.print("Codes are not");
                  lcd.setCursor(0,1);
                   lcd.print("matching !!");
                  delay(2000);
                   }
            
          }
          
          else{                      //In case the old code is wrong you can't change it
          lcd.clear();
           lcd.print("Wrong");
          delay(2000);
          }
}

void   GetNewCode1(){                      
  i=0;
  j=0;
  lcd.clear();
  lcd.print("Enter   new code");   //tell the user to enter the new code and press A
  lcd.setCursor(0,1);
   lcd.print("and press A");
  delay(2000);
  lcd.clear();
  lcd.setCursor(0,1);
   lcd.print("and press A");     //Press A keep showing while the top row print   ***
             
         while(keypressed != 'A'){            //A to confirm   and quits the loop
             keypressed = myKeypad.getKey();
               if(keypressed   != NO_KEY && keypressed != 'A' ){
                lcd.setCursor(j,0);
                lcd.print("*");                //On the new code you can show * as I did or change it to keypressed   to show the keys
                code_buff1[i]=keypressed;     //Store caracters   in the array
                i++;
                j++;                    
                 }
                }
keypressed = NO_KEY;
}

void   GetNewCode2(){                         //This is exactly like the GetNewCode1 function   but this time the code is stored in another array
  i=0;
  j=0;
  
   lcd.clear();
  lcd.print("Confirm code");
  lcd.setCursor(0,1);
  lcd.print("and   press A");
  delay(3000);
  lcd.clear();
  lcd.setCursor(0,1);
  lcd.print("and   press A");

         while(keypressed != 'A'){
             keypressed   = myKeypad.getKey();
               if(keypressed != NO_KEY && keypressed !=   'A' ){
                lcd.setCursor(j,0);
                lcd.print("*");
                 code_buff2[i]=keypressed;
                i++;
                j++;                     
                }
                }
keypressed = NO_KEY;
}

void   OpenDoor(){             //Lock opening function open for 3s
  lcd.clear();
   lcd.print("Welcome");       //With a message printed
  digitalWrite(Relay,LOW);
   delay(3000);
  digitalWrite(Relay,HIGH);
}

Keypad_doorlock_solenoid.ino

arduino

Remember to upload the code first then uncomment line 62 to 64 and reupload, it's done only once.

1/* This code works with 4x4 Keypad Matrix, LCD ic, IRF510N transistor  and a push button
2 * It's a lock where the transistor drives a solenoid lock  you can open either with correct code
3 * or by the push button from inside
4  * The code can be changed directly by the keypad and doesn't require uploading code  again
5 * Code is stored in EEPROM
6 * Refer to www.surtrtech.com for more details  
7 */
8
9#include <Keypad.h>
10#include <EEPROM.h>
11#include <LiquidCrystal_I2C.h>
12
13#define  Solenoid 11             //Actually the Gate of the transistor that controls the  solenoid
14#define O_Button 10             //Push Button
15
16#define I2C_ADDR  0x27           //I2C adress, you should use the code to scan the adress first (0x27)  here
17#define BACKLIGHT_PIN 3         // Declaring LCD Pins
18#define En_pin  2
19#define Rw_pin 1
20#define Rs_pin 0
21#define D4_pin 4
22#define D5_pin  5
23#define D6_pin 6
24#define D7_pin 7
25
26const byte numRows= 4;          //number  of rows on the keypad
27const byte numCols= 4;          //number of columns on  the keypad
28
29char keymap[numRows][numCols]= 
30{
31{'1', '2', '3', 'A'},  
32{'4', '5', '6', 'B'}, 
33{'7', '8', '9', 'C'},
34{'*', '0', '#', 'D'}
35};
36
37char  keypressed;                 //Where the keys are stored it changes very often
38char  code[]= {'6','6','0','1'};  //The default code, you can change it or make it a 'n'  digits one
39
40char code_buff1[sizeof(code)];  //Where the new key is stored
41char  code_buff2[sizeof(code)];  //Where the new key is stored again so it's compared  to the previous one
42
43short a=0,i=0,s=0,j=0;          //Variables used later
44
45byte  rowPins[numRows] = {9,8,7,6}; //Rows 0 to 3 //if you modify your pins you should  modify this too
46byte colPins[numCols]= {5,4,3,2}; //Columns 0 to 3
47
48LiquidCrystal_I2C  lcd(I2C_ADDR,En_pin,Rw_pin,Rs_pin,D4_pin,D5_pin,D6_pin,D7_pin);
49Keypad myKeypad=  Keypad(makeKeymap(keymap), rowPins, colPins, numRows, numCols);
50
51void setup()
52         {
53          lcd.begin (16,2);
54          lcd.setBacklightPin(BACKLIGHT_PIN,POSITIVE);
55          lcd.setBacklight(HIGH); //Lighting backlight
56          lcd.home ();
57          lcd.print("Standby");      //What's written on the LCD you can change
58          
59          pinMode(Solenoid,OUTPUT);
60          pinMode(O_Button,INPUT);
61                      
62//          for(i=0 ; i<sizeof(code);i++){        //When  you upload the code the first time keep it commented
63//            EEPROM.get(i,  code[i]);             //Upload the code and change it to store it in the EEPROM
64//             }                                  //Then uncomment this for loop and  reupload the code (It's done only once)
65
66         }
67
68
69void loop()
70{
71
72  keypressed = myKeypad.getKey();               //Constantly waiting for a key to  be pressed
73    if(keypressed == '*'){                      // * to open the lock
74            lcd.clear();
75            lcd.setCursor(0,0);
76            lcd.print("Enter  code");            //Message to show
77            GetCode();                          //Getting  code function
78                  if(a==sizeof(code))           //The GetCode function  assign a value to a (it's correct when it has the size of the code array)
79                  OpenDoor();                   //Open lock function if code is correct
80                  else{
81                  lcd.clear();               
82                  lcd.print("Wrong");          //Message to print when the code is wrong
83                  }
84            delay(2000);
85            lcd.clear();
86            lcd.print("Standby");             //Return  to standby mode it's the message do display when waiting
87        }
88
89     if(keypressed  == '#'){                  //To change the code it calls the changecode function
90      ChangeCode();
91      lcd.clear();
92      lcd.print("Standby");                 //When  done it returns to standby mode
93     }
94
95     if(digitalRead(O_Button)==HIGH){      //Opening by the push button
96       digitalWrite(Solenoid,HIGH);
97       delay(3000);                        //Opens for 3s you can change
98       digitalWrite(Solenoid,LOW);
99     
100     }
101         
102}
103
104void GetCode(){                  //Getting  code sequence
105       i=0;                      //All variables set to 0
106       a=0;
107       j=0; 
108                                     
109     while(keypressed !=  'A'){                                     //The user press A to confirm the code  otherwise he can keep typing
110           keypressed = myKeypad.getKey();                         
111             if(keypressed != NO_KEY && keypressed != 'A' ){       //If the char  typed isn't A and neither "nothing"
112              lcd.setCursor(j,1);                                  //This  to write "*" on the LCD whenever a key is pressed it's position is controlled  by j
113              lcd.print("*");
114              j++;
115            if(keypressed  == code[i]&& i<sizeof(code)){            //if the char typed is correct a and i  increments to verify the next caracter
116                 a++;                                              //Now  I think maybe I should have use only a or i ... too lazy to test it -_-'
117                 i++;
118                 }
119            else
120                a--;                                               //if  the character typed is wrong a decrements and cannot equal the size of code []
121            }
122            }
123    keypressed = NO_KEY;
124
125}
126
127void  ChangeCode(){                      //Change code sequence
128      lcd.clear();
129      lcd.print("Changing code");
130      delay(1000);
131      lcd.clear();
132      lcd.print("Enter old code");
133      GetCode();                      //verify  the old code first so you can change it
134      
135            if(a==sizeof(code)){      //again verifying the a value
136            lcd.clear();
137            lcd.print("Changing  code");
138            GetNewCode1();            //Get the new code
139            GetNewCode2();            //Get the new code again to confirm it
140            s=0;
141              for(i=0  ; i<sizeof(code) ; i++){     //Compare codes in array 1 and array 2 from two previous  functions
142              if(code_buff1[i]==code_buff2[i])
143              s++;                                //again this how we verifiy, increment s whenever  codes are matching
144              }
145                  if(s==sizeof(code)){            //Correct is always the size of the array
146                  
147                   for(i=0 ; i<sizeof(code) ; i++){
148                  code[i]=code_buff2[i];         //the code array now receives the new code
149                  EEPROM.put(i,  code[i]);        //And stores it in the EEPROM
150                  
151                  }
152                  lcd.clear();
153                  lcd.print("Code Changed");
154                  delay(2000);
155                  }
156                  else{                         //In case the new codes aren't matching
157                  lcd.clear();
158                  lcd.print("Codes are not");
159                  lcd.setCursor(0,1);
160                  lcd.print("matching !!");
161                  delay(2000);
162                  }
163            
164          }
165          
166          else{                     //In case the old code is wrong you can't change it
167          lcd.clear();
168          lcd.print("Wrong");
169          delay(2000);
170          }
171}
172
173void  GetNewCode1(){                      
174  i=0;
175  j=0;
176  lcd.clear();
177  lcd.print("Enter  new code");   //tell the user to enter the new code and press A
178  lcd.setCursor(0,1);
179  lcd.print("and press A");
180  delay(2000);
181  lcd.clear();
182  lcd.setCursor(0,1);
183  lcd.print("and press A");     //Press A keep showing while the top row print  ***
184             
185         while(keypressed != 'A'){            //A to confirm  and quits the loop
186             keypressed = myKeypad.getKey();
187               if(keypressed  != NO_KEY && keypressed != 'A' ){
188                lcd.setCursor(j,0);
189                lcd.print("*");               //On the new code you can show * as I did or change it to keypressed  to show the keys
190                code_buff1[i]=keypressed;     //Store caracters  in the array
191                i++;
192                j++;                    
193                }
194                }
195keypressed = NO_KEY;
196}
197
198void  GetNewCode2(){                         //This is exactly like the GetNewCode1 function  but this time the code is stored in another array
199  i=0;
200  j=0;
201  
202  lcd.clear();
203  lcd.print("Confirm code");
204  lcd.setCursor(0,1);
205  lcd.print("and  press A");
206  delay(3000);
207  lcd.clear();
208  lcd.setCursor(0,1);
209  lcd.print("and  press A");
210
211         while(keypressed != 'A'){
212             keypressed  = myKeypad.getKey();
213               if(keypressed != NO_KEY && keypressed !=  'A' ){
214                lcd.setCursor(j,0);
215                lcd.print("*");
216                code_buff2[i]=keypressed;
217                i++;
218                j++;                    
219                }
220                }
221keypressed = NO_KEY;
222}
223
224void  OpenDoor(){             //Lock opening function open for 3s
225  lcd.clear();
226  lcd.print("Welcome");       //With a message printed
227  digitalWrite(Solenoid,HIGH);
228  delay(3000);
229  digitalWrite(Solenoid,LOW);
230}
231
232

/* This code works with 4x4 Keypad Matrix, LCD ic, IRF510N transistor  and a push button
 * It's a lock where the transistor drives a solenoid lock  you can open either with correct code
 * or by the push button from inside
  * The code can be changed directly by the keypad and doesn't require uploading code  again
 * Code is stored in EEPROM
 * Refer to www.surtrtech.com for more details  
 */

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

#define  Solenoid 11             //Actually the Gate of the transistor that controls the  solenoid
#define O_Button 10             //Push Button

#define I2C_ADDR  0x27           //I2C adress, you should use the code to scan the adress first (0x27)  here
#define BACKLIGHT_PIN 3         // Declaring LCD Pins
#define En_pin  2
#define Rw_pin 1
#define Rs_pin 0
#define D4_pin 4
#define D5_pin  5
#define D6_pin 6
#define D7_pin 7

const byte numRows= 4;          //number  of rows on the keypad
const byte numCols= 4;          //number of columns on  the keypad

char keymap[numRows][numCols]= 
{
{'1', '2', '3', 'A'},  
{'4', '5', '6', 'B'}, 
{'7', '8', '9', 'C'},
{'*', '0', '#', 'D'}
};

char  keypressed;                 //Where the keys are stored it changes very often
char  code[]= {'6','6','0','1'};  //The default code, you can change it or make it a 'n'  digits one

char code_buff1[sizeof(code)];  //Where the new key is stored
char  code_buff2[sizeof(code)];  //Where the new key is stored again so it's compared  to the previous one

short a=0,i=0,s=0,j=0;          //Variables used later

byte  rowPins[numRows] = {9,8,7,6}; //Rows 0 to 3 //if you modify your pins you should  modify this too
byte colPins[numCols]= {5,4,3,2}; //Columns 0 to 3

LiquidCrystal_I2C  lcd(I2C_ADDR,En_pin,Rw_pin,Rs_pin,D4_pin,D5_pin,D6_pin,D7_pin);
Keypad myKeypad=  Keypad(makeKeymap(keymap), rowPins, colPins, numRows, numCols);

void setup()
         {
          lcd.begin (16,2);
          lcd.setBacklightPin(BACKLIGHT_PIN,POSITIVE);
          lcd.setBacklight(HIGH); //Lighting backlight
          lcd.home ();
          lcd.print("Standby");      //What's written on the LCD you can change
          
          pinMode(Solenoid,OUTPUT);
          pinMode(O_Button,INPUT);
                      
//          for(i=0 ; i<sizeof(code);i++){        //When  you upload the code the first time keep it commented
//            EEPROM.get(i,  code[i]);             //Upload the code and change it to store it in the EEPROM
//             }                                  //Then uncomment this for loop and  reupload the code (It's done only once)

         }


void loop()
{

  keypressed = myKeypad.getKey();               //Constantly waiting for a key to  be pressed
    if(keypressed == '*'){                      // * to open the lock
            lcd.clear();
            lcd.setCursor(0,0);
            lcd.print("Enter  code");            //Message to show
            GetCode();                          //Getting  code function
                  if(a==sizeof(code))           //The GetCode function  assign a value to a (it's correct when it has the size of the code array)
                  OpenDoor();                   //Open lock function if code is correct
                  else{
                  lcd.clear();               
                  lcd.print("Wrong");          //Message to print when the code is wrong
                  }
            delay(2000);
            lcd.clear();
            lcd.print("Standby");             //Return  to standby mode it's the message do display when waiting
        }

     if(keypressed  == '#'){                  //To change the code it calls the changecode function
      ChangeCode();
      lcd.clear();
      lcd.print("Standby");                 //When  done it returns to standby mode
     }

     if(digitalRead(O_Button)==HIGH){      //Opening by the push button
       digitalWrite(Solenoid,HIGH);
       delay(3000);                        //Opens for 3s you can change
       digitalWrite(Solenoid,LOW);
     
     }
         
}

void GetCode(){                  //Getting  code sequence
       i=0;                      //All variables set to 0
       a=0;
       j=0; 
                                     
     while(keypressed !=  'A'){                                     //The user press A to confirm the code  otherwise he can keep typing
           keypressed = myKeypad.getKey();                         
             if(keypressed != NO_KEY && keypressed != 'A' ){       //If the char  typed isn't A and neither "nothing"
              lcd.setCursor(j,1);                                  //This  to write "*" on the LCD whenever a key is pressed it's position is controlled  by j
              lcd.print("*");
              j++;
            if(keypressed  == code[i]&& i<sizeof(code)){            //if the char typed is correct a and i  increments to verify the next caracter
                 a++;                                              //Now  I think maybe I should have use only a or i ... too lazy to test it -_-'
                 i++;
                 }
            else
                a--;                                               //if  the character typed is wrong a decrements and cannot equal the size of code []
            }
            }
    keypressed = NO_KEY;

}

void  ChangeCode(){                      //Change code sequence
      lcd.clear();
      lcd.print("Changing code");
      delay(1000);
      lcd.clear();
      lcd.print("Enter old code");
      GetCode();                      //verify  the old code first so you can change it
      
            if(a==sizeof(code)){      //again verifying the a value
            lcd.clear();
            lcd.print("Changing  code");
            GetNewCode1();            //Get the new code
            GetNewCode2();            //Get the new code again to confirm it
            s=0;
              for(i=0  ; i<sizeof(code) ; i++){     //Compare codes in array 1 and array 2 from two previous  functions
              if(code_buff1[i]==code_buff2[i])
              s++;                                //again this how we verifiy, increment s whenever  codes are matching
              }
                  if(s==sizeof(code)){            //Correct is always the size of the array
                  
                   for(i=0 ; i<sizeof(code) ; i++){
                  code[i]=code_buff2[i];         //the code array now receives the new code
                  EEPROM.put(i,  code[i]);        //And stores it in the EEPROM
                  
                  }
                  lcd.clear();
                  lcd.print("Code Changed");
                  delay(2000);
                  }
                  else{                         //In case the new codes aren't matching
                  lcd.clear();
                  lcd.print("Codes are not");
                  lcd.setCursor(0,1);
                  lcd.print("matching !!");
                  delay(2000);
                  }
            
          }
          
          else{                     //In case the old code is wrong you can't change it
          lcd.clear();
          lcd.print("Wrong");
          delay(2000);
          }
}

void  GetNewCode1(){                      
  i=0;
  j=0;
  lcd.clear();
  lcd.print("Enter  new code");   //tell the user to enter the new code and press A
  lcd.setCursor(0,1);
  lcd.print("and press A");
  delay(2000);
  lcd.clear();
  lcd.setCursor(0,1);
  lcd.print("and press A");     //Press A keep showing while the top row print  ***
             
         while(keypressed != 'A'){            //A to confirm  and quits the loop
             keypressed = myKeypad.getKey();
               if(keypressed  != NO_KEY && keypressed != 'A' ){
                lcd.setCursor(j,0);
                lcd.print("*");               //On the new code you can show * as I did or change it to keypressed  to show the keys
                code_buff1[i]=keypressed;     //Store caracters  in the array
                i++;
                j++;                    
                }
                }
keypressed = NO_KEY;
}

void  GetNewCode2(){                         //This is exactly like the GetNewCode1 function  but this time the code is stored in another array
  i=0;
  j=0;
  
  lcd.clear();
  lcd.print("Confirm code");
  lcd.setCursor(0,1);
  lcd.print("and  press A");
  delay(3000);
  lcd.clear();
  lcd.setCursor(0,1);
  lcd.print("and  press A");

         while(keypressed != 'A'){
             keypressed  = myKeypad.getKey();
               if(keypressed != NO_KEY && keypressed !=  'A' ){
                lcd.setCursor(j,0);
                lcd.print("*");
                code_buff2[i]=keypressed;
                i++;
                j++;                    
                }
                }
keypressed = NO_KEY;
}

void  OpenDoor(){             //Lock opening function open for 3s
  lcd.clear();
  lcd.print("Welcome");       //With a message printed
  digitalWrite(Solenoid,HIGH);
  delay(3000);
  digitalWrite(Solenoid,LOW);
}

Keypad_doorlock_relay.ino

arduino

Remember to upload the code first then uncomment line 62 to 64 and reupload, it's done only once.

1/* This code works with 4x4 Keypad Matrix, LCD ic, relay module and a  push button
2 * It's a lock where the relay can control a lock you can open either  with correct code
3 * or by the push button from inside
4 * The code can be  changed directly by the keypad and doesn't require uploading code again
5 * Code  is stored in EEPROM
6 * Refer to www.surtrtech.com for more details 
7 */
8
9#include  <Keypad.h>
10#include <EEPROM.h>
11#include <LiquidCrystal_I2C.h>
12
13#define  Relay 11                //Controls the Relay
14#define O_Button 10             //Push  Button
15
16#define I2C_ADDR 0x27           //I2C adress, you should use the code  to scan the adress first (0x27) here
17#define BACKLIGHT_PIN 3         // Declaring  LCD Pins
18#define En_pin 2
19#define Rw_pin 1
20#define Rs_pin 0
21#define  D4_pin 4
22#define D5_pin 5
23#define D6_pin 6
24#define D7_pin 7
25
26const  byte numRows= 4;          //number of rows on the keypad
27const byte numCols=  4;          //number of columns on the keypad
28
29char keymap[numRows][numCols]=  
30{
31{'1', '2', '3', 'A'}, 
32{'4', '5', '6', 'B'}, 
33{'7', '8', '9', 'C'},
34{'*',  '0', '#', 'D'}
35};
36
37char keypressed;                 //Where the keys are  stored it changes very often
38char code[]= {'6','6','0','1'};  //The default code,  you can change it or make it a 'n' digits one
39
40char code_buff1[sizeof(code)];  //Where the new key is stored
41char code_buff2[sizeof(code)];  //Where the new  key is stored again so it's compared to the previous one
42
43short a=0,i=0,s=0,j=0;          //Variables used later
44
45byte rowPins[numRows] = {9,8,7,6}; //Rows  0 to 3 //if you modify your pins you should modify this too
46byte colPins[numCols]=  {5,4,3,2}; //Columns 0 to 3
47
48LiquidCrystal_I2C lcd(I2C_ADDR,En_pin,Rw_pin,Rs_pin,D4_pin,D5_pin,D6_pin,D7_pin);
49Keypad  myKeypad= Keypad(makeKeymap(keymap), rowPins, colPins, numRows, numCols);
50
51void  setup()
52         {
53          lcd.begin (16,2);
54          lcd.setBacklightPin(BACKLIGHT_PIN,POSITIVE);
55          lcd.setBacklight(HIGH); //Lighting backlight
56          lcd.home ();
57          lcd.print("Standby");      //What's written on the LCD you can change
58          
59          pinMode(Relay,OUTPUT);
60          pinMode(O_Button,INPUT);
61                      
62//          for(i=0 ; i<sizeof(code);i++){        //When  you upload the code the first time keep it commented
63//            EEPROM.get(i,  code[i]);             //Upload the code and change it to store it in the EEPROM
64//             }                                  //Then uncomment this for loop and  reupload the code (It's done only once)
65
66         }
67
68
69void loop()
70{
71
72  keypressed = myKeypad.getKey();               //Constantly waiting for a key to  be pressed
73    if(keypressed == '*'){                      // * to open the lock
74            lcd.clear();
75            lcd.setCursor(0,0);
76            lcd.print("Enter  code");            //Message to show
77            GetCode();                          //Getting  code function
78                  if(a==sizeof(code))           //The GetCode function  assign a value to a (it's correct when it has the size of the code array)
79                  OpenDoor();                   //Open lock function if code is correct
80                  else{
81                  lcd.clear();               
82                  lcd.print("Wrong");          //Message to print when the code is wrong
83                  }
84            delay(2000);
85            lcd.clear();
86            lcd.print("Standby");             //Return  to standby mode it's the message do display when waiting
87        }
88
89     if(keypressed  == '#'){                  //To change the code it calls the changecode function
90      ChangeCode();
91      lcd.clear();
92      lcd.print("Standby");                 //When  done it returns to standby mode
93     }
94
95     if(digitalRead(O_Button)==HIGH){      //Opening by the push button
96       digitalWrite(Relay,LOW);
97       delay(3000);                        //Opens for 3s you can change
98       digitalWrite(Relay,HIGH);
99     
100     }
101         
102}
103
104void GetCode(){                  //Getting  code sequence
105       i=0;                      //All variables set to 0
106       a=0;
107       j=0; 
108                                     
109     while(keypressed !=  'A'){                                     //The user press A to confirm the code  otherwise he can keep typing
110           keypressed = myKeypad.getKey();                         
111             if(keypressed != NO_KEY && keypressed != 'A' ){       //If the char  typed isn't A and neither "nothing"
112              lcd.setCursor(j,1);                                  //This  to write "*" on the LCD whenever a key is pressed it's position is controlled  by j
113              lcd.print("*");
114              j++;
115            if(keypressed  == code[i]&& i<sizeof(code)){            //if the char typed is correct a and i  increments to verify the next caracter
116                 a++;                                              //Now  I think maybe I should have use only a or i ... too lazy to test it -_-'
117                 i++;
118                 }
119            else
120                a--;                                               //if  the character typed is wrong a decrements and cannot equal the size of code []
121            }
122            }
123    keypressed = NO_KEY;
124
125}
126
127void  ChangeCode(){                      //Change code sequence
128      lcd.clear();
129      lcd.print("Changing code");
130      delay(1000);
131      lcd.clear();
132      lcd.print("Enter old code");
133      GetCode();                      //verify  the old code first so you can change it
134      
135            if(a==sizeof(code)){      //again verifying the a value
136            lcd.clear();
137            lcd.print("Changing  code");
138            GetNewCode1();            //Get the new code
139            GetNewCode2();            //Get the new code again to confirm it
140            s=0;
141              for(i=0  ; i<sizeof(code) ; i++){     //Compare codes in array 1 and array 2 from two previous  functions
142              if(code_buff1[i]==code_buff2[i])
143              s++;                                //again this how we verifiy, increment s whenever  codes are matching
144              }
145                  if(s==sizeof(code)){            //Correct is always the size of the array
146                  
147                   for(i=0 ; i<sizeof(code) ; i++){
148                  code[i]=code_buff2[i];         //the code array now receives the new code
149                  EEPROM.put(i,  code[i]);        //And stores it in the EEPROM
150                  
151                  }
152                  lcd.clear();
153                  lcd.print("Code Changed");
154                  delay(2000);
155                  }
156                  else{                         //In case the new codes aren't matching
157                  lcd.clear();
158                  lcd.print("Codes are not");
159                  lcd.setCursor(0,1);
160                  lcd.print("matching !!");
161                  delay(2000);
162                  }
163            
164          }
165          
166          else{                     //In case the old code is wrong you can't change it
167          lcd.clear();
168          lcd.print("Wrong");
169          delay(2000);
170          }
171}
172
173void  GetNewCode1(){                      
174  i=0;
175  j=0;
176  lcd.clear();
177  lcd.print("Enter  new code");   //tell the user to enter the new code and press A
178  lcd.setCursor(0,1);
179  lcd.print("and press A");
180  delay(2000);
181  lcd.clear();
182  lcd.setCursor(0,1);
183  lcd.print("and press A");     //Press A keep showing while the top row print  ***
184             
185         while(keypressed != 'A'){            //A to confirm  and quits the loop
186             keypressed = myKeypad.getKey();
187               if(keypressed  != NO_KEY && keypressed != 'A' ){
188                lcd.setCursor(j,0);
189                lcd.print("*");               //On the new code you can show * as I did or change it to keypressed  to show the keys
190                code_buff1[i]=keypressed;     //Store caracters  in the array
191                i++;
192                j++;                    
193                }
194                }
195keypressed = NO_KEY;
196}
197
198void  GetNewCode2(){                         //This is exactly like the GetNewCode1 function  but this time the code is stored in another array
199  i=0;
200  j=0;
201  
202  lcd.clear();
203  lcd.print("Confirm code");
204  lcd.setCursor(0,1);
205  lcd.print("and  press A");
206  delay(3000);
207  lcd.clear();
208  lcd.setCursor(0,1);
209  lcd.print("and  press A");
210
211         while(keypressed != 'A'){
212             keypressed  = myKeypad.getKey();
213               if(keypressed != NO_KEY && keypressed !=  'A' ){
214                lcd.setCursor(j,0);
215                lcd.print("*");
216                code_buff2[i]=keypressed;
217                i++;
218                j++;                    
219                }
220                }
221keypressed = NO_KEY;
222}
223
224void  OpenDoor(){             //Lock opening function open for 3s
225  lcd.clear();
226  lcd.print("Welcome");       //With a message printed
227  digitalWrite(Relay,LOW);
228  delay(3000);
229  digitalWrite(Relay,HIGH);
230}
231
232

/* This code works with 4x4 Keypad Matrix, LCD ic, relay module and a  push button
 * It's a lock where the relay can control a lock you can open either  with correct code
 * or by the push button from inside
 * The code can be  changed directly by the keypad and doesn't require uploading code again
 * Code  is stored in EEPROM
 * Refer to www.surtrtech.com for more details 
 */

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

#define  Relay 11                //Controls the Relay
#define O_Button 10             //Push  Button

#define I2C_ADDR 0x27           //I2C adress, you should use the code  to scan the adress first (0x27) here
#define BACKLIGHT_PIN 3         // Declaring  LCD Pins
#define En_pin 2
#define Rw_pin 1
#define Rs_pin 0
#define  D4_pin 4
#define D5_pin 5
#define D6_pin 6
#define D7_pin 7

const  byte numRows= 4;          //number of rows on the keypad
const byte numCols=  4;          //number of columns on the keypad

char keymap[numRows][numCols]=  
{
{'1', '2', '3', 'A'}, 
{'4', '5', '6', 'B'}, 
{'7', '8', '9', 'C'},
{'*',  '0', '#', 'D'}
};

char keypressed;                 //Where the keys are  stored it changes very often
char code[]= {'6','6','0','1'};  //The default code,  you can change it or make it a 'n' digits one

char code_buff1[sizeof(code)];  //Where the new key is stored
char code_buff2[sizeof(code)];  //Where the new  key is stored again so it's compared to the previous one

short a=0,i=0,s=0,j=0;          //Variables used later

byte rowPins[numRows] = {9,8,7,6}; //Rows  0 to 3 //if you modify your pins you should modify this too
byte colPins[numCols]=  {5,4,3,2}; //Columns 0 to 3

LiquidCrystal_I2C lcd(I2C_ADDR,En_pin,Rw_pin,Rs_pin,D4_pin,D5_pin,D6_pin,D7_pin);
Keypad  myKeypad= Keypad(makeKeymap(keymap), rowPins, colPins, numRows, numCols);

void  setup()
         {
          lcd.begin (16,2);
          lcd.setBacklightPin(BACKLIGHT_PIN,POSITIVE);
          lcd.setBacklight(HIGH); //Lighting backlight
          lcd.home ();
          lcd.print("Standby");      //What's written on the LCD you can change
          
          pinMode(Relay,OUTPUT);
          pinMode(O_Button,INPUT);
                      
//          for(i=0 ; i<sizeof(code);i++){        //When  you upload the code the first time keep it commented
//            EEPROM.get(i,  code[i]);             //Upload the code and change it to store it in the EEPROM
//             }                                  //Then uncomment this for loop and  reupload the code (It's done only once)

         }


void loop()
{

  keypressed = myKeypad.getKey();               //Constantly waiting for a key to  be pressed
    if(keypressed == '*'){                      // * to open the lock
            lcd.clear();
            lcd.setCursor(0,0);
            lcd.print("Enter  code");            //Message to show
            GetCode();                          //Getting  code function
                  if(a==sizeof(code))           //The GetCode function  assign a value to a (it's correct when it has the size of the code array)
                  OpenDoor();                   //Open lock function if code is correct
                  else{
                  lcd.clear();               
                  lcd.print("Wrong");          //Message to print when the code is wrong
                  }
            delay(2000);
            lcd.clear();
            lcd.print("Standby");             //Return  to standby mode it's the message do display when waiting
        }

     if(keypressed  == '#'){                  //To change the code it calls the changecode function
      ChangeCode();
      lcd.clear();
      lcd.print("Standby");                 //When  done it returns to standby mode
     }

     if(digitalRead(O_Button)==HIGH){      //Opening by the push button
       digitalWrite(Relay,LOW);
       delay(3000);                        //Opens for 3s you can change
       digitalWrite(Relay,HIGH);
     
     }
         
}

void GetCode(){                  //Getting  code sequence
       i=0;                      //All variables set to 0
       a=0;
       j=0; 
                                     
     while(keypressed !=  'A'){                                     //The user press A to confirm the code  otherwise he can keep typing
           keypressed = myKeypad.getKey();                         
             if(keypressed != NO_KEY && keypressed != 'A' ){       //If the char  typed isn't A and neither "nothing"
              lcd.setCursor(j,1);                                  //This  to write "*" on the LCD whenever a key is pressed it's position is controlled  by j
              lcd.print("*");
              j++;
            if(keypressed  == code[i]&& i<sizeof(code)){            //if the char typed is correct a and i  increments to verify the next caracter
                 a++;                                              //Now  I think maybe I should have use only a or i ... too lazy to test it -_-'
                 i++;
                 }
            else
                a--;                                               //if  the character typed is wrong a decrements and cannot equal the size of code []
            }
            }
    keypressed = NO_KEY;

}

void  ChangeCode(){                      //Change code sequence
      lcd.clear();
      lcd.print("Changing code");
      delay(1000);
      lcd.clear();
      lcd.print("Enter old code");
      GetCode();                      //verify  the old code first so you can change it
      
            if(a==sizeof(code)){      //again verifying the a value
            lcd.clear();
            lcd.print("Changing  code");
            GetNewCode1();            //Get the new code
            GetNewCode2();            //Get the new code again to confirm it
            s=0;
              for(i=0  ; i<sizeof(code) ; i++){     //Compare codes in array 1 and array 2 from two previous  functions
              if(code_buff1[i]==code_buff2[i])
              s++;                                //again this how we verifiy, increment s whenever  codes are matching
              }
                  if(s==sizeof(code)){            //Correct is always the size of the array
                  
                   for(i=0 ; i<sizeof(code) ; i++){
                  code[i]=code_buff2[i];         //the code array now receives the new code
                  EEPROM.put(i,  code[i]);        //And stores it in the EEPROM
                  
                  }
                  lcd.clear();
                  lcd.print("Code Changed");
                  delay(2000);
                  }
                  else{                         //In case the new codes aren't matching
                  lcd.clear();
                  lcd.print("Codes are not");
                  lcd.setCursor(0,1);
                  lcd.print("matching !!");
                  delay(2000);
                  }
            
          }
          
          else{                     //In case the old code is wrong you can't change it
          lcd.clear();
          lcd.print("Wrong");
          delay(2000);
          }
}

void  GetNewCode1(){                      
  i=0;
  j=0;
  lcd.clear();
  lcd.print("Enter  new code");   //tell the user to enter the new code and press A
  lcd.setCursor(0,1);
  lcd.print("and press A");
  delay(2000);
  lcd.clear();
  lcd.setCursor(0,1);
  lcd.print("and press A");     //Press A keep showing while the top row print  ***
             
         while(keypressed != 'A'){            //A to confirm  and quits the loop
             keypressed = myKeypad.getKey();
               if(keypressed  != NO_KEY && keypressed != 'A' ){
                lcd.setCursor(j,0);
                lcd.print("*");               //On the new code you can show * as I did or change it to keypressed  to show the keys
                code_buff1[i]=keypressed;     //Store caracters  in the array
                i++;
                j++;                    
                }
                }
keypressed = NO_KEY;
}

void  GetNewCode2(){                         //This is exactly like the GetNewCode1 function  but this time the code is stored in another array
  i=0;
  j=0;
  
  lcd.clear();
  lcd.print("Confirm code");
  lcd.setCursor(0,1);
  lcd.print("and  press A");
  delay(3000);
  lcd.clear();
  lcd.setCursor(0,1);
  lcd.print("and  press A");

         while(keypressed != 'A'){
             keypressed  = myKeypad.getKey();
               if(keypressed != NO_KEY && keypressed !=  'A' ){
                lcd.setCursor(j,0);
                lcd.print("*");
                code_buff2[i]=keypressed;
                i++;
                j++;                    
                }
                }
keypressed = NO_KEY;
}

void  OpenDoor(){             //Lock opening function open for 3s
  lcd.clear();
  lcd.print("Welcome");       //With a message printed
  digitalWrite(Relay,LOW);
  delay(3000);
  digitalWrite(Relay,HIGH);
}

Downloadable files

Relay wiring

Mosfet + Solenoid wiring

Comments

Only logged in users can leave comments

SurtrTech

0 Followers

•

0 Projects

Intro