NAIN 1.0 - Arduino का उपयोग करने वाला मूल ह्यूमनॉइड रोबोट: 6 चरण

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

नैन 1.0 में मूल रूप से 5 डिटेचेबल मॉड्यूल होंगे-

1) आर्म - जिसे सर्वो के माध्यम से नियंत्रित किया जा सकता है।

2) पहिए - जिन्हें डीसी मोटर्स से नियंत्रित किया जा सकता है।

3) लेग - नैन आंदोलन के लिए पहियों या पैरों के बीच स्विच करने में सक्षम होंगे।

4) सिर - इसके सिर को विभिन्न सिरों के लिए नियंत्रित किया जा सकता है।

5) कैमरा मॉड्यूल- जिसे फेस रिकग्निशन एक्सेस के लिए इंटरफेस किया जा सकता है।

इसके साथ ही NAIN यूजर्स से बात करने और इंटरैक्ट करने में सक्षम होगा और अपनी इनबिल्ट क्लॉक से आपको समय दिखा सकता है। इसमें वाई-फाई/ब्लूटूथ का उपयोग कर वायरलेस नियंत्रण होगा।

चरण 1: आवश्यक घटक

1. सर्वो मोटर्स -4
2. अरुडिनो मेगा - 1
3. रास्पबेरी पाई - 1
4. यूएसबी कैमरा -1
5. स्पीकर -1
6. डीसी मोटर्स -2
7. L293D -1
8. बैटरी पैक - 1
9. पहिए -2
10. कैस्टर व्हील्स - 2

इनके साथ आपको बॉडी बनाने के लिए एल्युमिनियम स्क्वायर स्ट्रिप्स और उन्हें ठीक से फिट करने के लिए स्क्रू और नट्स की आवश्यकता होगी।

चरण 2: शारीरिक संरचना

शरीर की संरचना हल्के एल्यूमीनियम वर्ग की छड़ से बनी होगी जो इसे आसानी से असेंबल करने में मदद करेगी।

अभी के रूप में उन्हें इकट्ठा करें जैसा कि चित्र में दिखाया गया है और साथ ही सर्वो मोटर्स को बाहों में संलग्न करने के लिए उचित स्थानों को काट दिया।

तल पर एक हेक्सागोनल लकड़ी का आधार संलग्न करें।

लकड़ी के आधार के नीचे, डीसी मोटर्स और पहियों को संलग्न करें जैसा कि हम किसी भी लाइन अनुयायी रोबोट में करते हैं।

दिलचस्प बात यह है कि दो कैस्टर व्हील जोड़ें- एक आगे की तरफ और दूसरा रोबोट के पीछे।

चरण 3: वायरिंग और कोडिंग

विभिन्न मॉड्यूल को तार-तार करने के लिए इस भाग में संलग्न कोड देखें।

सबसे पहले हमने स्टैंडअलोन कोड का उपयोग करके प्रत्येक मॉड्यूल का परीक्षण किया और फिर हमने उन सभी को एक में जोड़ दिया और ब्लूटूथ मॉड्यूल का उपयोग करके पहियों और हथियारों की गति को नियंत्रित किया।

चरण 4: रास्पबेरी पाई और छवि पहचान

छवि पहचान USB कैमरा और रास्पबेरी पाई का उपयोग करके की जाती है।

उसके लिए, आपको अपने पाई पर ओपन सीवी लाइब्रेरी स्थापित करनी होगी।

आप इसे यहाँ से कर सकते हैं -

फिर आपको हर कैस्केड का उपयोग करके छवि पहचान करने की आवश्यकता होगी।

आप इसे यहां से कर सकते हैं -https://thecodacus.com/category/opencv/#. WvsNC4iFPDc

उपरोक्त लिंक का अध्ययन करने और उसका अनुसरण करने के बाद, मैंने अपने द्वारा उपयोग किए गए अंतिम कोड में कुछ बदलाव किए हैं जिन्हें मैं नीचे चिपका रहा हूं -

डेटासेट जेनरेटर:

आयात सीवी2

कैम = cv2.वीडियो कैप्चर (0)

डिटेक्टर = cv2. CascadeClassifier('Classifiers/face.xml')

मैं = 0

ऑफसेट = 50

नाम = कच्चा_इनपुट ('अपना आईडी दर्ज करें')

जबकि सच:

रिट, आईएम = कैम.रीड ()

ग्रे=cv2.cvtColor(im, cv2. COLOR_BGR2GRAY)

चेहरे = डिटेक्टर। मल्टीस्केल (ग्रे, स्केलफैक्टर = 1.2, मिननेबर्स = 5, मिनसाइज = (100, 100), झंडे = cv2. CASCADE_SCALE_IMAGE)

for(x, y, w, h) फलकों में:

मैं=मैं+1

cv2.imwrite("dataSet/face।"+name +'.'+ str(i) + ".jpg", धूसर [y-offset:y+h+offset, x-offset:x+w+offset])

cv2.rectangle(im, (x-50, y-50), (x+w+50, y+h+50), (225, 0, 0), 2)

