పాస్‌వర్డ్ సెక్యూరిటీ లాక్ సర్క్యూట్ 4 × 4 కీప్యాడ్ మరియు ఆర్డునో ఉపయోగించి

సమస్యలను తొలగించడానికి మా పరికరాన్ని ప్రయత్నించండి





ఈ పోస్ట్‌లో మేము పాస్‌వర్డ్ సెక్యూరిటీ లాక్ సర్క్యూట్‌ను నిర్మించబోతున్నాము, దీనిని 6-అంకెల పాస్‌వర్డ్ ద్వారా యాక్సెస్ చేయవచ్చు. మరింత ఖచ్చితంగా చెప్పాలంటే ఇది ఆల్ఫా న్యూమరిక్ పాస్‌వర్డ్.

ఈ ప్రాజెక్ట్ కోసం హార్డ్వేర్

మేము 0x నుండి 9 దశాంశ విలువలు, రెండు ప్రత్యేక అక్షరాలు ‘#’ మరియు ‘*’ మరియు A నుండి D అక్షరాలను కలిగి ఉన్న 4x4 కీప్యాడ్‌ను ఉపయోగించబోతున్నాము. ఈ అక్షరాల కలయికను పాస్‌వర్డ్‌గా ఉపయోగించవచ్చు.



Arduino అనేది వ్యవస్థ యొక్క మెదడు, సరైన పాస్‌వర్డ్‌ను ఆదేశించినప్పుడు సక్రియం చేయడానికి మరియు నిష్క్రియం చేయడానికి Arduino తో రిలే ఇంటర్‌ఫేస్ చేయబడుతుంది. లాక్ సిస్టమ్ యొక్క స్థితిని సూచించడానికి ఇక్కడ రెండు సూచిక LED ఉపయోగించబడుతుంది.

మీకు 4x4 కీప్యాడ్ గురించి తెలియకపోతే, దయచేసి నా మునుపటి కథనాన్ని చూడండి, ఇది సమగ్రంగా చర్చించబడింది 4x4 మ్యాట్రిక్స్ కీప్యాడ్ యొక్క ప్రాథమికాలు



ప్రతిపాదిత ప్రాజెక్ట్ చాలా తక్కువ హార్డ్వేర్ డిజైన్ను కలిగి ఉంది. ఇది కేవలం కీప్యాడ్, రిలే, ఆర్డునో మరియు ఎల్‌ఈడీలను కలిగి ఉంటుంది, ఆర్డునోలోని ఒక నోబ్ కూడా దీన్ని సులభంగా సాధించగలదు.

ఈ ప్రాజెక్ట్‌లో కొంచెం కష్టంగా ఉన్న ఏకైక భాగం కోడింగ్, ఈ ప్రాజెక్ట్‌లో కోడ్ ఇవ్వబడిందని చింతించాల్సిన అవసరం లేదు. ప్రోగ్రామ్ ఫూల్ ప్రూఫ్ మరియు హైజాకర్ వ్యవస్థను హ్యాక్ చేయలేని విధంగా వ్రాయాలి.

కానీ, మీరు హార్డ్‌వేర్‌ను బహిర్గతం చేస్తే జాగ్రత్తగా ఉండండి లేదా ఈ ప్రాజెక్ట్ యొక్క హార్డ్‌వేర్ సులభంగా ప్రాప్తి చేయగలదు, రిలేను సులభంగా హ్యాక్ చేయవచ్చు. కాబట్టి ఈ ప్రాజెక్ట్ను బాగా రక్షిత చట్రంలో ఉంచండి.

అది ఎలా పని చేస్తుంది

గమనిక: ప్రస్తుత పరిమితి నిరోధకం 4.7K తప్పనిసరిగా ట్రాన్సిస్టర్ యొక్క స్థావరానికి అనుసంధానించబడి ఉండాలి, ఇది రేఖాచిత్రంలో చూపబడదు.

ఇప్పుడు ఈ ఆర్డునో పాస్వర్డ్ సెక్యూరిటీ లాక్ సర్క్యూట్ ఎలా పనిచేస్తుందో చూద్దాం, దయచేసి సర్క్యూట్ ఆపరేట్ చేయడానికి క్రింద ఇచ్చిన సూచనలను జాగ్రత్తగా చదవండి.

సర్క్యూట్ రేఖాచిత్రం

4x4 కీప్యాడ్ ఉపయోగించి ఆర్డునో పాస్వర్డ్ సెక్యూరిటీ లాక్ సర్క్యూట్

కీబోర్డ్ మరియు ఆర్డునోను ఎలా ఇంటర్ఫేస్ చేయాలో ఇక్కడ రెండు దృష్టాంతాలు ఉన్నాయి:

Arduino పాస్వర్డ్ సెక్యూరిటీ లాక్ పరీక్ష ఫలితాలు

