Arduino-യിലെ സ്മാർട്ട് ഇലക്ട്രോണിക് ലോക്ക്, ബ്ലൂടൂത്ത് വഴി പ്രവർത്തിക്കുന്നു - മുൻവാതിൽ സ്പൈഡർമാൻ പോലെയാണ്. വീട്ടിൽ നിർമ്മിച്ച കീബോർഡ് ഉപയോഗിച്ച് Arduino-യിലെ Arduino കോഡ് ലോക്കിലെ അസാധാരണ കോമ്പിനേഷൻ ലോക്ക്

ജോലിസ്ഥലത്ത് ഞങ്ങളുടെ വാതിലിൽ ഒരു കോമ്പിനേഷൻ ലോക്ക് ഇൻസ്റ്റാൾ ചെയ്യാൻ ഞങ്ങൾ തീരുമാനിച്ചു, കാരണം ഞങ്ങൾ നിരന്തരം ഓടുന്നു - ഞങ്ങൾ ഓഫീസിൽ നിന്ന് പുറത്തേക്ക് ഓടുന്നു, അതിലേക്കുള്ള വാതിൽ താമസക്കാരുടെ അഭാവത്തിൽ നിരന്തരം അടച്ചിരിക്കണം. കീകൾ പലപ്പോഴും ഉള്ളിൽ മറന്നുപോകുന്നു. പൊതുവേ, ഒരു കോമ്പിനേഷൻ ലോക്ക് ഒരു മികച്ച പരിഹാരമാണെന്ന് ഞങ്ങൾ തീരുമാനിച്ചു.

ചൈനീസ് ഫ്ലീ മാർക്കറ്റുകളിലൂടെയും ഇബേയിലൂടെയും ചുറ്റിക്കറങ്ങിയതിനാൽ, വിലകുറഞ്ഞതും കൂടുതലോ കുറവോ ഗൗരവമുള്ളതുമായ ഒന്നും ഞാൻ കണ്ടെത്തിയില്ല, അത് സ്വയം നിർമ്മിക്കാൻ തീരുമാനിച്ചു. മൈക്രോകൺട്രോളറുകളിൽ എനിക്ക് അനുഭവം ഇല്ലാത്തതിനാൽ Arduino പ്ലാറ്റ്ഫോം അതിൻ്റെ ലാളിത്യത്തിനായി തിരഞ്ഞെടുത്തുവെന്ന് ഞാൻ ഉടൻ പറയും.

ആശയം

പാസ്‌വേഡ് നൽകിയ വാതിലിൻ്റെ പുറത്ത് ഒരു കീബോർഡ് ഉണ്ടായിരിക്കണം, ബാക്കിയുള്ള ഘടന അകത്ത് ഉറപ്പിക്കണം. വാതിൽ പൂർണ്ണമായും അടയ്ക്കുന്നത് നിയന്ത്രിക്കാൻ ഒരു റീഡ് സ്വിച്ച് ഉപയോഗിക്കുന്നു. ഓഫീസിൽ നിന്ന് പുറത്തുപോകുമ്പോൾ, ഒരു വ്യക്തി കീബോർഡിൽ "*" അമർത്തി, വാതിൽ അടയ്ക്കുന്നത് വരെ കാത്തിരിക്കാതെ, തൻ്റെ ബിസിനസ്സിലേക്ക് പോകുന്നു, വാതിൽ പൂർണ്ണമായും അടയ്ക്കുമ്പോൾ, റീഡ് സ്വിച്ച് അടയ്ക്കുകയും ലോക്ക് അടയ്ക്കുകയും ചെയ്യും. . 4 അക്ക പാസ്‌വേഡ് നൽകി "#" അമർത്തിയാൽ വാതിൽ തുറക്കുന്നു.

ആക്സസറികൾ

Arduino UNO = $18
Arduino പ്രോട്ടോഷീൽഡ് + ബ്രെഡ്ബോർഡ് = $6
L293D = $1
ബ്രാഡ്‌ബോർഡിനുള്ള വയർ ബണ്ടിൽ 30pcs = $4
2 RJ45 സോക്കറ്റുകൾ = $4
2 RJ45 പ്ലഗുകൾ = $0.5
സെൻട്രൽ ലോക്കിംഗ് ആക്യുവേറ്റർ = 250 റബ്.
റീഡ് സ്വിച്ച് = പഴയ വിൻഡോയിൽ നിന്ന് സ്വതന്ത്രമായി കീറി.
ഭീമൻ ലോഹ ലാച്ച് = സ്വതന്ത്ര
ഒന്നര മില്ലിമീറ്റർ ഇരുമ്പ് കൊണ്ട് നിർമ്മിച്ച പഴയ D-LINK ഹബ്ബിൽ നിന്നുള്ള ഭവനം = സൗജന്യം
12-നും 5V-നും ഒരേ D-LINK ഹബ്ബിൽ നിന്നുള്ള വൈദ്യുതി വിതരണം = സൗജന്യവും
ഈ സാധനങ്ങളെല്ലാം ശരീരത്തിൽ ഘടിപ്പിക്കുന്നതിനുള്ള ഒരു കൂട്ടം സ്ക്രൂകളും നട്ടുകളും = 100 റൂബിൾസ്.
സുരക്ഷാ അലാറം നിയന്ത്രണ പാനൽ = സൗജന്യം.

ആകെ:$ 33.5 ഉം 350 റൂബിളുകളും.

അത്ര ചെറുതല്ല, നിങ്ങൾ പറയും, നിങ്ങൾ തീർച്ചയായും ശരിയാകും, പക്ഷേ നിങ്ങൾ സന്തോഷത്തിനായി പണം നൽകണം! നിങ്ങളുടെ സ്വന്തം കൈകൊണ്ട് എന്തെങ്കിലും കൂട്ടിച്ചേർക്കുന്നത് എല്ലായ്പ്പോഴും നല്ലതാണ്. കൂടാതെ, നിങ്ങൾ Arduino ഇല്ലാതെ ഒരു വെറും MK ഉപയോഗിക്കുകയാണെങ്കിൽ ഡിസൈൻ ചെലവ് ഗണ്യമായി കുറയ്ക്കാൻ കഴിയും.

അസംബ്ലിക്ക് തയ്യാറെടുക്കുന്നു

ആക്യുവേറ്റർ ഡിസൈനിൻ്റെ ഒരു പ്രധാന ഘടകം വാങ്ങുന്നതിനെക്കുറിച്ച് കുറച്ച് വാക്കുകൾ പറയാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. ഒരു പ്രാദേശിക ഓട്ടോ സ്റ്റോർ എനിക്ക് രണ്ട് തരം ആക്യുവേറ്ററുകൾ വാഗ്ദാനം ചെയ്തു: "രണ്ട് വയറുകളും അഞ്ച് കൂടെ." വിൽപ്പനക്കാരൻ്റെ അഭിപ്രായത്തിൽ, അവ തികച്ചും സമാനമായിരുന്നു, വയറുകളുടെ എണ്ണത്തിലെ വ്യത്യാസം അർത്ഥമാക്കുന്നത് ഒന്നുമല്ല. എന്നിരുന്നാലും, പിന്നീട് തെളിഞ്ഞതുപോലെ, ഇത് അങ്ങനെയല്ല! ഞാൻ രണ്ട് വയറുകളുള്ള ഒരു ഉപകരണം തിരഞ്ഞെടുത്തു, അത് 12V ആണ് നൽകുന്നത്. ലിവറിൻ്റെ ചലനം നിയന്ത്രിക്കുന്നതിനുള്ള ലിമിറ്റ് സ്വിച്ചുകൾ അഞ്ച് വയർ ഡിസൈൻ സവിശേഷതകൾ. എടുത്ത് മാറ്റി നോക്കിയപ്പോഴാണ് ഞാൻ വാങ്ങിയത് തെറ്റാണെന്ന് മനസ്സിലായത്, അത് മാറ്റാൻ വൈകി. ലാച്ച് ശരിയായി പിൻവലിക്കാൻ ലിവറിൻ്റെ സ്ട്രോക്ക് വളരെ ചെറുതായി മാറി, അതിനാൽ, ഇത് കുറച്ച് പരിഷ്കരിക്കേണ്ടത് ആവശ്യമാണ്, അതായത്, ആക്യുവേറ്റർ ലിവറിൻ്റെ സ്ട്രോക്ക് ചുരുക്കിയ രണ്ട് റബ്ബർ വാഷറുകൾ നീക്കംചെയ്യുക. ഇത് ചെയ്യുന്നതിന്, രണ്ടാമത്തെ വാഷർ ഉള്ളിലായതിനാൽ ശരീരം ഒരു സാധാരണ ഹാക്സോ ഉപയോഗിച്ച് നീളത്തിൽ മുറിക്കേണ്ടതുണ്ട്. ബ്ലൂ ഇലക്ട്രിക്കൽ ടേപ്പ്, എല്ലായ്പ്പോഴും എന്നപോലെ, അത് തിരികെ കൂട്ടിച്ചേർക്കുമ്പോൾ ഭാവിയിൽ ഞങ്ങളെ സഹായിച്ചു.
ആക്യുവേറ്റർ മോട്ടോർ നിയന്ത്രിക്കാൻ, ഞങ്ങൾ ഒരു L293D മോട്ടോർ ഡ്രൈവർ ഉപയോഗിച്ചു, അത് 1200 mA വരെയുള്ള പീക്ക് ലോഡിനെ നേരിടാൻ കഴിയും, ഞങ്ങൾ ആക്യുവേറ്റർ മോട്ടോർ നിർത്തിയപ്പോൾ, പീക്ക് ലോഡ് 600 mA ആയി വർദ്ധിച്ചു.
സുരക്ഷാ അലാറം കൺട്രോൾ പാനലിൽ നിന്ന് കീബോർഡ്, സ്പീക്കർ, രണ്ട് എൽഇഡി എന്നിവയിൽ നിന്നുള്ള കോൺടാക്റ്റുകൾ നീക്കം ചെയ്തു. വിദൂര നിയന്ത്രണവും പ്രധാന ഉപകരണവും വളച്ചൊടിച്ച ജോഡിയും RJ45 കണക്റ്ററുകളും ഉപയോഗിച്ച് ബന്ധിപ്പിക്കേണ്ടതായിരുന്നു

