पासवर्ड सुरक्षा लॉक सर्किट 4 × 4 कीपैड और Arduino का उपयोग करना

पासवर्ड सुरक्षा लॉक सर्किट 4 × 4 कीपैड और Arduino का उपयोग करना

इस पोस्ट में हम एक पासवर्ड सिक्योरिटी लॉक सर्किट बनाने जा रहे हैं, जिसे 6 अंकों के पासवर्ड द्वारा एक्सेस किया जा सकता है। अधिक सटीक होने के लिए यह अल्फा न्यूमेरिक पासवर्ड है।



इस परियोजना के लिए हार्डवेयर

हम 4x4 कीपैड का उपयोग करने जा रहे हैं, जिसमें 0 से 9 दशमलव मान, दो विशेष वर्ण ’#’ और to * ’और A से D अक्षर हैं। इन पात्रों के संयोजन को पासवर्ड के रूप में इस्तेमाल किया जा सकता है।

Arduino सिस्टम का मस्तिष्क है, जब सही पासवर्ड को कमांड किया जाता है, तो रिले को सक्रिय और निष्क्रिय करने के लिए Arduino के साथ हस्तक्षेप किया जाता है। लॉक सिस्टम की स्थिति को इंगित करने के लिए यहां दो संकेतक एलईडी का उपयोग किया जाता है।





यदि आप 4x4 कीपैड से परिचित नहीं हैं, तो कृपया मेरे पहले के लेख को देखें, जिसकी व्यापक चर्चा हुई 4x4 मैट्रिक्स कीपैड की मूल बातें

प्रस्तावित परियोजना में बहुत कम से कम हार्डवेयर डिजाइन है। यह सिर्फ एक कीपैड, रिले, आर्डिनो और एलईड के जोड़े से मिलकर बनता है, यहां तक ​​कि आर्डिनो में एक नॉब इसे आसानी से पूरा कर सकता है।



इस परियोजना में एकमात्र हिस्सा जो थोड़ा मुश्किल है, कोडिंग है, इस परियोजना में दिए गए कोड की चिंता न करें। कार्यक्रम को इस तरह से लिखा जाना चाहिए कि, यह मूर्खतापूर्ण सबूत है और कोई भी अपहरणकर्ता सिस्टम को हैक नहीं कर सकता है।

लेकिन, सावधान रहें यदि आप हार्डवेयर को उजागर करते हैं या इस परियोजना का हार्डवेयर आसानी से सुलभ है, तो रिले को आसानी से हैक किया जा सकता है। इसलिए इस परियोजना को अच्छी तरह से संरक्षित चेसिस में रखें।

यह काम किस प्रकार करता है

नोट: एक मौजूदा सीमित अवरोधक 4.7K को ट्रांजिस्टर के आधार से जोड़ा जाना चाहिए, जो आरेख में नहीं दिखाया गया है।

अब देखते हैं कि यह Arduino पासवर्ड सुरक्षा लॉक सर्किट कैसे कार्य करता है, कृपया सर्किट को संचालित करने के लिए नीचे दिए गए निर्देश को ध्यान से पढ़ें।

सर्किट आरेख

Arduino पासवर्ड सुरक्षा लॉक सर्किट 4x4 कीपैड का उपयोग करना

कीबोर्ड और Arduino को इंटरफ़ेस करने के दो तरीके यहां दिए गए हैं:

Arduino पासवर्ड सुरक्षा लॉक टेस्ट परिणाम

• जब सर्किट चालू होता है, तो वह पासवर्ड मांगता है, आप सीरियल मॉनिटर पर देख सकते हैं (सीरियल मॉनिटर अनिवार्य नहीं है लेकिन, परीक्षण के उद्देश्य के लिए इस्तेमाल किया जा सकता है)।

• उस पासवर्ड को दर्ज करें जिसे आपने प्रोग्राम में कंपाइल करने से पहले दर्ज किया था।