The సర్క్యూట్ ఆన్ చేయబడినప్పుడు, ఇది పాస్‌వర్డ్ అడుగుతుంది, మీరు సీరియల్ మానిటర్‌లో చూడవచ్చు (సీరియల్ మానిటర్ తప్పనిసరి కాదు, కానీ పరీక్షా ప్రయోజనం కోసం ఉపయోగించవచ్చు).

Comp కంపైల్ చేయడానికి ముందు మీరు ప్రోగ్రామ్‌లో నమోదు చేసిన పాస్‌వర్డ్‌ను నమోదు చేయండి.

The మీరు కీలను నొక్కినప్పుడు, ఆకుపచ్చ LED సెకనులో పదోవంతు మెరిసిపోతుంది, ఇది కొన్ని కీని వినియోగదారు నొక్కినట్లు సూచిస్తుంది.

You మీరు 6-అంకెల పాస్‌వర్డ్‌ను నమోదు చేసిన తర్వాత, కీప్యాడ్‌లోని ‘ఎంటర్’ వలె పనిచేసే ‘డి’ నొక్కండి. మీ పాస్‌వర్డ్ సరైనది అయితే, రిలే సక్రియం అవుతుంది, ఆకుపచ్చ LED ఆన్ అవుతుంది.

Lay రిలేను నిష్క్రియం చేయడానికి, కీప్యాడ్‌లో ‘సి’ నొక్కండి. ఎప్పుడు, ఇది పూర్తయినప్పుడు, ఆకుపచ్చ LED ఆపివేయబడుతుంది మరియు రిలే నిష్క్రియం అవుతుంది. మరే ఇతర కీ రిలేను నిష్క్రియం చేయదు.

By వినియోగదారు పాస్‌వర్డ్ ఎంటర్ చేస్తే, ఎరుపు ఎల్‌ఈడీ వెలిగిపోతుంది మరియు తదుపరి ప్రయత్నంలో ప్రవేశించడానికి వినియోగదారు 30 సెకన్లు వేచి ఉండాలి. 30 సెకన్లు ముగిసినప్పుడు, ఎరుపు LED ఆపివేయబడుతుంది, వినియోగదారుకు తెలియజేస్తుంది, సిస్టమ్ వినియోగదారు నుండి ఇన్పుట్ పొందడానికి సిద్ధంగా ఉంది.

Successful విజయవంతమైన క్రియాశీలత తర్వాత రిలే క్రియారహితం అయినప్పుడు, రిలేను మళ్లీ సక్రియం చేయడానికి, వినియోగదారు మళ్లీ పాస్‌వర్డ్‌ను నమోదు చేసి ‘D’ నొక్కాలి.

ఇక్కడ ఒక ప్రత్యేక సందర్భం:

Password సరైన పాస్‌వర్డ్ ఎంటర్ చేసినప్పుడు, రిలే సక్రియం అవుతుంది మరియు విజయవంతంగా క్రియారహితం అయిన తర్వాత, వినియోగదారు ఏదైనా తప్పు కీస్ట్రోక్‌ను తాకినప్పుడు (మొత్తం పాస్‌వర్డ్ కాదు), ప్రోగ్రామ్ తప్పు పాస్‌వర్డ్‌గా గుర్తిస్తుంది మరియు వినియోగదారు మరో 30 సెకన్లు వేచి ఉండాలి. ఇది హైజాకర్ అయితే అది హైజాకర్ చేసిన ప్రయత్నాల సంఖ్యను ఆలస్యం చేస్తుంది.

Key మొదటి ప్రయత్నంలో సరైన కీస్ట్రోక్ నొక్కినప్పుడు, అది మాత్రమే తదుపరి కీని నమోదు చేయడానికి అనుమతిస్తుంది. ఇది మొదటి కీస్ట్రోక్ కోసం మాత్రమే మరియు అన్ని వరుస కీస్ట్రోక్‌లకు మాత్రమే కాదు.

Designed హైజాకర్ చేసిన ప్రయత్నాల సంఖ్యను ఆలస్యం చేయడమే పైన వివరించిన భావన యొక్క నినాదం.

ప్రోగ్రామ్ కోడ్:

//---------------------------------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

}
}
లేకపోతే
{
గోటో డంప్
}
TO:
key2 = keypad.nightForKey ()
if (key2 == pass [1])
{
డిజిటల్ రైట్ (ఆకుపచ్చ, అధిక)
ఆలస్యం (100)
డిజిటల్ రైట్ (ఆకుపచ్చ, తక్కువ)
{
z = 2
సీరియల్.ప్రింట్ ('*')
గోటో బి
}
}
లేకపోతే
{
గోటో డంప్
}
బి:
key3 = keypad.nightForKey ()
if (key3 == pass [2])
{
డిజిటల్ రైట్ (ఆకుపచ్చ, అధిక)
ఆలస్యం (100)
డిజిటల్ రైట్ (ఆకుపచ్చ, తక్కువ)
{
z = 3
సీరియల్.ప్రింట్ ('*')
గోటో సి
}
}
లేకపోతే
{
గోటో డంప్
}
సి:
key4 = keypad.nightForKey ()
if (key4 == pass [3])
{
డిజిటల్ రైట్ (ఆకుపచ్చ, అధిక)
ఆలస్యం (100)
డిజిటల్ రైట్ (ఆకుపచ్చ, తక్కువ)
{
z = 4
సీరియల్.ప్రింట్ ('*')
గోటో డి
}
}
లేకపోతే
{
గోటో డంప్
}
డి:
key5 = keypad.nightForKey ()
if (key5 == pass [4])
{
డిజిటల్ రైట్ (ఆకుపచ్చ, అధిక)
ఆలస్యం (100)
డిజిటల్ రైట్ (ఆకుపచ్చ, తక్కువ)
{
z = 5
సీరియల్.ప్రింట్ ('*')
గోటో ఇ
}
}
లేకపోతే
{
గోటో డంప్
}
IS:
key6 = keypad.nightForKey ()
if (key6 == pass [5])
{
డిజిటల్ రైట్ (ఆకుపచ్చ, అధిక)
ఆలస్యం (100)
డిజిటల్ రైట్ (ఆకుపచ్చ, తక్కువ)
{
z = 6
సీరియల్.ప్రింట్ ('*')
goto ok
}
}
లేకపోతే
{
గోటో డంప్
}
అలాగే:
keyOK = keypad.nightForKey ()
if (keyOK == ok [0])
{
డిజిటల్ రైట్ (OP, HIGH)
డిజిటల్ రైట్ (ఆకుపచ్చ, అధిక)
సీరియల్.ప్రింట్ల్న్ ('')
Serial.println ('రిలే సక్రియం చేయబడింది, Deactivate.n' కు 'C' నొక్కండి)
}
లేకపోతే
{
సీరియల్.ప్రింట్ల్న్ ('')
Serial.println ('ఎంటర్ చేయడానికి' D 'నొక్కండి')
goto ok
}
ఆఫ్:
offkey = keypad.nightForKey ()
if (offkey == off [0])
{
డిజిటల్ రైట్ (OP, LOW)
డిజిటల్ రైట్ (ఆకుపచ్చ, తక్కువ)
సీరియల్.ప్రింట్ల్న్ ('రిలే డీయాక్టివేటెడ్.ఎన్')
గోటో టాప్
}
లేకపోతే
{
Serial.println ('క్రియారహితం చేయడానికి' C 'నొక్కండి)
గొటో ఆఫ్
}
డంప్:
if (z == 0)
{
డిజిటల్ రైట్ (ఆకుపచ్చ, అధిక)
ఆలస్యం (100)
డిజిటల్ రైట్ (ఆకుపచ్చ, తక్కువ)
సీరియల్.ప్రింట్ ('*')
డంప్‌కీ = కీప్యాడ్.వైట్ఫోర్కే ()
సీరియల్.ప్రింట్ ('*')
డంప్‌కీ = కీప్యాడ్.వైట్ఫోర్కే ()
సీరియల్.ప్రింట్ ('*')
డంప్‌కీ = కీప్యాడ్.వైట్ఫోర్కే ()
సీరియల్.ప్రింట్ ('*')
డంప్‌కీ = కీప్యాడ్.వైట్ఫోర్కే ()
సీరియల్.ప్రింట్ ('*')
డంప్‌కీ = కీప్యాడ్.వైట్ఫోర్కే ()
సీరియల్.ప్రింట్ ('*')
డంప్‌కీ = కీప్యాడ్.వైట్ఫోర్కే ()
సీరియల్.ప్రింట్ ('*')
గోటో లోపం
}
if (z == 1)
{
డిజిటల్ రైట్ (ఆకుపచ్చ, అధిక)
ఆలస్యం (100)
డిజిటల్ రైట్ (ఆకుపచ్చ, తక్కువ)
సీరియల్.ప్రింట్ ('*')
డంప్‌కీ = కీప్యాడ్.వైట్ఫోర్కే ()
సీరియల్.ప్రింట్ ('*')
డంప్‌కీ = కీప్యాడ్.వైట్ఫోర్కే ()
సీరియల్.ప్రింట్ ('*')
డంప్‌కీ = కీప్యాడ్.వైట్ఫోర్కే ()
సీరియల్.ప్రింట్ ('*')
డంప్‌కీ = కీప్యాడ్.వైట్ఫోర్కే ()
సీరియల్.ప్రింట్ ('*')
డంప్‌కీ = కీప్యాడ్.వైట్ఫోర్కే ()
సీరియల్.ప్రింట్ ('*')
గోటో లోపం
}
if (z == 2)
{
డిజిటల్ రైట్ (ఆకుపచ్చ, అధిక)
ఆలస్యం (100)
డిజిటల్ రైట్ (ఆకుపచ్చ, తక్కువ)
సీరియల్.ప్రింట్ ('*')
డంప్‌కీ = కీప్యాడ్.వైట్ఫోర్కే ()
సీరియల్.ప్రింట్ ('*')
డంప్‌కీ = కీప్యాడ్.వైట్ఫోర్కే ()
సీరియల్.ప్రింట్ ('*')
డంప్‌కీ = కీప్యాడ్.వైట్ఫోర్కే ()
సీరియల్.ప్రింట్ ('*')
డంప్‌కీ = కీప్యాడ్.వైట్ఫోర్కే ()
సీరియల్.ప్రింట్ ('*')
గోటో లోపం
}
if (z == 3)
{
డిజిటల్ రైట్ (ఆకుపచ్చ, అధిక)
ఆలస్యం (100)
డిజిటల్ రైట్ (ఆకుపచ్చ, తక్కువ)
సీరియల్.ప్రింట్ ('*')
డంప్‌కీ = కీప్యాడ్.వైట్ఫోర్కే ()
సీరియల్.ప్రింట్ ('*')
డంప్‌కీ = కీప్యాడ్.వైట్ఫోర్కే ()
సీరియల్.ప్రింట్ ('*')
డంప్‌కీ = కీప్యాడ్.వైట్ఫోర్కే ()
సీరియల్.ప్రింట్ ('*')
గోటో లోపం
}
if (z == 4)
{
డిజిటల్ రైట్ (ఆకుపచ్చ, అధిక)
ఆలస్యం (100)
డిజిటల్ రైట్ (ఆకుపచ్చ, తక్కువ)
సీరియల్.ప్రింట్ ('*')
డంప్‌కీ = కీప్యాడ్.వైట్ఫోర్కే ()
సీరియల్.ప్రింట్ ('*')
డంప్‌కీ = కీప్యాడ్.వైట్ఫోర్కే ()
సీరియల్.ప్రింట్ ('*')
గోటో లోపం
}
if (z == 5)
{
డిజిటల్ రైట్ (ఆకుపచ్చ, అధిక)
ఆలస్యం (100)
డిజిటల్ రైట్ (ఆకుపచ్చ, తక్కువ)
సీరియల్.ప్రింట్ ('*')
డంప్‌కీ = కీప్యాడ్.వైట్ఫోర్కే ()
సీరియల్.ప్రింట్ ('*')
గోటో లోపం
}
లోపం:
సీరియల్.ప్రింట్ల్న్ ('')
సీరియల్.ప్రింట్ ('తప్పు పాస్‌వర్డ్, 30 సెకన్లపాటు వేచి ఉండండి.')
డిజిటల్ రైట్ (ఎరుపు, అధిక)
ఆలస్యం (10000)
ఆలస్యం (10000)
ఆలస్యం (10000)
డిజిటల్ రైట్ (ఎరుపు, తక్కువ)
గోటో టాప్
}
// --------------------------------- ఆర్.గిరీష్ అభివృద్ధి చేసిన కార్యక్రమం --------- ----------------- //