പ്രോഗ്രാമിംഗ്.

അതിനാൽ, ആർഡ്വിനോ പ്രോഗ്രാമിംഗിൽ എനിക്ക് ഇതുവരെ പരിചയമില്ലായിരുന്നു. arduino.cc എന്ന സൈറ്റിൽ നിന്നുള്ള മറ്റുള്ളവരുടെ ജോലികളും ലേഖനങ്ങളും ഞാൻ ഉപയോഗിച്ചു. താൽപ്പര്യമുള്ള ആർക്കും ഈ വൃത്തികെട്ട കോഡ് നോക്കാം :)

ഫോട്ടോയും വീഡിയോയും

ആർഡ്വിനോയും ആക്യുവേറ്ററും

വൈദ്യുതി യൂണിറ്റ്

കീബോർഡ്

Espagnolette (മെറ്റൽ സ്‌പോക്ക് ഉപയോഗിച്ച് ആക്യുവേറ്ററുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു, സൗന്ദര്യത്തിനായി ഹീറ്റ് ഷ്രിങ്ക് കൊണ്ട് മൂടിയിരിക്കുന്നു)

ഉപകരണ പ്രവർത്തന പ്രക്രിയയുടെ വീഡിയോ:

ഇലക്ട്രോണിക് കീ (ടാഗ്) ഉപയോഗിച്ച് ലോക്ക് അൺലോക്ക് ചെയ്യുന്ന ലളിതമായ ഒരു സിസ്റ്റം എങ്ങനെ നിർമ്മിക്കാമെന്ന് ഈ പാഠത്തിൽ നമ്മൾ പഠിക്കും.

ഭാവിയിൽ, നിങ്ങൾക്ക് പ്രവർത്തനക്ഷമത മെച്ചപ്പെടുത്താനും വികസിപ്പിക്കാനും കഴിയും. ഉദാഹരണത്തിന്, "പുതിയ കീകൾ ചേർക്കുകയും അവ മെമ്മറിയിൽ നിന്ന് നീക്കം ചെയ്യുകയും ചെയ്യുക" എന്ന ഫംഗ്ഷൻ ചേർക്കുക. അടിസ്ഥാന സാഹചര്യത്തിൽ, പ്രോഗ്രാം കോഡിൽ ഒരു അദ്വിതീയ കീ ഐഡൻ്റിഫയർ മുൻകൂട്ടി സജ്ജമാക്കിയിരിക്കുന്ന ഒരു ലളിതമായ ഉദാഹരണം നോക്കാം.

ഈ ട്യൂട്ടോറിയലിൽ ഞങ്ങൾക്ക് ഇത് ആവശ്യമാണ്:

പ്രോജക്റ്റ് നടപ്പിലാക്കാൻ ഞങ്ങൾ ലൈബ്രറികൾ ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതുണ്ട്:

2) ഇപ്പോൾ നിങ്ങൾ ഒരു ബസർ കണക്റ്റുചെയ്യേണ്ടതുണ്ട്, അത് കീ പ്രവർത്തിക്കുകയും ലോക്ക് തുറക്കുകയും ചെയ്താൽ ഒരു സിഗ്നലും ലോക്ക് അടയ്ക്കുമ്പോൾ രണ്ടാമത്തെ സിഗ്നലും നൽകും.

ഇനിപ്പറയുന്ന ക്രമത്തിൽ ഞങ്ങൾ ബസറിനെ ബന്ധിപ്പിക്കുന്നു:

ആർഡ്വിനോ	ബസർ
5V	വി.സി.സി
ജിഎൻഡി	ജിഎൻഡി
പിൻ 5	ഐ.ഒ

3) അൺലോക്കിംഗ് മെക്കാനിസമായി ഒരു സെർവോ ഡ്രൈവ് ഉപയോഗിക്കും. നിങ്ങൾക്ക് ആവശ്യമുള്ള വലുപ്പവും സെർവോ ഡ്രൈവ് സൃഷ്ടിക്കുന്ന ശക്തിയും അനുസരിച്ച് ഏത് സെർവോ ഡ്രൈവും തിരഞ്ഞെടുക്കാനാകും. സെർവോയ്ക്ക് 3 കോൺടാക്റ്റുകൾ ഉണ്ട്:

ചുവടെയുള്ള ചിത്രത്തിലെ എല്ലാ മൊഡ്യൂളുകളും ഞങ്ങൾ എങ്ങനെ ബന്ധിപ്പിച്ചുവെന്ന് നിങ്ങൾക്ക് കൂടുതൽ വ്യക്തമായി കാണാൻ കഴിയും:

ഇപ്പോൾ, എല്ലാം ബന്ധിപ്പിച്ചിട്ടുണ്ടെങ്കിൽ, നിങ്ങൾക്ക് പ്രോഗ്രാമിംഗിലേക്ക് പോകാം.

സ്കെച്ച്:

#ഉൾപ്പെടുന്നു #ഉൾപ്പെടുന്നു #ഉൾപ്പെടുന്നു // "RFID" ലൈബ്രറി. #SS_PIN 10 നിർവചിക്കുക #RST_PIN 9 MFRC522 mfrc522(SS_PIN, RST_PIN); ഒപ്പിടാത്ത നീണ്ട uidDec, uidDecTemp; // ടാഗ് നമ്പർ ഡെസിമൽ ഫോർമാറ്റിൽ സെർവോ സെർവോയിൽ സൂക്ഷിക്കാൻ; void setup() ( Serial.begin(9600); Serial.println("കാർഡിനായി കാത്തിരിക്കുന്നു..."); SPI.begin(); // SPI ഇനീഷ്യലൈസേഷൻ / Init SPI ബസ്. mfrc522.PCD_Init(); // initialization MFRC522 / Init MFRC522 card (6); servo.write (0) ശൂന്യമായ ലൂപ്പിലേക്ക് സജ്ജമാക്കുക ( (മടങ്ങുക; ) // എങ്കിൽ (! mfrc522.PICC_ReadCardSerial()) (മടങ്ങുക; ) uidDec = 0 // എന്നതിനായുള്ള ടാഗിൻ്റെ സീരിയൽ നമ്പർ ഔട്ട്‌പുട്ട് ചെയ്യുക (ബൈറ്റ് i = 0; i< mfrc522.uid.size; i++) { uidDecTemp = mfrc522.uid.uidByte[i]; uidDec = uidDec * 256 + uidDecTemp; } Serial.println("Card UID: "); Serial.println(uidDec); // Выводим UID метки в консоль. if (uidDec == 3763966293) // Сравниваем Uid метки, если он равен заданому то серва открывает. { tone(5, 200, 500); // Делаем звуковой сигнал, Открытие servo.write(90); // Поворациваем серву на угол 90 градусов(Отпираем какой либо механизм: задвижку, поворациваем ключ и т.д.) delay(3000); // пауза 3 сек и механизм запирается. tone(5, 500, 500); // Делаем звуковой сигнал, Закрытие } servo.write(0); // устанавливаем серву в закрытое сосотояние }

സ്കെച്ച് കൂടുതൽ വിശദമായി നോക്കാം:

കാർഡിൻ്റെ (ടാഗ്) യുഐഡി കണ്ടെത്തുന്നതിന്, നിങ്ങൾ ഈ സ്കെച്ച് ആർഡ്വിനോയിലേക്ക് എഴുതുകയും മുകളിൽ വിവരിച്ച സർക്യൂട്ട് കൂട്ടിച്ചേർക്കുകയും കൺസോൾ തുറക്കുകയും വേണം (സീരിയൽ പോർട്ട് മോണിറ്ററിംഗ്). നിങ്ങൾ RFID ടാഗിൽ സ്പർശിക്കുമ്പോൾ, കൺസോൾ ഒരു നമ്പർ പ്രദർശിപ്പിക്കും

തത്ഫലമായുണ്ടാകുന്ന യുഐഡി ഇനിപ്പറയുന്ന വരിയിൽ നൽകണം:

എങ്കിൽ (uidDec == 3763966293) // ടാഗിൻ്റെ യുഐഡി താരതമ്യം ചെയ്യുക, അത് നൽകിയിരിക്കുന്നതിന് തുല്യമാണെങ്കിൽ, സെർവോ ഡ്രൈവ് വാൽവ് തുറക്കുന്നു.

ഓരോ കാർഡിനും ഒരു അദ്വിതീയ ഐഡൻ്റിഫയർ ഉണ്ട്, അത് ആവർത്തിക്കില്ല. അതിനാൽ, പ്രോഗ്രാമിൽ നിങ്ങൾ സജ്ജീകരിച്ച ഐഡൻ്റിഫയർ കാർഡ് അവതരിപ്പിക്കുമ്പോൾ, ഒരു സെർവോ ഡ്രൈവ് ഉപയോഗിച്ച് സിസ്റ്റം ആക്സസ് തുറക്കും.

വീഡിയോ:

കഴിഞ്ഞ ദിവസം ഞാൻ The Amazing Spider-Man കാണുകയായിരുന്നു, ഒരു സീനിൽ പീറ്റർ പാർക്കർ തൻ്റെ ലാപ്‌ടോപ്പിൽ നിന്ന് ഒരു വാതിൽ വിദൂരമായി തുറക്കുകയും അടയ്ക്കുകയും ചെയ്യുന്നു. ഇത് കണ്ടയുടനെ, എൻ്റെ മുൻവാതിലിനും അത്തരമൊരു ഇലക്ട്രോണിക് ലോക്ക് ആവശ്യമാണെന്ന് എനിക്ക് പെട്ടെന്ന് മനസ്സിലായി.

അൽപനേരം ചുറ്റിക്കറങ്ങി, ഞാൻ ഒരു സ്മാർട്ട് ലോക്കിൻ്റെ വർക്കിംഗ് മോഡൽ കൂട്ടിച്ചേർത്തു. ഈ ലേഖനത്തിൽ ഞാൻ അത് എങ്ങനെ സമാഹരിച്ചുവെന്ന് നിങ്ങളോട് പറയും.

ഘട്ടം 1: മെറ്റീരിയലുകളുടെ ലിസ്റ്റ്

Arduino- ൽ ഒരു ഇലക്ട്രോണിക് ലോക്ക് കൂട്ടിച്ചേർക്കാൻ നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന മെറ്റീരിയലുകൾ ആവശ്യമാണ്:

ഇലക്ട്രോണിക്സ്:

• 5V വാൾ അഡാപ്റ്റർ

ഘടകങ്ങൾ:

• 6 ലാച്ച് സ്ക്രൂകൾ
• കാർഡ്ബോർഡ്
• വയറുകൾ

ഉപകരണങ്ങൾ:

• സോളിഡിംഗ് ഇരുമ്പ്
• പശ തോക്ക്
• ഡ്രിൽ
• ഡ്രിൽ
• പൈലറ്റ് ഹോൾ ഡ്രിൽ
• സ്റ്റേഷനറി കത്തി
• Arduino IDE പ്രോഗ്രാമുള്ള കമ്പ്യൂട്ടർ

ഘട്ടം 2: ലോക്ക് എങ്ങനെ പ്രവർത്തിക്കുന്നു

താക്കോലില്ലാതെ വാതിൽ തുറക്കുകയോ അടയ്ക്കുകയോ ചെയ്യാം, അതിൻ്റെ അടുത്തേക്ക് പോലും പോകാതെ തന്നെ എനിക്ക് വാതിൽ തുറക്കാം എന്നതാണ് ആശയം. എന്നാൽ ഇത് അടിസ്ഥാന ആശയം മാത്രമാണ്, കാരണം നിങ്ങൾക്ക് ഒരു നോക്ക് സെൻസറും ചേർക്കാം, അതിലൂടെ അത് ഒരു പ്രത്യേക തട്ടിനോട് പ്രതികരിക്കും അല്ലെങ്കിൽ നിങ്ങൾക്ക് ഒരു വോയ്‌സ് റെക്കഗ്നിഷൻ സിസ്റ്റം ചേർക്കാം!

ബ്ലൂടൂത്ത് മൊഡ്യൂൾ വഴി ലഭിക്കുന്ന കമാൻഡുകൾ ഉപയോഗിച്ച് ബോൾട്ടുമായി ബന്ധിപ്പിച്ചിരിക്കുന്ന ഒരു സെർവോ ലിവർ അത് (0°) അടച്ച് (60°) തുറക്കും.

ഘട്ടം 3: വയറിംഗ് ഡയഗ്രം

ആദ്യം നമുക്ക് സെർവോയെ Arduino ബോർഡുമായി ബന്ധിപ്പിക്കാം (ഞാൻ ഒരു Arduino നാനോ ബോർഡാണ് ഉപയോഗിച്ചതെങ്കിലും, Uno ബോർഡിന് അതേ പിൻഔട്ട് ഉണ്ടെന്ന് ശ്രദ്ധിക്കുക).

• സെർവോയുടെ തവിട്ട് വയർ ഗ്രൗണ്ടിംഗ് ആണ്, ഞങ്ങൾ അതിനെ ആർഡ്വിനോയിലെ നിലവുമായി ബന്ധിപ്പിക്കുന്നു
• ചുവന്ന വയർ ഒരു പ്ലസ് ആണ്, ഞങ്ങൾ അതിനെ Arduino-യിലെ 5V കണക്റ്ററിലേക്ക് ബന്ധിപ്പിക്കുന്നു
• ഓറഞ്ച് വയർ എന്നത് സെർവോ ഡ്രൈവ് സോഴ്‌സ് പിൻ ആണ്, ഇത് Arduino-ലെ പിൻ 9-ലേക്ക് ബന്ധിപ്പിക്കുക

അസംബ്ലിയുമായി മുന്നോട്ടുപോകുന്നതിനുമുമ്പ് സെർവോയുടെ പ്രവർത്തനം പരിശോധിക്കാൻ ഞാൻ നിങ്ങളെ ഉപദേശിക്കുന്നു. ഇത് ചെയ്യുന്നതിന്, Arduino IDE പ്രോഗ്രാമിൽ, ഉദാഹരണങ്ങളിൽ Sweep തിരഞ്ഞെടുക്കുക. സെർവോ പ്രവർത്തിക്കുന്നുണ്ടെന്ന് ഉറപ്പുവരുത്തിയ ശേഷം, നമുക്ക് ബ്ലൂടൂത്ത് മൊഡ്യൂൾ ബന്ധിപ്പിക്കാം. നിങ്ങൾ ബ്ലൂടൂത്ത് മൊഡ്യൂളിൻ്റെ rx പിൻ Arduino- യുടെ tx പിൻ ലേക്ക് ബന്ധിപ്പിക്കേണ്ടതുണ്ട് എന്നാൽ ഇതുവരെ അത് ചെയ്യരുത്! ഈ കണക്ഷനുകൾ സോൾഡർ ചെയ്തുകഴിഞ്ഞാൽ, നിങ്ങൾക്ക് ആർഡ്വിനോയിലേക്ക് കോഡുകളൊന്നും അപ്‌ലോഡ് ചെയ്യാൻ കഴിയില്ല, അതിനാൽ നിങ്ങളുടെ എല്ലാ കോഡുകളും ആദ്യം ഡൗൺലോഡ് ചെയ്യുക, അതിനുശേഷം മാത്രമേ കണക്ഷനുകൾ സോൾഡർ ചെയ്യുക.

മൊഡ്യൂളും മൈക്രോകൺട്രോളറും തമ്മിലുള്ള കണക്ഷൻ ഡയഗ്രം ഇതാ:

