गुप्त डिब्बे के साथ चेहरे की पहचान दर्पण: 15 कदम (चित्रों के साथ)

2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-30 09:19

मैं हमेशा कहानियों, फिल्मों और इसी तरह के अन्य रचनात्मक गुप्त डिब्बों से आकर्षित होता रहा हूँ। इसलिए, जब मैंने सीक्रेट कम्पार्टमेंट प्रतियोगिता देखी तो मैंने खुद इस विचार के साथ प्रयोग करने और एक साधारण दिखने वाला दर्पण बनाने का फैसला किया, जो एक गुप्त साइड ड्रॉअर खोलता है जब सही व्यक्ति इसे देखता है।

रास्पबेरी पाई का उपयोग करके, अजगर प्रोग्रामिंग का कुछ ज्ञान, और 8 वीं कक्षा की दुकान वर्ग, हम वस्तुओं को सादे दृष्टि में छिपाने के लिए इस स्पिफी डिवाइस को बना सकते हैं, जिसकी पहुंच केवल सही उपयोगकर्ता के पास होगी।

मैं इन लोगों/मंचों को विशेष रूप से धन्यवाद देना चाहता हूं, जहां से मुझे मेरी जानकारी और संसाधन भी मिले:

टीसीओएड - यूट्यूब चैनल

PiMyLifeUp से एम्मेट

Hackster.io पर MJRoBot (प्रोफाइल)

गेवेन मैकडोनाल्ड - यूट्यूब चैनल

थिंगविवर्स पर टकर शैनन (प्रोफाइल)

आपूर्ति

फ्रेम आपूर्ति:

• लकड़ी का तख़्त (इस बोर्ड का आयाम ४२" गुणा ७.५" गुणा ५/१६ था)
• पेंसिल पिक्चर फ्रेम (ग्लास के साथ)
• स्प्रे पेंट
• एक तरह से चिंतनशील चिपकने वाला
• ग्लास क्लीनर और राग
• एमडीएफ वुड

चेहरे की पहचान की आपूर्ति:

• रास्पबेरी पाई (मैंने पाई 3 बी+ का उपयोग किया है लेकिन अन्य विकल्प भी हैं)
• कैमरा मॉड्यूल
• स्टेपर मोटर

उपकरण:

• आरा
• जिग सॉ
• सैंडपेपरवुड
• गोंद टेप
• उपाय
• कैंची
• स्प्रे बॉटल
• थ्री डी प्रिण्टर
• सुपर गोंद

चरण 1: बॉक्स फ्रेम के लिए कट्स

मैंने सेकेंड-हैंड स्टोर से एक पिक्चर फ्रेम खरीदा। बस एक चेतावनी, सुनिश्चित करें कि फ्रेम बनाने वाले तख्त कम से कम 1 1/2 चौड़े हैं। ऐसा इसलिए है कि आप लकड़ी के अन्य बोर्डों को काम करने के लिए पर्याप्त जगह के साथ गोंद कर सकते हैं। साथ ही, सुनिश्चित करें कि ग्लास अंदर है फ्रेम पूरी तरह से स्पष्ट है। मैंने दुर्घटना से एक पाले सेओढ़ लिया और फिर सिर्फ स्पष्ट कांच के लिए एक और फ्रेम खरीदना पड़ा। क्योंकि मेरे फ्रेम का उपयोग किया जाता है, बॉक्स फ्रेम के लिए माप भिन्न हो सकते हैं।