గమనిక: పాస్వర్డ్ను సెట్ చేయడానికి: చార్ పాస్ [] = '123ABC' // 6 అంకెల పాస్వర్డ్ మాత్రమే (తక్కువ లేదా అంతకంటే ఎక్కువ కాదు)
కొటేషన్ మార్క్ లోపల, మీ స్వంత పాస్‌వర్డ్‌తో “123ABC” ని మార్చండి.

ప్రోగ్రామ్‌లో సెట్ చేసిన పాస్‌వర్డ్ 6-అంకెలు మాత్రమే అని నిర్ధారించుకోండి, తక్కువ లేదా అంతకంటే ఎక్కువ కాదు, ఖచ్చితంగా 6-అంకెలు. లేకపోతే ప్రోగ్రామ్ సరిగ్గా పనిచేయదు.

వివరించిన పాస్‌వర్డ్ సెక్యూరిటీ లాక్ సర్క్యూట్‌కు సంబంధించి మీకు ఏవైనా సందేహాలు ఉంటే, దయచేసి వాటిని మీ వ్యాఖ్యల ద్వారా పోస్ట్ చేయడానికి సంకోచించకండి




మునుపటి: సూర్యోదయ సూర్యాస్తమయం సిమ్యులేటర్ LED సర్క్యూట్ తర్వాత: బ్లూటూత్ మోటార్ కంట్రోలర్ సర్క్యూట్