• Rx മൊഡ്യൂൾ - Tx ബോർഡ് Arduino
• Tx മൊഡ്യൂൾ - Rx ബോർഡ്
• മൊഡ്യൂളിൻ്റെ Vcc (പോസിറ്റീവ് ടെർമിനൽ) Arduino ബോർഡിൻ്റെ 3.3v ആണ്
• ഗ്രൗണ്ട് ഗ്രൗണ്ടുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു (ഗ്രൗണ്ടിംഗ് ടു ഗ്രൗണ്ടിംഗ്)

വിശദീകരണം നിങ്ങൾക്ക് അവ്യക്തമാണെന്ന് തോന്നുന്നുവെങ്കിൽ, നൽകിയിരിക്കുന്ന വയറിംഗ് ഡയഗ്രം പിന്തുടരുക.

ഘട്ടം 4: ടെസ്റ്റ്

ഇപ്പോൾ എല്ലാ പ്രവർത്തന ഭാഗങ്ങളും ഉള്ളതിനാൽ, സെർവോയ്ക്ക് ലാച്ച് നീക്കാൻ കഴിയുമെന്ന് ഉറപ്പാക്കാം. വാതിലിലേക്ക് ലാച്ച് ഘടിപ്പിക്കുന്നതിന് മുമ്പ്, സെർവോ വേണ്ടത്ര ശക്തമാണെന്ന് ഉറപ്പാക്കാൻ ഞാൻ ഒരു ടെസ്റ്റ് സാമ്പിൾ കൂട്ടിച്ചേർക്കുന്നു. എൻ്റെ സെർവോ ദുർബലമാണെന്ന് ആദ്യം എനിക്ക് തോന്നി, ഞാൻ ലാച്ചിൽ ഒരു തുള്ളി എണ്ണ ചേർത്തു, അതിനുശേഷം അത് നന്നായി പ്രവർത്തിച്ചു. മെക്കാനിസം നന്നായി സ്ലൈഡുചെയ്യുന്നത് വളരെ പ്രധാനമാണ്, അല്ലാത്തപക്ഷം നിങ്ങളുടെ മുറിയിൽ പൂട്ടിയിടപ്പെടാൻ സാധ്യതയുണ്ട്.

ഘട്ടം 5: ഇലക്ട്രിക്കൽ ഹൗസിംഗ്

കേസിൽ കൺട്രോളറും ബ്ലൂടൂത്ത് മൊഡ്യൂളും മാത്രം ഇടാനും സെർവോ പുറത്ത് വിടാനും ഞാൻ തീരുമാനിച്ചു. ഇത് ചെയ്യുന്നതിന്, ഒരു കാർഡ്ബോർഡിൽ Arduino നാനോ ബോർഡിൻ്റെ രൂപരേഖ വരച്ച് ചുറ്റളവിന് ചുറ്റും 1 സെൻ്റിമീറ്റർ ഇടം ചേർത്ത് മുറിക്കുക. ഇതിനുശേഷം, ഞങ്ങൾ ശരീരത്തിൻ്റെ അഞ്ച് വശങ്ങൾ കൂടി മുറിച്ചുമാറ്റി. കൺട്രോളറിൻ്റെ പവർ കോർഡിനായി നിങ്ങൾ മുൻവശത്തെ ഭിത്തിയിൽ ഒരു ദ്വാരം മുറിക്കേണ്ടതുണ്ട്.

കേസ് സൈഡ് അളവുകൾ:

• താഴെ - 7.5x4 സെ.മീ
• കവർ - 7.5x4 സെ.മീ
• ഇടത് വശത്തെ മതിൽ - 7.5x4 സെ.മീ
• വലതുവശത്തെ മതിൽ - 7.5x4 സെ.മീ
• മുൻവശത്തെ മതിൽ - 4x4 സെൻ്റീമീറ്റർ (പവർ കോർഡിനായി ഒരു സ്ലോട്ടിനൊപ്പം)
• പിന്നിലെ മതിൽ - 4x4 സെ.മീ

ഘട്ടം 6: അപേക്ഷ

കൺട്രോളർ നിയന്ത്രിക്കാൻ, നിങ്ങൾക്ക് അന്തർനിർമ്മിത ബ്ലൂടൂത്ത് ഉള്ള ഒരു Android അല്ലെങ്കിൽ Windows ഗാഡ്‌ജെറ്റ് ആവശ്യമാണ്. ആപ്പിൾ ഉപകരണങ്ങളിൽ ആപ്ലിക്കേഷൻ പരീക്ഷിക്കാൻ എനിക്ക് അവസരം ലഭിച്ചില്ല;

നിങ്ങളിൽ ചിലർക്ക് ഇത് പരിശോധിക്കാൻ അവസരമുണ്ടെന്ന് എനിക്ക് ഉറപ്പുണ്ട്. ആൻഡ്രോയിഡിനായി, ബ്ലൂടൂത്ത് ടെർമിനൽ ആപ്ലിക്കേഷൻ ഡൗൺലോഡ് ചെയ്യുക, വിൻഡോസിനായി, TeraTerm ഡൗൺലോഡ് ചെയ്യുക. തുടർന്ന് നിങ്ങളുടെ സ്മാർട്ട്‌ഫോണിലേക്ക് മൊഡ്യൂൾ ബന്ധിപ്പിക്കേണ്ടതുണ്ട്, പേര് linvor ആയിരിക്കണം, പാസ്‌വേഡ് 0000 അല്ലെങ്കിൽ 1234 ആയിരിക്കണം. ജോടിയാക്കൽ സ്ഥാപിച്ചുകഴിഞ്ഞാൽ, ഇൻസ്റ്റാൾ ചെയ്ത ആപ്ലിക്കേഷൻ തുറക്കുക, ഓപ്ഷനുകളിലേക്ക് പോയി "ഒരു കണക്ഷൻ സ്ഥാപിക്കുക (സുരക്ഷിതമല്ലാത്തത്)" തിരഞ്ഞെടുക്കുക. ഇപ്പോൾ നിങ്ങളുടെ സ്മാർട്ട്ഫോൺ ഒരു Arduino സീരിയൽ ഇൻ്റർഫേസ് മോണിറ്ററാണ്, അതായത് നിങ്ങൾക്ക് കൺട്രോളറുമായി ഡാറ്റ കൈമാറ്റം ചെയ്യാം.

നിങ്ങൾ 0 നൽകിയാൽ, വാതിൽ അടയ്ക്കുകയും "ഡോർ അടച്ചിരിക്കുന്നു" എന്ന സന്ദേശം സ്മാർട്ട്ഫോൺ സ്ക്രീനിൽ പ്രത്യക്ഷപ്പെടുകയും ചെയ്യും.
നിങ്ങൾ 1 എന്ന് നൽകിയാൽ, വാതിൽ തുറക്കുന്നതും സ്ക്രീനിൽ "ഡോർ ഓപ്പൺ" എന്ന് എഴുതുന്നതും നിങ്ങൾ കാണും.
വിൻഡോസിൽ, നിങ്ങൾ TeraTerm ആപ്ലിക്കേഷൻ ഇൻസ്റ്റാൾ ചെയ്യണമെന്നതൊഴിച്ചാൽ, പ്രക്രിയ സമാനമാണ്.

ഘട്ടം 7: ലാച്ച് ഇൻസ്റ്റാൾ ചെയ്യുക

ആദ്യം നിങ്ങൾ സെർവോയെ ലാച്ചിലേക്ക് ബന്ധിപ്പിക്കേണ്ടതുണ്ട്. ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾ ഡ്രൈവ് ഭവനത്തിൻ്റെ മൗണ്ടിംഗ് ദ്വാരങ്ങളിൽ നിന്ന് പ്ലഗുകൾ മുറിച്ചു മാറ്റേണ്ടതുണ്ട്. ഞങ്ങൾ സെർവോ താഴെ വെച്ചാൽ, മൗണ്ടിംഗ് ദ്വാരങ്ങൾ ബോൾട്ടിനൊപ്പം ഫ്ലഷ് ആയിരിക്കണം. ലാച്ച് ഹാൻഡിൽ ഉണ്ടായിരുന്ന ലാച്ച് സ്ലോട്ടിൽ നിങ്ങൾ സെർവോ ലിവർ സ്ഥാപിക്കേണ്ടതുണ്ട്. ലോക്ക് ശരീരത്തിൽ എങ്ങനെ നീങ്ങുന്നുവെന്ന് പരിശോധിക്കുക. എല്ലാം ശരിയാണെങ്കിൽ, സെർവോ കൈ പശ ഉപയോഗിച്ച് സുരക്ഷിതമാക്കുക.