• जब आप कुंजी दबाते हैं, तो हरे रंग की एलईडी एक सेकंड के दसवें हिस्से के लिए झपकी लेती है, यह दर्शाता है कि उपयोगकर्ता द्वारा कुछ कुंजी दबाया गया है।

• एक बार जब आप 6-अंकीय पासवर्ड दर्ज करते हैं, तो कीपैड में the D ’दबाएं जो 6 Enter’ के रूप में कार्य करता है। यदि आपका पासवर्ड सही है, तो रिले सक्रिय हो जाता है, हरे रंग की एलईडी चालू हो जाती है।

• रिले को निष्क्रिय करने के लिए, कीपैड में 'C' दबाएँ। जब ऐसा किया जाता है, तो हरे रंग की एलईडी बंद हो जाती है और रिले निष्क्रिय हो जाता है। कोई अन्य कुंजी रिले को निष्क्रिय नहीं कर सकती है।

• यदि उपयोगकर्ता द्वारा दर्ज किया गया पासवर्ड गलत है, तो लाल एलईडी लाइटें बंद हो जाती हैं और उपयोगकर्ता को अगले प्रयास में प्रवेश करने के लिए 30 सेकंड इंतजार करना पड़ता है। जब 30 सेकंड खत्म हो जाता है, तो लाल एलईडी बंद हो जाता है, उपयोगकर्ता को सूचित करता है कि, सिस्टम उपयोगकर्ता से इनपुट प्राप्त करने के लिए तैयार है।

• जब रिले को सक्रिय सक्रियण के बाद निष्क्रिय कर दिया जाता है, तो रिले को फिर से सक्रिय करने के लिए, उपयोगकर्ता को फिर से पासवर्ड दर्ज करना होगा और and D ’को दबाना होगा।

यहाँ एक विशेष मामला है:

• जब सही पासवर्ड दर्ज किया जाता है, तो रिले सक्रिय हो जाता है और सफल निष्क्रिय होने के बाद, जब उपयोगकर्ता किसी एक गलत कीस्ट्रोक (संपूर्ण पासवर्ड नहीं) को हिट करता है, तो प्रोग्राम गलत पासवर्ड के रूप में पहचानता है और उपयोगकर्ता को एक और 30 सेकंड इंतजार करने की आवश्यकता होती है। यदि यह अपहर्ता था तो अपहर्ता द्वारा किए गए प्रयास में देरी करेगा।

• जब सही कीस्ट्रोक को पहले प्रयास पर दबाया जाता है, तभी यह अगली कुंजी में प्रवेश करने की अनुमति देता है। यह केवल पहले कीस्ट्रोक के लिए है और केवल सभी कीस्ट्रोक्स के लिए नहीं है।

• ऊपर बताई गई अवधारणा का उद्देश्य अपहरणकर्ता द्वारा किए गए प्रयासों की संख्या में देरी करना है।

कार्यक्रम कोड:

//---------------------------------Program Developed by R.Girish--------------------------//
#include
const byte ROWS = 4
const byte COLS = 4
char pass[] = '123ABC' // 6 digit password only (no less or no more)
int OP=10
int green=12
int red=11
char key1
char key2
char key3
char key4
char key5
char key6
char dumpkey
char keyOK
char ok[]='D'
char offkey
char off[]='C'
int z
char keys[ROWS][COLS] =
{
{'D','#','0','*'},
{'C','9','8','7'},
{'B','6','5','4'},
{'A','3','2','1'}
}
byte rowPins[ROWS] = {6,7,8,9} //connect to the row pinouts of the keypad
byte colPins[COLS] = {2,3,4,5} //connect to the column pinouts of the keypad
Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS )
void setup()
{
Serial.begin(9600)
pinMode(OP,OUTPUT)
pinMode(green,OUTPUT)
pinMode(red,OUTPUT)
digitalWrite(OP,LOW)
}
void loop()
{
top:
Serial.println('')
Serial.println('[Press D = Enter]')
Serial.print('Enter the password: ')
key1=keypad.waitForKey()
if(key1 == pass[0])
{
digitalWrite(green,HIGH)
delay(100)
digitalWrite(green,LOW)
{
z=1
Serial.print('*')
goto A

}
}
अन्य
{{
गोटो डंप
}
सेवा मेरे:
की 2 = कीपैड। बिटफॉरके ()
अगर (की 2 == पास [1])
{{
डिजिटलराइट (हरा, उच्च)
देरी (100)
digitalWrite (हरा, कम)
{{
z = २
सीरियल.प्रिंट ('*')
गोटो बी
}
}
अन्य
{{
गोटो डंप
}
बी:
की 3 = कीपैड। बिटफॉरके ()
अगर (की 3 == पास [2])
{{
डिजिटलराइट (हरा, उच्च)
देरी (100)
digitalWrite (हरा, कम)
{{
z = 3
सीरियल.प्रिंट ('*')
गोटो सी
}
}
अन्य
{{
गोटो डंप
}
सी:
की 4 = कीपैड। बिटफॉरके ()
अगर (की 4 == पास [3])
{{
डिजिटलराइट (हरा, उच्च)
देरी (100)
digitalWrite (हरा, कम)
{{
z = 4
सीरियल.प्रिंट ('*')
गोटो डी
}
}
अन्य
{{
गोटो डंप
}
D:
की 5 = कीपैड। बिटफॉरके ()
अगर (की 5 == पास [4])
{{
डिजिटलराइट (हरा, उच्च)
देरी (100)
digitalWrite (हरा, कम)
{{
z = ५
सीरियल.प्रिंट ('*')
गोटो ई
}
}
अन्य
{{
गोटो डंप
}
है:
की 6 = कीपैड। बिटफॉरके ()
अगर (की 6 == पास [5])
{{
डिजिटलराइट (हरा, उच्च)
देरी (100)
digitalWrite (हरा, कम)
{{
z = 6
सीरियल.प्रिंट ('*')
गोटो ठीक है
}
}
अन्य
{{
गोटो डंप
}
अछा ठीक है:
कीओक = कीपैड.वाइटफ़ोरके ()
अगर (की -ोक == ठीक [0])
{{
डिजिटलराइट (ओपी, हाई)
डिजिटलराइट (हरा, उच्च)
धारावाहिक.प्रदर्शन ('')
Serial.println ('रिले सक्रिय, Deactivate.n' के लिए 'C' दबाएं)
}
अन्य
{{
धारावाहिक.प्रदर्शन ('')
Serial.println ('एंटर करने के लिए' D 'दबाएं)
गोटो ठीक है
}
बंद:
offkey = कीपैड ।waitForKey ()
अगर (ऑफकी == ऑफ [0])
{{
digitalWrite (ओपी, कम)
digitalWrite (हरा, कम)
Serial.println ('रिले निष्क्रिय)'
ऊपर जाएँ
}
अन्य
{{
Serial.println ('प्रेस' सी 'से Deactivaten')
गोटो
}
डंप:
अगर (z == 0)
{{
डिजिटलराइट (हरा, उच्च)
देरी (100)
digitalWrite (हरा, कम)
सीरियल.प्रिंट ('*')
डंपकी = कीपैड.वाइटफ़ोरके ()
सीरियल.प्रिंट ('*')
डंपकी = कीपैड.वाइटफ़ोरके ()
सीरियल.प्रिंट ('*')
डंपकी = कीपैड.वाइटफ़ोरके ()
सीरियल.प्रिंट ('*')
डंपकी = कीपैड.वाइटफ़ोरके ()
सीरियल.प्रिंट ('*')
डंपकी = कीपैड.वाइटफ़ोरके ()
सीरियल.प्रिंट ('*')
डंपकी = कीपैड.वाइटफ़ोरके ()
सीरियल.प्रिंट ('*')
गोटो त्रुटि
}
अगर (z == 1)
{{
डिजिटलराइट (हरा, उच्च)
देरी (100)
digitalWrite (हरा, कम)
सीरियल.प्रिंट ('*')
डंपकी = कीपैड.वाइटफ़ोरके ()
सीरियल.प्रिंट ('*')
डंपकी = कीपैड.वाइटफ़ोरके ()
सीरियल.प्रिंट ('*')
डंपकी = कीपैड.वाइटफ़ोरके ()
सीरियल.प्रिंट ('*')
डंपकी = कीपैड.वाइटफ़ोरके ()
सीरियल.प्रिंट ('*')
डंपकी = कीपैड.वाइटफ़ोरके ()
सीरियल.प्रिंट ('*')
गोटो त्रुटि
}
अगर (z == 2)
{{
डिजिटलराइट (हरा, उच्च)
देरी (100)
digitalWrite (हरा, कम)
सीरियल.प्रिंट ('*')
डंपकी = कीपैड.वाइटफ़ोरके ()
सीरियल.प्रिंट ('*')
डंपकी = कीपैड.वाइटफ़ोरके ()
सीरियल.प्रिंट ('*')
डंपकी = कीपैड.वाइटफ़ोरके ()
सीरियल.प्रिंट ('*')
डंपकी = कीपैड.वाइटफ़ोरके ()
सीरियल.प्रिंट ('*')
गोटो त्रुटि
}
अगर (z == 3)
{{
डिजिटलराइट (हरा, उच्च)
देरी (100)
digitalWrite (हरा, कम)
सीरियल.प्रिंट ('*')
डंपकी = कीपैड.वाइटफ़ोरके ()
सीरियल.प्रिंट ('*')
डंपकी = कीपैड.वाइटफ़ोरके ()
सीरियल.प्रिंट ('*')
डंपकी = कीपैड.वाइटफ़ोरके ()
सीरियल.प्रिंट ('*')
गोटो त्रुटि
}
अगर (z == 4)
{{
डिजिटलराइट (हरा, उच्च)
देरी (100)
digitalWrite (हरा, कम)
सीरियल.प्रिंट ('*')
डंपकी = कीपैड.वाइटफ़ोरके ()
सीरियल.प्रिंट ('*')
डंपकी = कीपैड.वाइटफ़ोरके ()
सीरियल.प्रिंट ('*')
गोटो त्रुटि
}
अगर (z == 5)
{{
डिजिटलराइट (हरा, उच्च)
देरी (100)
digitalWrite (हरा, कम)
सीरियल.प्रिंट ('*')
डंपकी = कीपैड.वाइटफ़ोरके ()
सीरियल.प्रिंट ('*')
गोटो त्रुटि
}
त्रुटि:
धारावाहिक.प्रदर्शन ('')
Serial.print ('गलत पासवर्ड, 30 सेकंड तक प्रतीक्षा करें।')
digitalWrite (लाल, उच्च)
देरी (10000)
देरी (10000)
देरी (10000)
digitalWrite (लाल, कम)
ऊपर जाएँ
}
// --------------------------------- आर.गिरिश द्वारा विकसित कार्यक्रम --------- ----------------- //

ध्यान दें: पासवर्ड सेट करने के लिए: char पास [] = '123ABC' // 6 अंकों का पासवर्ड केवल (कोई कम या अधिक नहीं)
उद्धरण चिह्न के अंदर, अपने स्वयं के पासवर्ड के साथ '123ABC' बदलें।

सुनिश्चित करें कि प्रोग्राम में निर्धारित पासवर्ड 6-अंकीय है, कम या अधिक नहीं, लेकिन ठीक 6-अंकीय। अन्यथा कार्यक्रम सही ढंग से काम नहीं कर रहा है।

यदि आपको समझाए गए पासवर्ड सुरक्षा लॉक सर्किट के बारे में कोई और संदेह है, तो कृपया अपनी टिप्पणियों के माध्यम से उन्हें पोस्ट करने के लिए स्वतंत्र महसूस करें




की एक जोड़ी: सूर्योदय सूर्यास्त सिम्युलेटर एलईडी सर्किट अगला: ब्लूटूथ मोटर नियंत्रक सर्किट