మన రోజువారీ జీవితంలో భద్రత ఒక ప్రధాన ఆందోళన, మరియు ఈ భద్రతా వ్యవస్థలలో డిజిటల్ తాళాలు ఒక ముఖ్యమైన భాగంగా మారాయి. మా స్థలాన్ని భద్రపరచడానికి అనేక రకాల భద్రతా వ్యవస్థలు అందుబాటులో ఉన్నాయి. కొన్ని ఉదాహరణలు పిఐఆర్ ఆధారిత సెక్యూరిటీ సిస్టమ్, ఆర్‌ఎఫ్‌ఐడి ఆధారిత సెక్యూరిటీ సిస్టమ్, డిజిటల్ లాక్ సిస్టమ్, బయో మ్యాట్రిక్స్ సిస్టమ్స్, ఎలక్ట్రానిక్స్ కోడ్ లాక్. ఈ పోస్ట్‌లో, ఆర్డునోను ఉపయోగించి సీక్రెట్ నాక్ డిటెక్టింగ్ డోర్ లాక్‌ని నిర్మించుకుందాం, ఇది తలుపు వద్ద మీ కొట్టుల నమూనాను గుర్తించగలదు మరియు నాకింగ్ నమూనా సరైన నమూనాతో సరిపోలితే మాత్రమే లాక్‌ని తెరుస్తుంది. సరైన పని డెమో కోసం, చివరిలో వీడియోను తనిఖీ చేయండి.
భాగాలు:
- ఆర్డునో యునో
- నొక్కుడు మీట
- బజర్
- 1 ఎమ్ రెసిస్టర్
- శక్తి
- వైర్లను కనెక్ట్ చేస్తోంది
- బాక్స్
- సర్వో మోటార్
సర్క్యూట్ వివరణ:
ఈ నాకింగ్ సరళి డిటెక్టర్ యొక్క సర్క్యూట్ రేఖాచిత్రం చాలా సులభం, దీనిలో ప్రాజెక్ట్, పుష్ బటన్, బజర్ మరియు సర్వో మోటార్ యొక్క మొత్తం ప్రక్రియను నియంత్రించడానికి ఆర్డునో ఉంటుంది. పాస్‌వర్డ్ ఫారమ్ బజర్ లేదా సెన్సార్ తీసుకోవడం, నమూనాలను పోల్చడం, గేట్‌ను తెరిచి మూసివేయడం కోసం సర్వోను నడపడం మరియు నమూనాను ఆర్డునోకు సేవ్ చేయడం వంటి పూర్తి ప్రక్రియలను ఆర్డునో నియంత్రిస్తుంది.
పుష్ బటన్ నేరుగా భూమికి సంబంధించి ఆర్డునో యొక్క పిన్ డి 7 కి అనుసంధానించబడి ఉంది. మరియు భూమికి సంబంధించి మరియు A0 మరియు భూమి మధ్య 1M నిరోధకతతో Arduino యొక్క అనలాగ్ పిన్ A0 వద్ద ఒక బజర్ అనుసంధానించబడి ఉంది. ఒక సర్వో మోటారు Arduino యొక్క PWM పిన్ D3 కి కూడా అనుసంధానించబడి ఉంది.
ఆర్డునోలో నాకింగ్ సరళికి ఆహారం ఇవ్వడం:
ఈ సర్క్యూట్లో, సిస్టమ్‌లో నాక్ ఇన్పుట్ నమూనాను తీసుకోవడానికి మేము బజర్ లేదా పీజో సెన్సార్‌ను ఉపయోగించాము. ఇక్కడ మేము సెన్సార్ నుండి ఇన్పుట్ తీసుకోవడానికి మరియు దానిని ఆర్డునోలో సేవ్ చేయడానికి అనుమతించడానికి పుష్ బటన్‌ను ఉపయోగిస్తున్నాము. ఈ వ్యవస్థ మోర్స్ కోడ్ నమూనా నుండి ఆలోచన తీసుకొని రూపొందించబడింది, కానీ దానితో సరిగ్గా సరిపోదు.
ఇక్కడ మేము ప్రదర్శన కోసం కార్డ్ బోర్డు పెట్టెను ఉపయోగించాము. ఇన్పుట్ తీసుకోవడానికి మేము పుష్ బటన్ నొక్కిన తరువాత బోర్డు మీద పడతాము. ఇక్కడ మేము 500ms అని ఒక సమయ వ్యవధిని దృష్టిలో ఉంచుకుని కొట్టాము. ఈ 500ms ఎందుకంటే మేము దీన్ని కోడ్‌లో పరిష్కరించాము మరియు ఇన్పుట్ నమూనా దానిపై ఆధారపడి ఉంటుంది. ఈ 500ms కాల వ్యవధి ఇన్పుట్ 1 లేదా 0 అని నిర్వచిస్తుంది. ఈ విషయాన్ని అర్థం చేసుకోవడానికి క్రింది కోడ్‌ను తనిఖీ చేయండి.
మేము దానిని కొట్టినప్పుడు, ఆర్డునో మొదటి నాక్ యొక్క సమయాన్ని రెండవ నాక్ వరకు పర్యవేక్షించడం ప్రారంభిస్తాడు మరియు దానిని శ్రేణిలో ఉంచండి. ఇక్కడ ఈ వ్యవస్థలో, మేము 6 నాక్స్ తీసుకుంటున్నాము. అంటే మనకు 5 కాల వ్యవధులు లభిస్తాయి.
ఇప్పుడు మేము కాల వ్యవధిని ఒక్కొక్కటిగా తనిఖీ చేస్తాము. మొదట, మొదటి నాక్ మరియు రెండవ నాక్ మధ్య కాల వ్యవధిని తనిఖీ చేస్తే, ఈ 500ms కన్నా తక్కువ సమయం వ్యత్యాసం ఉంటే అది 0 అవుతుంది మరియు 500ms కంటే ఎక్కువ ఉంటే అది 1 అవుతుంది మరియు ఇది వేరియబుల్ లో సేవ్ అవుతుంది. ఇప్పుడు దాని తరువాత, మేము రెండవ నాక్ మరియు మూడవ నాక్ మధ్య సమయ వ్యవధిని తనిఖీ చేస్తాము.
చివరగా, మనకు 0 మరియు 1 ఫార్మాట్ (బైనరీ) లో 5 అంకెల అవుట్పుట్ లభిస్తుంది.
పని వివరణ:
నాక్ ఆధారిత స్మార్ట్ లాక్ ప్రాజెక్ట్ యొక్క పని చాలా సులభం. మొదట మనం వ్యవస్థలో ఒక నమూనాను సేవ్ చేయాలి. కాబట్టి మనం 6 సార్లు కొట్టుకునే వరకు పుష్ బటన్‌ను నొక్కి పట్టుకోవాలి. ఇక్కడ ఈ ప్రాజెక్ట్‌లో, నేను 6 నాక్‌లను ఉపయోగించాను కాని వినియోగదారు వారు కోరుకున్న విధంగా మార్చవచ్చు. ఆరుసార్లు కొట్టిన తరువాత, ఆర్డునో నాక్ నమూనాను కనుగొని EEPROM లో సేవ్ చేయండి. ఇప్పుడు ఇన్పుట్ నమూనాను సేవ్ చేసిన తరువాత, లాక్ తెరవడానికి సెన్సార్ నుండి ఆర్డునోకు ఇన్పుట్ తీసుకోవటానికి పుష్ బటన్‌ను నొక్కండి మరియు వెంటనే విడుదల చేయండి. ఇప్పుడు మనం 6 సార్లు కొట్టాలి. దాని తరువాత, ఆర్డునో దానిని డీకోడ్ చేసి, సేవ్ చేసిన నమూనాతో పోలుస్తుంది. ఒక మ్యాచ్ జరిగితే, ఆర్డునో సర్వో మోటారును నడపడం ద్వారా గేట్ తెరుస్తాడు.
గమనిక: మేము పుష్ బటన్‌ను నొక్కినప్పుడు లేదా నొక్కినప్పుడు ఆర్డునో మొత్తం 6 నాక్ తీసుకోవడానికి 10 సెకన్ల టైమర్‌ను ప్రారంభించండి. ఈ 10 సెకన్ల వ్యవధిలో వినియోగదారు నాక్ చేయాలి. మరియు లాగ్ చూడటానికి వినియోగదారు సీరియల్ మానిటర్‌ను తెరవవచ్చు.
ప్రోగ్రామింగ్ వివరణ:
ఒక ప్రోగ్రామ్‌లో మొదట మేము హెడర్ ఫైల్‌ను చేర్చుకుంటాము మరియు ఇన్పుట్ మరియు అవుట్పుట్ పిన్‌లను నిర్వచిస్తాము మరియు మాక్రో మరియు డిక్లేర్డ్ వేరియబుల్స్‌ను నిర్వచించాము, మీరు పూర్తి కోడ్‌లో ఈ క్రింది కోడ్ విభాగంలో చూడవచ్చు.
దీని తరువాత, సెటప్ ఫంక్షన్‌లో, మేము నిర్వచించిన పిన్‌కు దిశను ఇస్తాము మరియు సర్వో మోటారును ప్రారంభిస్తాము.
శూన్య సెటప్ () {పిన్‌మోడ్ (sw, INPUT_PULLUP); myServo.attach (సర్వోపిన్); myServo.write (180); సీరియల్.బెగిన్ (9600); }
దాని తరువాత, మేము ఇన్పుట్ తీసుకొని ఇన్పుట్ నమూనాను సేవ్ చేస్తాము లేదా శ్రేణిలో సమయాన్ని కొట్టండి.
void loop () {int i = 0; if (DigitalRead (sw) == LOW) {Serial.println ("Start"); ఆలస్యం (1000); పొడవైన stt = మిల్లీస్ (); అయితే (మిల్లిస్ () <(stt + patternInputTime)) {int temp = అనలాగ్ రీడ్ (A0); if (టెంప్> సున్నితత్వం && ఫ్లాగ్ == 0 && నేను <= patternLeth) {………….
దాని తరువాత, మేము ఇన్పుట్ నమూనాను డీకోడ్ చేస్తాము
(int i = 0; i
పుష్ బటన్ ఇంకా నొక్కితే సేవ్ చేయండి
(int i = 0; i కోసం (డిజిటల్ రీడ్ (sw) == 0) if
పుష్ బటన్ ఇంకా నొక్కితే, ఆర్డునో ఇన్పుట్ డీకోడ్ చేసిన నమూనాను సేవ్ చేసిన నమూనాతో పోలుస్తుంది.
(int i = 0; i కోసం {if (knok == 1) {
ఏదైనా పాస్‌వర్డ్ సరిపోలితే, సర్వో గేట్ తెరుస్తుంది లేకపోతే ఏమీ జరగలేదు కాని వినియోగదారు సీరియల్ మానిటర్ ద్వారా ఫలితాన్ని చూడవచ్చు.
సీరియల్.ప్రింట్ల్న్ (అంగీకరించుఫ్లాగ్); if (అంగీకరించుఫ్లాగ్> = నమూనా లెంత్ -1) {సీరియల్.ప్రింట్ల్న్ ("అంగీకరించబడింది"); myServo.write (ఓపెన్‌గేట్); ఆలస్యం (5000); myServo.write (క్లోజ్‌గేట్); } else Serial.println ("తిరస్కరించబడింది"); }
మీరు డెమో వీడియోతో క్రింద ఉన్న పూర్తి కోడ్‌ను తనిఖీ చేయవచ్చు.