ഇപ്പോൾ നിങ്ങൾ വാതിലിൽ സ്ക്രൂകൾക്കായി പൈലറ്റ് ദ്വാരങ്ങൾ തുരത്തേണ്ടതുണ്ട്. ഇത് ചെയ്യുന്നതിന്, വാതിലിൽ ലാച്ച് അറ്റാച്ചുചെയ്യുക, വാതിൽ ഇലയിലെ സ്ക്രൂകൾക്കുള്ള ദ്വാരങ്ങൾ അടയാളപ്പെടുത്താൻ ഒരു പെൻസിൽ ഉപയോഗിക്കുക. അടയാളപ്പെടുത്തിയ സ്ഥലങ്ങളിൽ ഏകദേശം 2.5 സെൻ്റീമീറ്റർ ആഴത്തിൽ സ്ക്രൂകൾക്കായി ദ്വാരങ്ങൾ തുളച്ച് സ്ക്രൂകൾ ഉപയോഗിച്ച് ഉറപ്പിക്കുക. സെർവോ പ്രവർത്തനം വീണ്ടും പരിശോധിക്കുക.

ഘട്ടം 8: പവർ

ഉപകരണം പൂർത്തിയാക്കാൻ, നിങ്ങൾക്ക് ഒരു പവർ സപ്ലൈ, ഒരു ചരട്, ഒരു മിനി-യുഎസ്ബി പ്ലഗ് എന്നിവ Arduino-ലേക്ക് കണക്റ്റുചെയ്യേണ്ടതുണ്ട്.
മിനി യുഎസ്ബി പോർട്ടിൻ്റെ ഗ്രൗണ്ട് പിന്നിലേക്ക് പവർ സപ്ലൈയുടെ ഗ്രൗണ്ട് പിൻ ബന്ധിപ്പിക്കുക, ചുവന്ന വയർ മിനി യുഎസ്ബി പോർട്ടിൻ്റെ റെഡ് വയറുമായി ബന്ധിപ്പിക്കുക, തുടർന്ന് ലോക്കിൽ നിന്ന് ഡോർ ഹിഞ്ചിലേക്കും അവിടെ നിന്ന് സോക്കറ്റിലേക്കും വയർ പ്രവർത്തിപ്പിക്കുക. .

ഘട്ടം 9: കോഡ്

#സെർവോ മൈസർവോ ഉൾപ്പെടുത്തുക; int pos = 0; അന്തർ സംസ്ഥാനം; int ഫ്ലാഗ്=0; void setup() (myservo.attach(9); Serial.begin(9600); myservo.write(60); delay(1000); ) void loop() (if(Serial.available() >0) (state = Serial.read(); flag=0; // സംസ്ഥാനം "0" ആണെങ്കിൽ (സ്റ്റേറ്റ് == "0") (myservo.write(8); delay(1000); സീരിയൽ. println("ഡോർ ലോക്ക്ഡ്"); അല്ലെങ്കിൽ (സ്റ്റേറ്റ് == "1") (myservo.write(55); delay(1000); Serial.println("ഡോർ അൺലോക്ക്ഡ്"); )

ഘട്ടം 10: Arduino അടിസ്ഥാനമാക്കിയുള്ള ലോക്ക് പൂർത്തിയാക്കി

നിങ്ങളുടെ റിമോട്ട് കൺട്രോൾ ലോക്ക് ആസ്വദിക്കൂ, നിങ്ങളുടെ സുഹൃത്തുക്കളെ മുറിയിൽ "ആകസ്മികമായി" പൂട്ടാൻ മറക്കരുത്.

ഏത് ഹാർഡ്‌വെയറും പകർത്താനുള്ള മികച്ച സംവിധാനമാണ് ആർഡ്വിനോ. അവളില്ലാതെ മിക്ക ആശയങ്ങളും യാഥാർത്ഥ്യമാകില്ല. വളരെക്കാലമായി ഈ ആശയം ഉണ്ട്: Arduino- ൽ ഒരു പ്രത്യേക കോമ്പിനേഷൻ ലോക്ക് സൃഷ്ടിക്കാൻ. ഇത് തുറക്കാൻ, നിങ്ങൾ ഒരു പ്രത്യേക കീ അമർത്തിപ്പിടിക്കേണ്ടതുണ്ട്. ഈ സാഹചര്യത്തിൽ, നിങ്ങൾക്ക് ശരിയായ ബട്ടൺ അറിയാമെങ്കിലും ലോക്ക് തുറക്കാൻ പാടില്ല. ഇത് തുറക്കാൻ, മസിൽ മെമ്മറി ഉപയോഗിച്ച് നിങ്ങൾ ചില ഇടവേളകൾ നിലനിർത്തേണ്ടതുണ്ട്. ഒരു കുറ്റവാളിക്ക് അങ്ങനെ ചെയ്യാൻ കഴിയില്ല. എന്നാൽ ഇതെല്ലാം ഒരു സിദ്ധാന്തം മാത്രമാണ്.

ഇത് കൂട്ടിച്ചേർക്കാൻ നിങ്ങൾ ഒരു പ്രത്യേക ചതുരാകൃതിയിലുള്ള പൾസ് ഉപകരണവും നിരവധി കൗണ്ടറുകളും ഒരു കൂമ്പാരവും ഉപയോഗിക്കേണ്ടതുണ്ട്. എന്നാൽ പൂർത്തിയായ ഉപകരണത്തിന് മൊത്തത്തിലുള്ള വലിയ അളവുകൾ ഉണ്ടായിരിക്കും, അത് ഉപയോഗിക്കാൻ അസൗകര്യമുണ്ടാകും. ചട്ടം പോലെ, അത്തരം ചിന്തകൾ നിങ്ങളെ വേട്ടയാടുന്നു. എൻ്റെ സ്വപ്നം സാക്ഷാത്കരിക്കുന്നതിനുള്ള ആദ്യപടി Arduino-യ്‌ക്കായി ഒരു പ്രോഗ്രാം സൃഷ്‌ടിക്കുകയായിരുന്നു. ഇത് ഒരു കോമ്പിനേഷൻ ലോക്കായി പ്രവർത്തിക്കും. ഇത് തുറക്കുന്നതിന്, നിങ്ങൾ ഒരു കീ അല്ല, പലതും അമർത്തേണ്ടതുണ്ട്, ഇത് ഒരേസമയം ചെയ്യുക. പൂർത്തിയായ ഡയഗ്രം ഇതുപോലെ കാണപ്പെടുന്നു:

ചിത്രത്തിൻ്റെ ഗുണനിലവാരം മികച്ചതല്ല, പക്ഷേ കണക്ഷൻ ഗ്രൗണ്ട്, D3, D5, D7, D9, D11 എന്നിവയിലേക്കാണ് നിർമ്മിച്ചിരിക്കുന്നത്.

കോഡ് ചുവടെ:

കോൺസ്റ്റ് ഇന = 3; const int inb = 5; const int inc = 9; const int ledPin = 13; int i = 1000; ബൈറ്റ് a = 0; ബൈറ്റ് b = 0; ബൈറ്റ് c = 0; ബൈറ്റ് d = 0; ഒപ്പിടാത്ത ദീർഘകാലം = 0; //ഒരു മൂല്യം മില്ലിസ് () ഒപ്പിടാത്ത ലോംഗ് ടെമ്പ് = 0 എടുക്കുന്ന എല്ലാം മറക്കരുത്; //അൺ സൈൻ ചെയ്യാത്ത ലോംഗ് ബൈറ്റ് കീയിൽ സംഭരിക്കുക = ( 0, 0, 0, 0, 0, 0, 0, 0); //യഥാർത്ഥ കോഡുകൾ ബൈറ്റ് കീബ് = (1, 1, 1, 1, 0, 1, 0, 0); ബൈറ്റ് കീ = (1, 0, 1, 0, 1, 1, 1, 0); ബൈറ്റ് k = 0; അസാധുവായ സജ്ജീകരണം () ( പിൻ മോഡ് (ഇന, INPUT_PULLUP); //3 ഇൻപുട്ടുകൾ പിൻ മോഡ് (inb, INPUT_PULLUP); പിൻ മോഡ് (inc, INPUT_PULLUP); പിൻ മോഡ് (ledPin, OUTPUT); // 13-ന് ബിൽറ്റ്-ഇൻ LED പിൻ മോഡ് (11, OUTPUT); LED ഡിജിറ്റൽ റൈറ്റ് (ledPin, HIGH); // കോഡ് നൽകാൻ ആവശ്യപ്പെടുക) എങ്കിൽ (k == 8) (digitalWrite(ledPin, HIGH); delay(3000); k = 0 ; ) a = digitalRead(ina); //സിഗ്നൽ ലെവലുകൾ ബട്ടണുകളിൽ നിന്ന് വായിക്കുന്നു - അമർത്തി /അമർത്തിയില്ല ബി = ഡിജിറ്റൽ റീഡ്(ഇൻബി); //അടുത്തത് എങ്കിൽ - തെറ്റായ പോസിറ്റീവുകൾക്കെതിരെയുള്ള സംരക്ഷണം, നിങ്ങൾ if((digitalRead(ina) == a)&&(digitalRead(inb); ) ==b)&&(digitalRead(inc)==c)) (എങ്കിൽ (a == keya[k]) ( എങ്കിൽ (b == keyb[k]) ( if (c == keyc[k]) k++; ) ) ) എങ്കിൽ (k==1) ((d ==0) എങ്കിൽ (സമയം = മില്ലിസ് (); d++; ) ) temp = millis(); temp = temp - time; എങ്കിൽ (താപനില > 10000) ( k= 0; d=0; സമയം = മില്ലിസ് (; ) )