cv2.imshow('im', im[y-offset:y+h+offset, x-offset:x+w+offset])

अगर cv2.waitKey(100) और 0xFF == ord('q'):

टूटना

# ब्रेक अगर नमूना संख्या 20 से अधिक है

एलिफ (i>20):

टूटना

कैम.रिलीज ()

cv2.destroyAllWindows ()

यह आपकी तस्वीरों का एक डेटासेट बनाएगा जिसका उपयोग प्रमाणीकरण के लिए किया जाएगा।

प्रशिक्षक:

आयात सीवी2, ओएस

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

जनहित याचिका से आयात छवि

पहचानकर्ता = cv2.face.createLBPHFaceRecognizer ()

cascadePath = "क्लासिफायर/फेस.एक्सएमएल"

faceCascade = cv2. CascadeClassifier(cascadePath);

पथ = 'डेटासेट'

def get_images_and_labels (पथ):

image_paths = [os.path.join(path, f) f के लिए os.listdir(path)]

# छवियों में चेहरे की छवियां होंगी

छवियां =

# लेबल में वह लेबल होगा जो छवि को सौंपा गया है

लेबल =

image_paths में image_path के लिए:

# छवि पढ़ें और ग्रेस्केल में बदलें

image_pil = Image.open(image_path).convert('L')

# इमेज फॉर्मेट को numpy array में बदलें

छवि = np.array (image_pil, 'uint8')

# छवि का लेबल प्राप्त करें

nbr = int(os.path.split(image_path)[-1].split(.")[1].replace("face-", ""))

#nbr=int(''.join(str(ord(c)) c for c in nbr))

प्रिंट एनबीआर

# छवि में चेहरे का पता लगाएं

चेहरे = faceCascade.detectMultiScale(छवि)

# अगर चेहरे का पता चला है, तो चेहरे को इमेज से और लेबल को लेबल से जोड़ दें

फलकों में (x, y, w, h) के लिए:

images.append (छवि [y: y + h, x: x + w])

लेबल.एपेंड (nbr)

cv2.imshow ("ट्रेनिंग सेट में चेहरे जोड़ना …", छवि [y: y + h, x: x + w])

cv2.waitKey(१०)

# छवियों की सूची और लेबल सूची लौटाएं

वापसी चित्र, लेबल

चित्र, लेबल = get_images_and_labels (पथ)

cv2.imshow('test', images[0])

cv2.waitKey(1)

पहचानकर्ता। ट्रेन (छवियां, एनपी। सरणी (लेबल))

पहचानकर्ता.सेव ('ट्रेनर/ट्रेनर.वाईएमएल')

cv2.destroyAllWindows ()

डिटेक्टर

आयात सीवी2

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

आयात ओएस

सी = 0

पहचानकर्ता = cv2.face.createLBPHFaceRecognizer ()

पहचानकर्ता लोड ('ट्रेनर/ट्रेनर.वाईएमएल')

cascadePath = "क्लासिफायर/फेस.एक्सएमएल"

faceCascade = cv2. CascadeClassifier(cascadePath);

कैम = cv2.वीडियो कैप्चर (0)

फॉन्टफेस = cv2. FONT_HERSHEY_SIMPLEX

फोंटस्केल = 1

फॉन्टकलर = (255, 255, 255)

जबकि सच:

रिट, आईएम = कैम.रीड ()

ग्रे=cv2.cvtColor(im, cv2. COLOR_BGR2GRAY)

चेहरे = faceCascade.detectMultiScale(ग्रे, १.२, ५)

for(x, y, w, h) फलकों में:

cv2.rectangle(im, (x-50, y-50), (x+w+50, y+h+50), (225, 0, 0), 2)

आईडी = पहचानकर्ता। भविष्यवाणी (ग्रे [वाई: वाई + एच, एक्स: एक्स + डब्ल्यू])

अगर (आईडी <70):

अगर (आईडी == 1):

आईडी = "शशांक"

एलिफ (आईडी == 2):

अगर (सी == 0):

आईडी = "शिवम"

सी=सी+1

os.system ("एस्पीक 'वेलकम शिवम एक्सेस ग्रांटेड'")

अन्यथा:

आईडी = "शिवम"

अन्यथा:

आईडी = "अज्ञात"

cv2.putText(im, str(Id), (x, y+h), fontface, fontscale, fontcolor)

cv2.imshow('im', im)

अगर cv2.waitKey(10) और 0xFF==ord('q'):

टूटना

कैम.रिलीज ()

cv2.destroyAllWindows ()

चरण 5: एलसीडी और स्पीकर

मैंने I2C LED डिस्प्ले और एक स्पीकर का भी उपयोग किया है।

LED को Arduino Mega द्वारा नियंत्रित किया जाता है और इसका कोड अंतिम कोड में दिया जाता है।

स्पीकर के लिए, यह रास्पबेरी पाई से जुड़ा है और ईस्पीक यूटिलिटी का उपयोग करता है।

आप इसका संदर्भ यहां देख सकते हैं -

चरण 6: अंतिम चरण।

सब कुछ इकट्ठा करो और धमाके के लिए तैयार हो जाओ।