• फ़्रेम को पोर्ट्रेट ओरिएंटेशन में रखें। फ्रेम पर ग्लास होल साइड के लंबे पक्षों (LS) को ऊपर और नीचे दोनों तरफ अतिरिक्त ½”के साथ मापें। (यानी कांच के छेद के माप के लंबे हिस्से में एक इंच जोड़ें। इसे रिकॉर्ड करें और एलएसएम (लॉन्ग साइड मेजरमेंट) को लेबल करें।
• इसी तरह, छेद के ऊपरी हिस्से को मापें और अतिरिक्त 1” जोड़ें। इसे रिकॉर्ड करें और SSM (शॉर्ट साइड मेजरमेंट) को लेबल करें।
• अपना बोर्ड प्राप्त करें और एक टेबल आरी के साथ, दो LSM x 2”और दो SSM x 2” काटें।
• LSM कट्स में से एक लें और एक 2"x1" आयत को मापें जो नीचे से 1" और बाएँ और दाएँ पक्ष से ½" हो (जैसा कि चित्र 3 में दिखाया गया है)।
• छेद को काटने के लिए एक आरा का प्रयोग करें। फिर किनारों को रेत करने के लिए सैंडपेपर का उपयोग करें।

चरण 2: दराज के लिए कटौती

अब हम दराज (उर्फ सीक्रेट कम्पार्टमेंट) बनाना शुरू करेंगे।

• दो 4"x 1" पक्षों को काटें, एक 3 "x 1" (पिछला किनारा), एक 4 ¼ "x 1 " (सामने का किनारा), और एक 4" x 3 ⅜" (प्लेटफ़ॉर्म)।
• प्लेटफॉर्म के 4" साइड के साथ पहले 4" x 1" साइड को ग्लू करें। मैंने प्लेटफ़ॉर्म की तरफ मुड़े हुए एक जोड़े को कागज़ के नीचे रख दिया ताकि इसे थोड़ा उठा लिया जाए, इस तरह यह उस छेद पर नहीं खींचेगा जिसे मैंने LS प्लांक में काटा था। 30 मिनट के लिए सूखने के लिए सेट करें।
• इसी तरह, प्लेटफॉर्म के 3 " किनारे के साथ 3 "x 1" को गोंद दें। 30 मिनट के लिए सूखने के लिए सेट करें। फिर पहले के विपरीत दिशा में दूसरे 4”x 1” पक्ष को गोंद दें। 30 मिनट के लिए सूखने के लिए सेट करें।
• अभी के लिए सामने के किनारे को अलग रख दें। यह दराज पर चिपकी आखिरी चीज होगी।
• समाप्त होने पर, यह देखने के लिए जांचें कि क्या यह उस छेद में फिट बैठता है जिसे आपने एलएसएम तख़्त में लगाया था। यदि नहीं, तो छेद को तब तक रेत दें जब तक कि दराज आसानी से अंदर और बाहर न आ जाए, और कोई खिंचाव न हो।

चरण 3: फ़्रेम को एक साथ रखना

सभी भागों के पूरा होने के साथ हम पूरे फ्रेम को इकट्ठा करना शुरू कर सकते हैं।

• प्रत्येक तरफ ½”के साथ कांच के छेद के साथ केंद्रित एलएसएम तख़्त को गोंद करें। सुनिश्चित करें कि यह छेद से ½” दूर चिपका हुआ है (जैसा कि चित्र 1 में दिखाया गया है)। 30 मिनट के लिए सूखने के लिए सेट करें।
• पहले एसएसएम प्लैंक को एलएसएम प्लैंक के अंदर के किनारे को छूते हुए चिपकाएं जो अभी चिपका हुआ था। (यह सुनिश्चित करने के लिए एक शासक का उपयोग करें कि यह सीधे पर चिपका हुआ है)। 30 मिनट के लिए सूखने के लिए सेट करें।
• दूसरे एलएसएम पक्ष को लें और पहले वाले के समान गोंद करें। सुनिश्चित करें कि यह छेद से ½”दूर है और एसएसएम जो अभी जुड़ा हुआ था वह तख़्त के अंदर से चिपका हुआ है। 30 मिनट के लिए सूखने के लिए सेट करें।
• अंतिम एसएसएम को शीर्ष किनारे पर गोंद करें। चूंकि आपके पास दोनों तरफ दो एलएसएम हैं, इस पर निर्भर करते हुए कि आपने उन्हें कितना सीधा जोड़ा है, आपको यह सुनिश्चित करने के लिए एसएसएम के किनारों को रेत करना पड़ सकता है कि यह फिट बैठता है (मेरी कटिंग कभी-कभी बंद होती है)। 30 मिनट के लिए सूखने के लिए सेट करें।
• दराज के नीचे और फ्रेम के बीच की छोटी जगह को मापें। इस माप के साथ एमडीएफ की लकड़ी के एक टुकड़े को 4 से काटें।
• जब सब कुछ हो गया, तो मैंने फ्रेम को स्प्रे किया ताकि सभी टुकड़े मेल खा सकें।

चरण 4: दर्पण के लिए

अमेज़ॅन से मैंने जो एकतरफा फिल्म एडहेसिव खरीदा, वह लगभग $ 10 था। यदि आप रुचि रखते हैं तो बेहतर गुणवत्ता वाले हैं जो थोड़े अधिक महंगे हैं। मैं जो उपयोग करता हूं वह प्रतिबिंबित करता है लेकिन आप बता सकते हैं कि यह एक नियमित दर्पण नहीं है जिसे आप घर में देखते हैं। जितने महंगे होंगे वो लुक आपको मिलेगा।

• ग्लास को दोनों तरफ से ग्लास क्लीनर से साफ करें।
• वन-वे एडहेसिव को अनियंत्रित करें और गिलास को ऊपर रखें। चिपकने वाला काट लें ताकि कांच के प्रत्येक तरफ कम से कम ½”अतिरिक्त हो।
• गिलास को एक तरफ रख दें और उसके एक किनारे को पानी से गीला कर लें। फिर प्लास्टिक कोट को वन-वे एडहेसिव से छीलें और नए खुले हिस्से को पानी से स्प्रे करें।
• कांच के गीले हिस्से को चिपकने वाले के गीले हिस्से पर रखें। 30 मिनट बैठने दें।
• चिपकने वाला और कांच के बीच किसी भी बुलबुले को फ़्लैट करने के लिए अपने अंगूठे का उपयोग करें और फ़्लिप करें। फिर किनारों के चारों ओर से अतिरिक्त चिपकने वाला काट लें।

चरण 5: रास्पियन खिंचाव स्थापित करें

यह मेरा पहली बार रास्पबेरी पाई के वातावरण में तल्लीन होने के कारण मैंने ओएस को स्थापित करने के तरीके के बारे में निर्देशों की तलाश शुरू की। मुझे अंततः TeCoEd द्वारा Youtube पर एक सीधा ट्यूटोरियल मिला जो SD कार्ड पर स्ट्रेच स्थापित करने की प्रक्रिया से गुजरा (बल्कि एक सुंदर परिचय के साथ)। यहाँ उस ट्यूटोरियल का लिंक दिया गया है:

संक्षेप में, आपको बस इतना करना है:

• अपने ड्राइव >> ड्राइव टूल्स >> फॉर्मेट का चयन करके एसडी कार्ड को फॉर्मेट करें। रास्पियन खिंचाव के लिए ज़िप फ़ाइल डाउनलोड करें (यहां पाया गया:
• ओएस छवि को एसडी कार्ड में फ्लैश करें। इसे पूरा करने के लिए TeCoEd ने Win32 डिस्क इमेजर का इस्तेमाल किया। मैंने balenaEtcher स्थापित करना समाप्त कर दिया जो थोड़ा और सीधा लग रहा था। (यहाँ balenaEtcher के लिए डाउनलोड लिंक है:
• एक बार balenaEtcher में "फ़ाइल से फ्लैश" चुनें और पहले से डाउनलोड की गई ज़िप फ़ाइल चुनें। इसके बाद, वांछित एसडी कार्ड का चयन करें (यदि स्वचालित रूप से चयनित नहीं है)। फिर रसदार फ्लैश बटन दबाएं और जादू होने की प्रतीक्षा करें।

एक बार एसडी कार्ड पर स्थापित होने के बाद आप इसे रास्पबेरी पाई में डाल सकते हैं और सामान्य पाई सेटअप प्रक्रिया से गुजर सकते हैं।

चरण 6: ओपनसीवी स्थापित करें

अब अधिक चेहरे-पहचान-उन्मुख भागों पर। चेहरों को पहचानने के लिए, हमें ओपनसीवी पुस्तकालय डाउनलोड करना होगा जिसमें कंप्यूटर दृष्टि के साथ काम करने के लिए बड़ी संख्या में टूल शामिल हैं।

ओपनसीवी स्थापित करना मेरे लिए सॉफ्टवेयर पहलू का सबसे कठिन हिस्सा था। लेकिन कई निर्देशों का पालन करने के बाद मुझे अंततः PiMyLifeUp से एम्मेट का एक ट्यूटोरियल मिला जिसने यहाँ पाया गया ट्रिक किया:

मैं इन चरणों के माध्यम से नहीं चलूंगा क्योंकि आप लिंक से उनका अनुसरण करना बेहतर समझेंगे (दिए गए स्पष्टीकरण और साइट से सीधे कॉपी और पेस्ट करने की क्षमता के साथ)।

चरण 7: कैमरा सक्षम / परीक्षण करें

OpenCV को स्थापित करने के बाद मेरी बाकी यात्रा MJRoBot द्वारा Hackster.io पर एक ट्यूटोरियल का उपयोग करके पूरी की गई:

इससे पहले कि हम शुरू करें, मैं आपको याद दिलाना चाहूंगा कि मैं इन लिपियों का मूल निर्माता नहीं हूं, लेकिन अंत में उनके कुछ हिस्सों को संशोधित किया है।

शुरू करने के लिए हमें यह सुनिश्चित करने के लिए कैमरे का परीक्षण करना चाहिए कि हम स्क्रीन पर वीडियो कैप्चर कर सकते हैं। मैंने MJRoBot के चरण 3 में प्रदान की गई स्क्रिप्ट को चलाने का प्रयास करते हुए लगभग एक घंटा बिताया। जैसा कि जीवन होगा, हमें वास्तव में रास्पबेरी पाई पर कैमरे को सक्षम करने की आवश्यकता है (यह पता चला है कि प्रदान किए गए निर्देशों को पढ़ना एक अच्छा विचार हो सकता है … मिमी नाह)। तो कैमरे को उसके सही पोर्ट से जोड़ने के बाद इन चरणों का पालन करें:

• एक कमांड टर्मिनल खोलें और टाइप करें sudo raspi-config
• "कैमरा सक्षम करें" चुनें (यह डिवाइस विकल्प के अंतर्गत पाया जा सकता है)
• "एंटर" मारो
• "समाप्त करें" पर जाएं और आपको रिबूट करने के लिए प्रेरित किया जाएगा

फिर इन चरणों का पालन करें:

• रास्पबेरी के मुख्य मेनू पर जाएं (ऊपर बाएं)
• पसंद
• रास्पबेरी पाई विन्यास
• इंटरफेस
• फिर कैमरा में, "सक्षम" चुनें
• फिर ठिक है"

अब आप कैमरे का परीक्षण करने के लिए MJRoBot के ट्यूटोरियल से इस स्क्रिप्ट को सफलतापूर्वक चलाने में सक्षम होना चाहिए (याद रखें कि यह सभी कोड और अधिक गहन विवरण MJRobot के ट्यूटोरियल के ऊपर दिए गए लिंक में पाया जाता है):

np. के रूप में numpy आयात करें

आयात cv2 cap = cv2. VideoCapture(0) cap.set(3, 640) # set Width cap.set(4, 480) # set ऊंचाई जबकि(True): ret, फ्रेम = cap.read() फ्रेम = cv2. फ्लिप (फ्रेम, -1) # फ्लिप कैमरा लंबवत ग्रे = cv2.cvtColor (फ्रेम, cv2. COLOR_BGR2GRAY) cv2.imshow ('फ्रेम', फ्रेम) cv2.imshow ('ग्रे', ग्रे) k = cv2.waitKey(30) और 0xff अगर k == 27: # ब्रेक कैप छोड़ने के लिए 'ESC' दबाएं। रिलीज () cv2.destroyAllWindows ()

पिछले कोड को दो विंडो प्रदर्शित करनी चाहिए, एक रंग में और दूसरी ग्रेस्केल में। यदि आपने इसे इतनी दूर बनाया है तो मुझे लगता है कि आप एक अच्छे सैंडविच के लायक हैं।

चरण 8: डेटा और प्रशिक्षण डेटा एकत्र करना

प्रदान किए गए ट्यूटोरियल में लेखक जल्द ही प्रदान किए जाने वाले कोड की प्रक्रियाओं के बारे में और अधिक गहराई में जाता है, लेकिन चूंकि ये निर्देश हैं कि यह दर्पण कैसे बनाया गया था, इसलिए मैं इतिहास और न ही जटिल यांत्रिकी पर गहराई से नहीं जाऊंगा। हालाँकि मैं आपको अपने जीवन का एक महीना इन दो चीजों के बारे में पढ़ने की सलाह देता हूँ क्योंकि ये आपके दिमाग की अच्छी तरह से सेवा कर सकते हैं।

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

एक कमांड लाइन खोलें और इसे कुछ मजेदार नाम देने वाली एक नई निर्देशिका बनाएं (मैंने अपना फेसरेक कहा)

एमकेडीआईआर फेसरेक

अब, निर्देशिका को FaceRec में बदलें और इसे डेटासेट नाम देना सुनिश्चित करते हुए एक उपनिर्देशिका बनाएं।

सीडी फेसआरईसी

एमकेडीआईआर डेटासेट

जब हम इसमें होते हैं, तो हम ट्रेनर नामक दूसरी उपनिर्देशिका भी बना सकते हैं।

एमकेडीआईआर ट्रेनर

अब आप पहली स्क्रिप्ट के निर्देशों को चला सकते हैं और उनका पालन कर सकते हैं जो उपयोगकर्ता के चित्रों को कैप्चर करेगा। (बस एक ध्यान दें, उपयोगकर्ता आईडी को 1, 2, 3 आदि के रूप में दर्ज करना सुनिश्चित करें)

आयात cv2import os cam = cv2. VideoCapture(0) cam.set(3, 640) # वीडियो चौड़ाई सेट करें cam.set(4, 480) # वीडियो ऊंचाई सेट करें face_detector = cv2. CascadeClassifier('haarcascade_frontalface_default.xml') # प्रत्येक के लिए व्यक्ति, एक संख्यात्मक चेहरा आईडी दर्ज करें face_id = इनपुट ('\ n उपयोगकर्ता आईडी दर्ज करें अंत प्रेस ==> ') प्रिंट ("\ n [सूचना] चेहरा कैप्चर शुरू करना। कैमरा देखें और प्रतीक्षा करें …") # व्यक्तिगत नमूना चेहरे की गिनती शुरू करें गिनती = 0 जबकि (ट्रू): रिट, आईएमजी = कैम.रीड () img = cv2.flip (img, -1) # फ्लिप वीडियो छवि लंबवत ग्रे = cv2.cvtColor (img, cv2. COLOR_BGR2GRAY) चेहरे = face_detector.detectMultiScale (ग्रे, 1.3, 5) (x, y, w, h) के लिए फलकों में: cv2.rectangle(img, (x, y), (x+w, y+h), (255, 0, 0), 2) गिनती += 1 # कैप्चर की गई छवि को डेटासेट फ़ोल्डर cv2.imwrite("dataset/User." + str(face_id) + '.' + str(count) + ".jpg", ग्रे[y:y] में सेव करें +h, x:x+w]) cv2.imshow('image', img) k = cv2.waitKey(100) & 0xff # वीडियो से बाहर निकलने के लिए 'ESC' दबाएं अगर k == 27: ब्रेक एलिफ काउंट>= 30: # 30 चेहरे का नमूना लें और वीडियो ब्रेक बंद करें k प्रिंट ("\ n [सूचना] कार्यक्रम और सफाई सामग्री से बाहर निकलना") cam.release () cv2.destroyAllWindows ()

इस बिंदु पर सुनिश्चित करें कि आपने पाई पर तकिया स्थापित किया है। यदि नहीं, तो कमांड चलाएँ:

पिप स्थापित तकिया

उसके पूरा होने के बाद आप प्रशिक्षण स्क्रिप्ट (दूसरी स्क्रिप्ट) चला सकते हैं जो आपको एक.yaml फ़ाइल प्रदान करेगी जिसका उपयोग अंतिम स्क्रिप्ट में किया जाएगा।

पीआईएल आयात से एनपी के रूप में आयात cv2import numpy छवि आयात ओएस # चेहरा छवि डेटाबेस पथ के लिए पथ = 'डेटासेट' पहचानकर्ता = cv2.face। LBPHFaceRecognizer_create() डिटेक्टर = cv2. CascadeClassifier ("haarcascade_frontalface_default.xml"); # छवियों और लेबल डेटा प्राप्त करने के लिए फ़ंक्शन getImagesAndLabels (पथ): imagePaths = [os.path.join(path, f) f के लिए os.listdir(path)] faceSamples= ids = imagePath में imagePath के लिए: PIL_img = Image.open(imagePath).convert('L') # इसे ग्रेस्केल में बदलें img_numpy = np.array(PIL_img, 'uint8') id = int(os.path.split(imagePath)[-1]. स्प्लिट ("।") [1]) चेहरे = डिटेक्टर। मल्टीस्केल (img_numpy) के लिए (x, y, w, h) चेहरों में: faceSamples.append(img_numpy[y:y+h, x:x+w]) ids.append(id) रिटर्न फेसनमूने, आईडी प्रिंट ("\ n [सूचना] प्रशिक्षण चेहरे। इसमें कुछ सेकंड लगेंगे। प्रतीक्षा करें …") चेहरे, आईडी = getImagesAndLabels (पथ) पहचानकर्ता। ट्रेन (चेहरे, np.array(आईडी)) # मॉडल को प्रशिक्षक/ट्रेनर में सहेजें। ("\n [जानकारी] {0} प्रशिक्षित चेहरे। प्रोग्राम से बाहर निकल रहे हैं।format(len(np.unique(ids))))

स्क्रिप्ट के इस सेट के बारे में क्या अच्छा है कि सिस्टम में कई चेहरे दर्ज किए जा सकते हैं, जिसका अर्थ है कि यदि वांछित है तो कई व्यक्ति दर्पण के अंदरूनी हिस्से तक पहुंच सकते हैं।

नीचे मेरे पास डेटा कैप्चर स्क्रिप्ट और प्रशिक्षण स्क्रिप्ट डाउनलोड के लिए उपलब्ध है।

चरण 9: चेहरे की पहचान का समय

अंत में, हम पहचानकर्ता स्क्रिप्ट चला सकते हैं। मोटर प्रक्रिया को कार्यात्मक बनाने के लिए इस स्क्रिप्ट में और कोड जोड़ा गया था, इसलिए मैं उन हिस्सों को थोड़ा और अच्छी तरह से समझाऊंगा। मैं इसे खंडों में तोड़ दूंगा लेकिन अगर आप ऐसा कर रहे हैं तो मैं पूरी स्क्रिप्ट को चरण के अंत में रखूंगा।

हम उन सभी मॉड्यूलों को आयात करके शुरू करेंगे जिनकी हमें आवश्यकता होगी और फिर GPIO मोड को GPIO. BCM पर सेट करें

np. के रूप में numpy आयात करें

GPIO GPIO.setwarnings (गलत) GPIO.setmode (GPIO. BCM) के रूप में आयात समय आयात RPi. GPIO आयात करें

कंट्रोलपिन नाम की यह अगली सूची संख्याओं की एक सरणी है जो आउटपुट पिन का प्रतिनिधित्व करती है जिसका उपयोग हमारे स्टेपर मोटर के लिए किया जाएगा।

कंट्रोलपिन = [१४, १५, १८, २३]

फॉर-लूप इन पिनों को आउटपुट के रूप में सेट करता है और फिर सुनिश्चित करता है कि वे बंद हैं। मेरे पास अभी भी कुछ कोड है जो दराज को एक बटन के धक्का से बंद करने देता है लेकिन मैंने इसके बजाय टाइमर का उपयोग करने का निर्णय लिया।

GPIO.setup(ControlPin, GPIO. OUT)

GPIO.output(ControlPin, 0) GPIO.setup(2, GPIO. IN, pull_up_down=GPIO. PUD_DOWN)

अगले दो चर अनुक्रम हैं जिनका उपयोग हम मोटर चलाने के लिए करेंगे। मैंने यह जानकारी गेवेन मैकडोनाल्ड के एक अद्भुत वीडियो से सीखी है जिसे मैं देखने की अत्यधिक अनुशंसा करता हूं क्योंकि वह न केवल कोड बल्कि वास्तविक मोटर पर गहराई से जाता है (यहां पाया गया: https://www.youtube.com/embed/Dc16mKFA7Fo). संक्षेप में, प्रत्येक अनुक्रम को आगामी ओपनकॉम्प और क्लोज़कॉम्प फ़ंक्शंस में नेस्टेड फॉर-लूप का उपयोग करके पुनरावृत्त किया जाएगा। यदि आप बारीकी से देखें तो seq2 seq1 के बिल्कुल विपरीत है। हाँ, आपने अनुमान लगाया। एक मोटर को आगे बढ़ाने के लिए है और दूसरा रिवर्स के लिए।

seq1 =

seq2 =

अपने ओपनकॉम्प फ़ंक्शन से शुरू करके हम एक फॉर-लूप बनाते हैं जो 1024 बार पुनरावृति करेगा। मैकडॉनल्ड्स के वीडियो के अनुसार 512 पुनरावृत्तियों से मोटर का पूर्ण रोटेशन होगा और मैंने पाया कि लगभग दो घुमाव एक अच्छी लंबाई थी लेकिन इसे किसी व्यक्ति के आकार के आधार पर समायोजित किया जा सकता है। seq1 और seq2 में पाए गए 8 सरणियों को ध्यान में रखते हुए अगले फॉर-लूप में 8 पुनरावृत्तियों का समावेश है। और अंत में, अंतिम फॉर-लूप चार वस्तुओं के लिए चार बार पुनरावृति करता है जो इनमें से प्रत्येक सरणियों में पाए जाते हैं और साथ ही साथ 4 GPIO पिन जिनसे हमारी मोटर जुड़ी हुई है। यहां नीचे की रेखा GPIO पिन का चयन करती है और फिर इसे चालू या बंद कर देती है, जिसके आधार पर यह चालू है। लाइन के बाद कुछ बफर समय प्रदान करता है ताकि हमारी मोटर बिल्कुल भी न घूमे। दराज को बाहर निकालने के लिए मोटर घूमने के बाद आगे बढ़ने से पहले 5 सेकंड के लिए सोती है। इस समय को यहां समायोजित किया जा सकता है या आप टिप्पणी किए गए कोड को सक्षम कर सकते हैं जो टाइमर के बजाय स्क्रिप्ट के साथ पुश-बटन के उपयोग की अनुमति देता है।

मेरे लिए रेंज में (1024):

हाफस्टेप इन रेंज(8) के लिए: पिन इन रेंज(4) के लिए: GPIO.output(ControlPin[pin], seq1[halfstep] [pin]) time.sleep(.001) ''जबकि ट्रू: if GPIO.input (2) == GPIO. LOW: ब्रेक; '''' टाइम.स्लीप(5)

क्लोजकॉम्प फ़ंक्शन एक समान तरीके से काम करता है। मोटर के वापस चले जाने के बाद मैं यह सुनिश्चित करने के लिए अपने अंतिम GPIO पिन को कम करने के लिए आगे बढ़ता हूं कि हम कोई ऊर्जा बर्बाद नहीं कर रहे हैं और फिर मैं आगे बढ़ने से पहले तीन और सेकंड का समय जोड़ता हूं।

मेरे लिए रेंज में (1024):

रेंज में हाफस्टेप के लिए(8): पिन इन रेंज(4) के लिए: GPIO.output(ControlPin[pin], seq2[halfstep] [pin]) time.sleep(.001) प्रिंट ("कम्पार्टमेंट क्लोज्ड") GPIO.output (कंट्रोलपिन [0], 0) जीपीआईओ। आउटपुट (कंट्रोलपिन [3], 0) समय। नींद (3)

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

सबसे पहले मैंने सूची के नाम बदले ताकि मेरा नाम उस इंडेक्स में हो जिसे मैंने डेटा एकत्र करते समय इसे सौंपा था (मेरे मामले में 1)। और फिर मैंने शेष मानों को किसी के लिए भी सेट नहीं किया क्योंकि मेरे पास डेटासेट में कोई और चेहरा नहीं था।

नाम = ['कोई नहीं', 'डैनियल', 'कोई नहीं', 'कोई नहीं', 'कोई नहीं', 'कोई नहीं']

कोड की हमारी अंतिम कुछ पंक्तियाँ thic for-loop में क्रियान्वित की गई हैं। वैरिएबल कॉन्फिडेंस को स्ट्रिंग में बदलने से पहले मैंने कॉन्फिडेंस को इंटीजर (इंट कॉन्फिडेंस) के रूप में स्टोर करने के लिए एक वेरिएबल बनाया। फिर मैं एक if-statement का उपयोग यह जांचने के लिए करता हूं कि क्या विश्वास 30 से अधिक है और यदि आईडी (कंप्यूटर किस व्यक्ति का पता लगा रहा है, इस मामले में, "डैनियल") मेरे नाम के बराबर है।इसकी पुष्टि के बाद फ़ंक्शन openComp को कहा जाता है जो (जैसा कि पहले बताया गया है) मोटर को स्थानांतरित करता है, 5 सेकंड के बाद बाहर निकलता है, और फिर बंद करने के लिए आगे बढ़ता है जो मोटर को विपरीत दिशा में ले जाता है और thic लूप के साथ आगे बढ़ने से पहले कुछ सफाई करता है।

अगर intConfidence> 30 और आईडी == 'डैनियल':

ओपनकॉम्प () क्लोजकॉम्प ()

एक बग जो मुझे यहां मिला, वह यह है कि कभी-कभी क्लोजकॉम्प रिटर्न के बाद, कोड जारी रहता है, लेकिन सशर्त अगर-स्टेटमेंट फिर से सही पाया जाता है जैसे कि यह वीडियो फीड पढ़ रहा है जो अभी भी बफर में है। हालाँकि यह हर बार नहीं होता है, मुझे अभी तक यह सुनिश्चित करने का कोई तरीका नहीं मिला है कि ऐसा कभी न हो, इसलिए यदि किसी के पास कोई विचार है तो मुझे टिप्पणियों में बताएं।

यहाँ वह पूरी स्क्रिप्ट एक ही स्थान पर है (और इसके ठीक नीचे डाउनलोड करने योग्य है):

आयात cv2

एनपी के रूप में numpy आयात करें os आयात समय आयात RPIO GPIO के रूप में GPIO। (कंट्रोलपिन , GPIO. OUT) GPIO.output(ControlPin, 0) GPIO.setup(2, GPIO. IN, pull_up_down=GPIO. PUD_DOWN) seq1 =

चरण 10: पाई को माउंट करना और मोटर को जोड़ना

रास्पबेरी पाई को फ्रेम में माउंट करना सरल था। मैंने एक छोटी 90-डिग्री कोहनी डिज़ाइन की जिसमें एक चेहरे में एक छेद था और दूसरी तरफ पूरी तरह से सपाट था। 3 डी प्रिंटिंग के बाद इनमें से दो को रास्पबेरी पाई के बढ़ते छेद पर शिकंजा के साथ जोड़ा जा सकता है (मैंने जीपीआईओ पिन के प्रत्येक तरफ दो छेद का इस्तेमाल किया)।

फिर मैं फ्रेम पर दराज के ठीक ऊपर पाई को गोंद करने के लिए 3 डी प्रिंटेड कोहनी के विपरीत चेहरों पर सुपर गोंद का उपयोग करने के लिए आगे बढ़ा। गोंद को सूखने देने के बाद मैं पाई को केवल दो स्क्रू के साथ आसानी से और आसानी से स्थिति में हटाने या बदलने में सक्षम था। मेरे पास नीचे लिंक की गई कोहनी के लिए.stl है।

अब बस मोटर चालक को PI से IN1, IN2, IN3, IN4 के साथ क्रमशः GPIO 14, 15, 18, 23 से कनेक्ट करें। अंत में, कंट्रोलर बोर्ड के 5v और ग्राउंड पिन को 5v आउटपुट और Pi के ग्राउंड पिन से कनेक्ट करें।

यहाँ कुछ संदर्भ के लिए पाई के पिनआउट का लिंक दिया गया है:

चरण 11: कैमरा माउंट करना

कैमरा माउंट करना पाई की तुलना में थोड़ा कम मजबूत था लेकिन इस तरीके से काम हो गया। प्रत्येक छोर पर 2 छेदों के साथ एक पतली बीम को डिजाइन और प्रिंट करने के बाद मैंने बीम को इसके बढ़ते छेद के माध्यम से रासबेरी पाई से जोड़ा। फिर बस कैमरे को दूसरे स्क्रू से बीम के विपरीत छोर से जोड़ दें। टा-दा! यह सुंदर मक्खी लग रही है।

चरण 12: ड्रॉअर-मूविंग-मैकेनिज्म बनाना और माउंट करना

निर्माता समुदाय के हमेशा परोपकारी उपहारों की बदौलत इस कदम को आसान बना दिया गया। थिंगविवर्स पर एक त्वरित खोज के बाद मैं TucksProjects द्वारा निर्मित एक रैखिक एक्ट्यूएटर खोजने में सक्षम था (यहां पाया गया: https://www.thingiverse.com/thing:2987762)। बस इतना करना बाकी था कि इसे एसडी कार्ड पर थप्पड़ मारें और प्रिंटर को काम करने दें।

मैंने फ़्यूज़न 360 में जाना समाप्त कर दिया और स्पर को संपादित किया क्योंकि मेरी मोटर का शाफ्ट टक्सप्रोजेक्ट्स द्वारा प्रदान किए गए एक के लिए बहुत बड़ा था। मेरे पास इसके लिए.stl नीचे है। प्रिंट हो जाने के बाद, हमें बस मोटर शाफ्ट पर स्पर लगाकर इसे इकट्ठा करने की जरूरत है, फिर मोटर और संलग्नक पक्षों को 2 स्क्रू के साथ जोड़कर (सुनिश्चित करें कि आपने इसे बंद करने से पहले रैक को बीच में रखा है)। मुझे रैक से एक इंच की दूरी काटनी पड़ी ताकि वह दराज और फ्रेम के बीच में फिट हो जाए।

अब जो कुछ बचा है वह तंत्र को फ्रेम और दराज से जोड़ रहा है। "लेकिन हम यह कैसे करेंगे?" आप पूछते हैं … हाँ, इसे मेरे साथ कहो: सुपर गोंद। जैसा कि ऊपर की तस्वीरों में दिखाया गया है, बस तंत्र को फ्रेम के नीचे रखें और इसे लकड़ी के उस टुकड़े के ऊपर धकेलें जिस पर दराज स्लाइड करता है। यहां यह महत्वपूर्ण है कि आप रैक/तंत्र को जितना संभव हो सके फ्रेम के समानांतर प्राप्त करने का प्रयास करें ताकि जब तंत्र चलता है तो यह दराज को सीधे धक्का दे, कोण पर नहीं। गोंद सूख जाने के बाद, रैक के किनारे पर कुछ और गोंद रखें और दराज को स्थिति में ले जाएं और इसे सूखने दें। एक बार पूरा होने के बाद हमारे पास अपने गुप्त दराज को अंदर और बाहर स्लाइड करने के लिए एक मजबूत तंत्र है।

चरण 13: मिरर के पीछे कार्डबोर्ड जोड़ना

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

चरण 14: अंतिम टुकड़े पर रखना

करने के लिए आखिरी चीज दराज के सामने वाले हिस्से को रखना है जिसे पहले अलग रखा गया था। मोटर को हिलाएं ताकि दराज चिपक जाए। फिर सामने के हिस्से को गोंद दें ताकि दराज का टुकड़ा बीच में रहे (चारो तरफ थोड़ा सा हैंग होना चाहिए। फिर आप इसे दीवार पर लटका सकते हैं।)

चरण 15: समापन

ये लो! कई सुधार किए जा सकते हैं जैसे कि पुश बटन जोड़ना, कुछ बेहतर टू-वे फिल्म खरीदना और कोड में उस बग को ठीक करना, लेकिन कुल मिलाकर, यह काम पूरा हो जाता है: यह एक दर्पण की तरह दिखता है, यह पूर्व निर्धारित को पहचानता है उपयोगकर्ता का चेहरा और यह उस प्यारे छोटे दराज को खोलता है। हमेशा की तरह मुझे आपके विचार, प्रश्न और संस्मरण नीचे कमेंट में सुनना अच्छा लगेगा।

समग्र रेटिंग: 10/10

टिप्पणियाँ: #WouldNotTryAgain… जब तक मैं इस निर्देश का पालन नहीं कर सकता;)

सीक्रेट कम्पार्टमेंट चैलेंज में भव्य पुरस्कार