കോഡുമായി ബന്ധപ്പെട്ട അനാവശ്യ ചോദ്യങ്ങൾ ഒഴിവാക്കാൻ, ചില പോയിൻ്റുകൾ വ്യക്തമാക്കണം. പോർട്ടുകൾ നൽകുന്നതിന് സജ്ജീകരണ പ്രവർത്തനം ഉപയോഗിക്കുന്നു. പിൻ വോൾട്ടേജ് 5 V കൊണ്ട് വർദ്ധിപ്പിക്കാൻ ആവശ്യമായ Input_Pullup ആണ് അടുത്ത പ്രവർത്തനം. ഇത് ഒരു റെസിസ്റ്റർ ഉപയോഗിച്ചാണ് ചെയ്യുന്നത്. ഇതിന് നന്ദി, വിവിധ ഷോർട്ട് സർക്യൂട്ടുകൾ ഉണ്ടാകില്ല. കൂടുതൽ സൗകര്യത്തിനായി, ബ്ലിങ്ക്‌ട്‌വൈസ് ഫംഗ്‌ഷൻ ഉപയോഗിക്കാൻ ശുപാർശ ചെയ്യുന്നു. പൊതുവേ, വ്യത്യസ്ത പ്രോഗ്രാമുകൾ സൃഷ്ടിക്കുമ്പോൾ, നിങ്ങൾ മറ്റ് പ്രവർത്തനങ്ങൾ പരീക്ഷിക്കേണ്ടതുണ്ട്.

ഫംഗ്ഷനുകൾ നൽകിയ ശേഷം, പോർട്ടുകളിൽ നിന്ന് സിഗ്നൽ വായിക്കുന്നു. ബട്ടൺ അമർത്തിയാൽ, അത് നമ്പർ 1 കൊണ്ട് സൂചിപ്പിക്കും, ഇല്ലെങ്കിൽ, 2 കൊണ്ട് സൂചിപ്പിക്കും. അടുത്തതായി, എല്ലാ മൂല്യങ്ങളും വിശകലനം ചെയ്യുന്നു. ഉദാഹരണത്തിന്, 0,1,1 പോലുള്ള ഒരു കോമ്പിനേഷൻ പ്രത്യക്ഷപ്പെട്ടു. ഇതിനർത്ഥം ആദ്യത്തെ കീ അമർത്തി, എന്നാൽ മറ്റ് രണ്ടെണ്ണം അങ്ങനെയല്ല. എല്ലാ മൂല്യങ്ങളും ശരിയാണെങ്കിൽ, വ്യവസ്ഥ 8 ഉം ശരിയാണ്. ഫ്രണ്ട് പാനലിൽ കത്തിച്ച LED ഇത് സൂചിപ്പിക്കുന്നു. അടുത്തതായി, വാതിൽ തുറക്കാൻ ഉപയോഗിക്കുന്ന ഒരു പ്രത്യേക കോഡ് നിങ്ങൾ നൽകേണ്ടതുണ്ട്.

കൌണ്ടർ മൂല്യങ്ങൾ പുനഃസജ്ജമാക്കാൻ കോഡിൻ്റെ അവസാന ഘടകങ്ങൾ ഉപയോഗിക്കുന്നു. അവസാന കീ അമർത്തി 10 സെക്കൻഡിൽ കൂടുതൽ കഴിഞ്ഞാൽ ഈ ഫംഗ്ഷൻ നടപ്പിലാക്കുന്നു. ഈ കോഡ് ഇല്ലാതെ, സാധ്യമായ എല്ലാ ഓപ്ഷനുകളിലൂടെയും കടന്നുപോകാൻ കഴിയും, എന്നിരുന്നാലും അവയിൽ ധാരാളം ഉണ്ട്. ഈ ഉപകരണം സൃഷ്ടിച്ച ശേഷം, നിങ്ങൾ ഇത് പരിശോധിക്കേണ്ടതുണ്ട്. കൂടുതൽ

ലളിതമായ ഒരു ലോക്കിംഗ് സിസ്റ്റം സൃഷ്ടിക്കാൻ ആർഡ്വിനോയ്‌ക്കൊപ്പം ഒരു RFID റീഡർ എങ്ങനെ ഉപയോഗിക്കാമെന്നതിനെക്കുറിച്ചുള്ള ഒരു പാഠമാണ് ഇന്ന്, ലളിതമായി പറഞ്ഞാൽ - ഒരു RFID ലോക്ക്.

RFID (ഇംഗ്ലീഷ് റേഡിയോ ഫ്രീക്വൻസി ഐഡൻ്റിഫിക്കേഷൻ, റേഡിയോ ഫ്രീക്വൻസി ഐഡൻ്റിഫിക്കേഷൻ) എന്നത് ട്രാൻസ്‌പോണ്ടറുകൾ അല്ലെങ്കിൽ RFID ടാഗുകളിൽ സംഭരിച്ചിരിക്കുന്ന ഡാറ്റ റേഡിയോ സിഗ്നലുകൾ ഉപയോഗിച്ച് വായിക്കുകയോ എഴുതുകയോ ചെയ്യുന്ന വസ്തുക്കളുടെ യാന്ത്രിക തിരിച്ചറിയൽ രീതിയാണ്. ഏതൊരു RFID സിസ്റ്റത്തിലും ഒരു വായനാ ഉപകരണവും (റീഡർ, റീഡർ അല്ലെങ്കിൽ ചോദ്യം ചെയ്യുന്നയാളും) ഒരു ട്രാൻസ്‌പോണ്ടറും (RFID ടാഗ് എന്നും അറിയപ്പെടുന്നു, ചിലപ്പോൾ RFID ടാഗ് എന്ന പദം ഉപയോഗിക്കാറുണ്ട്).

ഈ ട്യൂട്ടോറിയൽ Arduino ഉള്ള ഒരു RFID ടാഗ് ഉപയോഗിക്കും. റീഡറിന് അടുത്തായി ഞങ്ങൾ സ്ഥാപിക്കുന്ന ഓരോ RFID ടാഗിൻ്റെയും തനത് ഐഡൻ്റിഫയർ (UID) ഉപകരണം വായിക്കുകയും അത് OLED ഡിസ്പ്ലേയിൽ പ്രദർശിപ്പിക്കുകയും ചെയ്യുന്നു. ടാഗിൻ്റെ യുഐഡി ആർഡ്വിനോ മെമ്മറിയിൽ സംഭരിച്ചിരിക്കുന്ന മുൻകൂട്ടി നിശ്ചയിച്ച മൂല്യത്തിന് തുല്യമാണെങ്കിൽ, ഡിസ്പ്ലേയിൽ "അൺലോക്ക് ചെയ്തു" എന്ന സന്ദേശം നമുക്ക് കാണാം. അദ്വിതീയ ഐഡി ഒരു മുൻനിശ്ചയിച്ച മൂല്യത്തിന് തുല്യമല്ലെങ്കിൽ, "അൺലോക്ക് ചെയ്ത" സന്ദേശം ദൃശ്യമാകില്ല - ചുവടെയുള്ള ഫോട്ടോ കാണുക.

കോട്ട അടച്ചിരിക്കുന്നു

പൂട്ട് തുറന്നിരിക്കുന്നു

ഈ പ്രോജക്റ്റ് സൃഷ്ടിക്കാൻ ആവശ്യമായ ഭാഗങ്ങൾ:

• RFID റീഡർ RC522
• OLED ഡിസ്പ്ലേ
• ബ്രെഡ് ബോർഡ്
• വയറുകൾ

കൂടുതൽ വിശദാംശങ്ങൾ:

• ബാറ്ററി (പവർബാങ്ക്)

പദ്ധതിയുടെ ഘടകങ്ങളുടെ ആകെ ചെലവ് ഏകദേശം $15 ആയിരുന്നു.

ഘട്ടം 2: RFID റീഡർ RC522

ഓരോ RFID ടാഗിലും ഒരു ചെറിയ ചിപ്പ് (ഫോട്ടോയിൽ കാണിച്ചിരിക്കുന്ന വെള്ള കാർഡ്) അടങ്ങിയിരിക്കുന്നു. ഈ RFID കാർഡിൽ നിങ്ങൾ ഒരു ഫ്ലാഷ്‌ലൈറ്റ് തെളിച്ചാൽ, നിങ്ങൾക്ക് ചുറ്റുമുള്ള ചെറിയ ചിപ്പും കോയിലും കാണാം. ഈ ചിപ്പിന് വൈദ്യുതി ഉൽപ്പാദിപ്പിക്കാനുള്ള ബാറ്ററി ഇല്ല. ഈ വലിയ കോയിൽ ഉപയോഗിച്ച് വയർലെസ് ആയി ഇത് വായനക്കാരിൽ നിന്ന് വൈദ്യുതി സ്വീകരിക്കുന്നു. 20 മില്ലിമീറ്റർ അകലെ നിന്ന് ഇതുപോലെ ഒരു RFID കാർഡ് വായിക്കാൻ സാധിക്കും.

RFID കീ ഫോബ് ടാഗുകളിലും ഇതേ ചിപ്പ് നിലവിലുണ്ട്.

ഓരോ RFID ടാഗിനും അത് തിരിച്ചറിയുന്ന ഒരു അദ്വിതീയ നമ്പർ ഉണ്ട്. OLED ഡിസ്പ്ലേയിൽ കാണിക്കുന്ന UID ഇതാണ്. ഈ UID ഒഴികെ, ഓരോ ടാഗിനും ഡാറ്റ സംഭരിക്കാൻ കഴിയും. ഇത്തരത്തിലുള്ള കാർഡിന് ആയിരം ഡാറ്റ വരെ സംഭരിക്കാൻ കഴിയും. ശ്രദ്ധേയമാണ്, അല്ലേ? ഈ ഫീച്ചർ ഇന്ന് ഉപയോഗിക്കില്ല. ഇന്ന്, താൽപ്പര്യമുള്ളത് ഒരു പ്രത്യേക കാർഡ് അതിൻ്റെ യുഐഡി ഉപയോഗിച്ച് തിരിച്ചറിയുക എന്നതാണ്. RFID റീഡറിൻ്റെയും ഈ രണ്ട് RFID കാർഡുകളുടെയും വില ഏകദേശം $4 ആണ്.

ഘട്ടം 3: OLED ഡിസ്പ്ലേ

പാഠം 0.96" 128x64 I2C OLED മോണിറ്റർ ഉപയോഗിക്കുന്നു.

ആർഡ്വിനോയ്‌ക്കൊപ്പം ഉപയോഗിക്കാൻ വളരെ നല്ല ഡിസ്‌പ്ലേയാണിത്. ഇതൊരു OLED ഡിസ്പ്ലേയാണ്, അതിനർത്ഥം ഇതിന് കുറഞ്ഞ വൈദ്യുതി ഉപഭോഗം ഉണ്ടെന്നാണ്. ഈ ഡിസ്പ്ലേയുടെ വൈദ്യുതി ഉപഭോഗം ഏകദേശം 10-20mA ആണ്, ഇത് പിക്സലുകളുടെ എണ്ണത്തെ ആശ്രയിച്ചിരിക്കുന്നു.

ഡിസ്‌പ്ലേയ്ക്ക് 128 ബൈ 64 പിക്സൽ റെസലൂഷൻ ഉണ്ട്, വലിപ്പം കുറവാണ്. രണ്ട് ഡിസ്പ്ലേ ഓപ്ഷനുകൾ ഉണ്ട്. അവയിലൊന്ന് മോണോക്രോം ആണ്, മറ്റൊന്ന്, പാഠത്തിൽ ഉപയോഗിച്ചിരിക്കുന്നതുപോലെ, രണ്ട് നിറങ്ങൾ പ്രദർശിപ്പിക്കാൻ കഴിയും: മഞ്ഞയും നീലയും. സ്‌ക്രീനിൻ്റെ മുകൾഭാഗം മഞ്ഞയും താഴെ നീലയും മാത്രമായിരിക്കും.

ഈ OLED ഡിസ്‌പ്ലേ വളരെ തെളിച്ചമുള്ളതും ഈ ഡിസ്‌പ്ലേയ്‌ക്കായി Adafruit വികസിപ്പിച്ചെടുത്ത മികച്ചതും മനോഹരവുമായ ഒരു ലൈബ്രറിയും ഉണ്ട്. ഇതുകൂടാതെ, ഡിസ്പ്ലേ ഒരു I2C ഇൻ്റർഫേസ് ഉപയോഗിക്കുന്നു, അതിനാൽ Arduino- ലേക്ക് ബന്ധിപ്പിക്കുന്നത് അവിശ്വസനീയമാംവിധം എളുപ്പമാണ്.

Vcc, GND എന്നിവ ഒഴികെയുള്ള രണ്ട് വയറുകൾ മാത്രമേ നിങ്ങൾ ബന്ധിപ്പിക്കേണ്ടതുള്ളൂ. നിങ്ങൾ Arduino-യിൽ പുതിയ ആളാണെങ്കിൽ നിങ്ങളുടെ പ്രോജക്റ്റിൽ വിലകുറഞ്ഞതും ലളിതവുമായ ഒരു ഡിസ്പ്ലേ ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, ഇവിടെ ആരംഭിക്കുക.

ഘട്ടം 4: എല്ലാ ഭാഗങ്ങളും ബന്ധിപ്പിക്കുന്നു

Arduino Uno ബോർഡുമായുള്ള ആശയവിനിമയം വളരെ ലളിതമാണ്. ആദ്യം, റീഡറിലേക്കും ഡിസ്പ്ലേയിലേക്കും പവർ ബന്ധിപ്പിക്കാം.

ശ്രദ്ധിക്കുക, ആർഡ്വിനോ യുനോയിൽ നിന്നുള്ള 3.3V ഔട്ട്‌പുട്ടിലേക്ക് RFID റീഡർ ബന്ധിപ്പിച്ചിരിക്കണം അല്ലെങ്കിൽ അത് കേടാകും.

ഡിസ്‌പ്ലേയ്‌ക്ക് 3.3V-യിലും പ്രവർത്തിക്കാനാകുമെന്നതിനാൽ, രണ്ട് മൊഡ്യൂളുകളിൽ നിന്നും ബ്രെഡ്‌ബോർഡിൻ്റെ പോസിറ്റീവ് റെയിലിലേക്ക് ഞങ്ങൾ വിസിസിയെ ബന്ധിപ്പിക്കുന്നു. ഈ ബസ് പിന്നീട് Arduino Uno-യിൽ നിന്നുള്ള 3.3V ഔട്ട്പുട്ടുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു. തുടർന്ന് ഞങ്ങൾ രണ്ട് ഗ്രൗണ്ടുകളും (ജിഎൻഡി) ബ്രെഡ്ബോർഡ് ഗ്രൗണ്ടിംഗ് ബസുമായി ബന്ധിപ്പിക്കുന്നു. പിന്നെ നമ്മൾ ബ്രെഡ്ബോർഡ് GND ബസിനെ Arduino GND-യുമായി ബന്ധിപ്പിക്കുന്നു.

OLED ഡിസ്പ്ലേ → Arduino

SCL → അനലോഗ് പിൻ 5

SDA → അനലോഗ് പിൻ 4

RFID റീഡർ → Arduino

RST → ഡിജിറ്റൽ പിൻ 9

IRQ → ബന്ധിപ്പിച്ചിട്ടില്ല

MISO → ഡിജിറ്റൽ പിൻ 12

മോസി → ഡിജിറ്റൽ പിൻ 11

SCK → ഡിജിറ്റൽ പിൻ 13

SDA → ഡിജിറ്റൽ പിൻ 10

ആർഡ്വിനോയുമായി ആശയവിനിമയം നടത്താൻ RFID റീഡർ മൊഡ്യൂൾ SPI ഇൻ്റർഫേസ് ഉപയോഗിക്കുന്നു. അതിനാൽ ഞങ്ങൾ Arduino UNO-യിൽ നിന്നുള്ള ഹാർഡ്‌വെയർ SPI പിന്നുകൾ ഉപയോഗിക്കാൻ പോകുന്നു.

RST പിൻ ഡിജിറ്റൽ പിൻ 9-ലേക്ക് പോകുന്നു. IRQ പിൻ വിച്ഛേദിക്കപ്പെട്ട നിലയിൽ തുടരുന്നു. MISO പിൻ ഡിജിറ്റൽ പിൻ 12-ലേക്ക് പോകുന്നു. MOSI പിൻ ഡിജിറ്റൽ പിൻ 11-ലേക്ക് പോകുന്നു. SCK പിൻ ഡിജിറ്റൽ പിൻ 13-ലേക്ക് പോകുന്നു, ഒടുവിൽ SDA പിൻ ഡിജിറ്റൽ പിൻ 10-ലേക്ക് പോകുന്നു. അത്രമാത്രം.

RFID റീഡർ ബന്ധിപ്പിച്ചിരിക്കുന്നു. ഇപ്പോൾ നമ്മൾ I2C ഇൻ്റർഫേസ് ഉപയോഗിച്ച് OLED ഡിസ്പ്ലേ Arduino ലേക്ക് ബന്ധിപ്പിക്കേണ്ടതുണ്ട്. അതിനാൽ ഡിസ്പ്ലേയിലെ SCL പിൻ പിൻ 5 ൻ്റെ അനലോഗ് പിന്നിലേക്കും ഡിസ്പ്ലേയിലെ SDA പിൻ അനലോഗ് പിൻ 4 ലേക്ക് പോകുന്നു. ഇപ്പോൾ പ്രോജക്റ്റ് ഓണാക്കി RFID കാർഡ് റീഡറിന് സമീപം വെച്ചാൽ, പ്രോജക്റ്റ് എന്ന് നമുക്ക് കാണാൻ കഴിയും. നന്നായി പ്രവർത്തിക്കുന്നു.

ഘട്ടം 5: പ്രോജക്റ്റ് കോഡ്

പ്രോജക്റ്റ് കോഡ് കംപൈൽ ചെയ്യുന്നതിന്, ഞങ്ങൾ ചില ലൈബ്രറികൾ ഉൾപ്പെടുത്തേണ്ടതുണ്ട്. ഒന്നാമതായി, ഞങ്ങൾക്ക് MFRC522 Rfid ലൈബ്രറി ആവശ്യമാണ്.

ഇത് ഇൻസ്റ്റാൾ ചെയ്യാൻ, പോകുക സ്കെച്ച് -> ലൈബ്രറികൾ ഉൾപ്പെടുത്തുക -> ലൈബ്രറികൾ നിയന്ത്രിക്കുക(ലൈബ്രറി മാനേജ്മെൻ്റ്). MFRC522 കണ്ടെത്തി ഇൻസ്റ്റാൾ ചെയ്യുക.

പ്രദർശനത്തിനായി ഞങ്ങൾക്ക് Adafruit SSD1306 ലൈബ്രറിയും Adafruit GFX ലൈബ്രറിയും ആവശ്യമാണ്.

രണ്ട് ലൈബ്രറികളും ഇൻസ്റ്റാൾ ചെയ്യുക. Adafruit SSD1306 ലൈബ്രറിക്ക് ഒരു ചെറിയ മാറ്റം ആവശ്യമാണ്. ഫോൾഡറിലേക്ക് പോകുക Arduino -> ലൈബ്രറികൾ, Adafruit SSD1306 ഫോൾഡർ തുറന്ന് ലൈബ്രറി എഡിറ്റ് ചെയ്യുക Adafruit_SSD1306.h. കമൻ്റ് ഔട്ട് ലൈൻ 70 ഉം അൺകമൻ്റ് ലൈൻ 69 ഉം കാരണം ഡിസ്പ്ലേയ്ക്ക് 128x64 റെസലൂഷൻ ഉണ്ട്.

ആദ്യം നമ്മൾ ആർഡ്വിനോ തിരിച്ചറിയേണ്ട RFID ടാഗിൻ്റെ മൂല്യം പ്രഖ്യാപിക്കുന്നു. ഇത് പൂർണ്ണസംഖ്യകളുടെ ഒരു നിരയാണ്:

Int കോഡ് = (69,141,8,136); // യുഐഡി

തുടർന്ന് ഞങ്ങൾ RFID റീഡർ സമാരംഭിക്കുകയും പ്രദർശിപ്പിക്കുകയും ചെയ്യുന്നു:

Rfid.PCD_Init(); display.begin(SSD1306_SWITCHCAPVCC, 0x3C);

അതിനുശേഷം, ലൂപ്പ് ഫംഗ്ഷനിൽ ഞങ്ങൾ റീഡറിലെ ടാഗ് ഓരോ 100 എംഎസിലും പരിശോധിക്കുന്നു.

റീഡറിൽ ഒരു ടാഗ് ഉണ്ടെങ്കിൽ, ഞങ്ങൾ അതിൻ്റെ യുഐഡി വായിച്ച് ഡിസ്പ്ലേയിൽ പ്രിൻ്റ് ചെയ്യുന്നു. തുടർന്ന് നമ്മൾ ഇപ്പോൾ വായിച്ച ടാഗിൻ്റെ യുഐഡിയെ കോഡ് വേരിയബിളിൽ സംഭരിച്ചിരിക്കുന്ന മൂല്യവുമായി താരതമ്യം ചെയ്യുന്നു. മൂല്യങ്ങൾ സമാനമാണെങ്കിൽ, ഞങ്ങൾ അൺലോക്ക് സന്ദേശം പ്രദർശിപ്പിക്കും, അല്ലാത്തപക്ഷം ഞങ്ങൾ ഈ സന്ദേശം പ്രദർശിപ്പിക്കില്ല.

If(match) ( Serial.println("\nഎനിക്ക് ഈ കാർഡ് അറിയാം!"); printUnlockMessage(); )else ( Serial.println("\nഅജ്ഞാത കാർഡ്"); )

തീർച്ചയായും, 1 യുഐഡി മൂല്യത്തിൽ കൂടുതൽ സംഭരിക്കാൻ നിങ്ങൾക്ക് ഈ കോഡ് മാറ്റാൻ കഴിയും, അതുവഴി പ്രോജക്റ്റ് കൂടുതൽ RFID ടാഗുകൾ തിരിച്ചറിയും. ഇതൊരു ഉദാഹരണം മാത്രം.

പ്രോജക്റ്റ് കോഡ്:

#ഉൾപ്പെടുന്നു #ഉൾപ്പെടുന്നു #ഉൾപ്പെടുന്നു #ഉൾപ്പെടുന്നു #നിർവചിക്കുക OLED_RESET 4 Adafruit_SSD1306 ഡിസ്പ്ലേ(OLED_RESET); #SS_PIN 10 നിർവചിക്കുക #RST_PIN 9 MFRC522 rfid (SS_PIN, RST_PIN); // ക്ലാസിൻ്റെ ഉദാഹരണം MFRC522 ::MIFARE_Key കീ; int കോഡ് = (69,141,8,136); //ഇത് സംഭരിച്ചിരിക്കുന്ന UID int codeRead = 0; സ്ട്രിംഗ് uidString; void setup() (Serial.begin(9600); SPI.begin(); // Init SPI ബസ് rfid.PCD_Init(); // Init MFRC522 display.begin(SSD1306_SWITCHCAPVCC, 0x3C); // I2C addr 0x3D ഉപയോഗിച്ച് സമാരംഭിക്കുക (128x64) // ഡിസ്പ്ലേ.clearDisplay() മായ്ക്കുക; display.setTextSize(2); display.setCursor(10,0); display.print("RFID ലോക്ക്"); display.display(); ) void loop() ( if(rfid.PICC_IsNewCardPresent()) ( readRFID(); ) താമസം(100); ) അസാധുവായ readRFID() ( rfid.PICC_ReadCardSerial(); Serial.print(F("\nPICC തരം: ") ); MFRC522::PICC_TYPE_MIFARE_4K) ( സീരിയൽ .println("നിങ്ങളുടെ ടാഗ് MIFARE ക്ലാസിക്കല്ല") uidString = String(rfid.uid.uidByte)+" "+String(rfid.uid.uidByte)+" "+ String(rfid.uid.uidByte)+ " "+String(rfid.uid.uidByte); ബൂളിയൻ പൊരുത്തം = true;

ഘട്ടം 6: അന്തിമ ഫലം

പാഠത്തിൽ നിന്ന് നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, കുറച്ച് പണത്തിന് നിങ്ങളുടെ പ്രോജക്റ്റുകളിലേക്ക് ഒരു RFID റീഡർ ചേർക്കാം. ഈ റീഡർ ഉപയോഗിച്ച് നിങ്ങൾക്ക് എളുപ്പത്തിൽ ഒരു സുരക്ഷാ സംവിധാനം സൃഷ്ടിക്കാം അല്ലെങ്കിൽ കൂടുതൽ രസകരമായ പ്രോജക്റ്റുകൾ സൃഷ്ടിക്കാം, ഉദാഹരണത്തിന്, ഒരു USB ഡ്രൈവിൽ നിന്നുള്ള ഡാറ്റ അൺലോക്ക് ചെയ്തതിനുശേഷം മാത്രമേ വായിക്കൂ.