სახის ამოცნობის სარკე საიდუმლო განყოფილებით: 15 ნაბიჯი (სურათებით)

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:16

მე ყოველთვის მაინტერესებდა ყოველთვის შემოქმედებითი საიდუმლო განყოფილებები, რომლებიც გამოიყენება მოთხრობებში, ფილმებში და მსგავსი. ასე რომ, როდესაც ვნახე საიდუმლო განყოფილების კონკურსი, მე თვითონ გადავწყვიტე ექსპერიმენტი გამეკეთებინა იდეაზე და მეკეთებინა ჩვეულებრივი სარკე, რომელიც ხსნის საიდუმლო გვერდით უჯრას, როდესაც სწორი ადამიანი იხედება მასში.

Raspberry Pi- ს, პითონის პროგრამირების გარკვეული ცოდნისა და მე -8 კლასის მაღაზიის გამოყენებით, ჩვენ შეგვიძლია შევქმნათ ეს მბზინავი მოწყობილობა ობიექტების დასამალავად, რომელთა ხილვაც მხოლოდ სწორ მომხმარებელს ექნება.

მინდა განსაკუთრებული მადლობა გადავუხადო ამ ადამიანებს/პლატფორმებს, საიდანაც მივიღე ჩემი ინფორმაცია და რესურსები:

TeCoEd - Youtube არხი

ემეტი PiMyLifeUp– დან

MJRoBot Hackster.io– ზე (პროფილი)

გევენ მაკდონალდი - Youtube არხი

ტაკერ შენონი Thingiverse- ზე (პროფილი)

მარაგები

ჩარჩო მასალები:

• ვუდი ფიცარი (ამ დაფის ზომები იყო 42 "7,5" 5/16 ")
• ფანქრის სურათის ჩარჩო (მინით)
• Შესასხურებელი საღებავი
• ერთი გზა ამრეკლავი წებოვანი
• შუშის საწმენდი და ჯოხი
• MDF ხე

სახის ამოცნობის საშუალებები:

• ჟოლო Pi (მე გამოვიყენე Pi 3 B+, მაგრამ არის სხვა ვარიანტებიც)
• კამერის მოდული
• Ბიჯური ძრავი

ინსტრუმენტები:

• მაგიდის ხერხი
• ჯიგ ხერხი
• SandpaperWood
• GlueTape
• გაზომეთ
• Მაკრატელი
• სპრეის ბოთლი
• 3D პრინტერი
• Სუპერ წებო

ნაბიჯი 1: მოჭრა ყუთის ჩარჩოსთვის

მე ვიყიდე სურათის ჩარჩო მეორადი მაღაზიიდან. მხოლოდ გაფრთხილება, დარწმუნდით, რომ ფიცრები, რომლებიც ქმნიან ჩარჩოს, არის მინიმუმ 1 1/2 სიგანის. ეს არის ასე, რომ თქვენ შეგიძლიათ წებოთ მასზე სხვა დაფები, სადაც საკმარისი ადგილი გაქვთ სამუშაოდ. ასევე, დარწმუნდით, რომ მინის ჩარჩო სრულიად ნათელია. მე შემთხვევით ვიყიდე ყინვაგამძლე და შემდეგ მომიწია ყიდვა სხვა ჩარჩო მხოლოდ გამჭვირვალე მინისთვის. რადგან ჩემი ჩარჩო გამოიყენება ყუთის ჩარჩოს გაზომვები შეიძლება განსხვავდებოდეს.

• განათავსეთ ჩარჩო პორტრეტის ორიენტაციაში. გაზომეთ შუშის ხვრელის მხარის გრძელი მხარეები (LS) ჩარჩოზე დამატებითი ½”ზემოდან და ქვემოდან. (ანუ დაამატეთ ინჩი შუშის ხვრელის გაზომვის გრძელ მხარეს. ჩაწერეთ ეს და მონიშნეთ LSM (Long Side Measurement).
• ანალოგიურად, გაზომეთ ხვრელის ზედა მხარე და დაამატეთ დამატებითი 1”. ჩაწერეთ ეს და მონიშნეთ SSM (მოკლე გვერდითი გაზომვა).
• აიღეთ დაფა და მაგიდის ხერხით გაჭერით ორი LSM x 2”და ორი SSM x 2”.
• აიღეთ LSM- ის ერთ -ერთი მონაკვეთი და გაზომეთ 2”x1” მართკუთხედი, რომელიც არის 1”ქვემოდან და ½” მარცხენა და მარჯვენა მხრიდან (როგორც ეს ნაჩვენებია სურათზე 3).
• გამოიყენეთ jigsaw ამოჭრა ხვრელი. შემდეგ გამოიყენეთ ქვიშის ფურცელი, რომ კიდეები გაასუფთაოთ.

ნაბიჯი 2: შემცირება უჯრისთვის

ახლა ჩვენ დავიწყებთ უჯრის (ანუ საიდუმლო განყოფილების) მშენებლობას.

• ამოჭრა ორი 4”x 1” გვერდი, 3 ⅜”x 1” (უკანა კიდე), 4 ¼”x 1 ¼” (წინა კიდე) და 4”x 3 ⅜” (პლატფორმა).
• წებოვანა პირველი 4”x 1” მხარე პლატფორმის 4”გვერდის გასწვრივ. პლატფორმის გვერდით რამოდენიმე დაკეცილი ქაღალდი დავდე, ასე რომ ოდნავ წამოიწია, ამ გზით ის არ გადაიტანს ხვრელს, რომელიც LS ფიცარში ამოვიღე. დადგით გასაშრობად 30 წთ.
• ანალოგიურად, წებოვანა 3 ⅜”x 1” პლატფორმის 3 ⅜”ზღვარზე. დადგით გასაშრობად 30 წთ. შემდეგ წებო მეორე 4”x 1” მხარეს პირველის საპირისპირო მხარეს. დადგით გასაშრობად 30 წთ.
• ახლავე გადადეთ წინა ზღვარი. ეს იქნება უკანასკნელი, რაც შეკერილია უჯრაზე.
• დასრულებისთანავე, შეამოწმეთ, ჯდება თუ არა იგი იმ ხვრელში, რომელიც თქვენ LSM ფიცარში მოათავსეთ. თუ არა, გახეხეთ ხვრელი, სანამ უჯრა ადვილად არ შემოდის შიგნით და გარეთ და არ იქნება გადატანა.

ნაბიჯი 3: ჩარჩოს გაერთიანება

ყველა ნაწილის დასრულებით ჩვენ შეგვიძლია დავიწყოთ ჩარჩოს მთლიანობის შეკრება.

• მიამაგრეთ LSM ფიცარი შუშის ხვრელის ცენტრში, ½”თითოეულ მხარეს. დარწმუნდით, რომ იგი არის შეკრული ½”ხვრელიდან მოშორებით (როგორც ნაჩვენებია სურათზე 1). დადგით გასაშრობად 30 წთ.
• მიამაგრეთ პირველი SSM ფიცარი, რომლის კიდეც ეხება LSM ფიცრის შიგნიდან, რომელიც ახლახან იყო წებოვანი. (გამოიყენეთ მმართველი, რომ დარწმუნდეთ, რომ ის წებოვანია პირდაპირ). დადგით გასაშრობად 30 წთ.
• აიღეთ LSM- ის მეორე მხარე და წებეთ პირველის მსგავსი. დარწმუნდით, რომ ის ½”დაშორებულია ხვრელიდან და რომ SSM, რომელიც ახლახან იყო დამაგრებული, წებოვანია ფიცრის შიგნით. დადგით გასაშრობად 30 წთ.
• მიამაგრეთ ბოლო SSM ზედა ზღვარზე. ვინაიდან თქვენ გაქვთ ორი LSM ორივე მხარეს, იმისდა მიხედვით, თუ რამდენად პირდაპირ მიამაგრეთ ისინი, შეიძლება დაგჭირდეთ SSM- ის გვერდების ქვიშა ქვემოთ, რომ დარწმუნდეთ, რომ ის ჯდება (ჩემი ჭრა ზოგჯერ გამორთულია). დადგით გასაშრობად 30 წთ.
• გაზომეთ პატარა სივრცე უჯრის ძირსა და ჩარჩოს შორის. გაჭერით MDF ხის ნაჭერი ამ გაზომვით, 4 "-ით. თქვენ გინდათ ეს ნაჭერი უჯართან ახლოს გახადოთ, მაგრამ არ შეეხოთ მას. ის გულისხმობს უჯრის შენარჩუნებას მინიმალური ხახუნის საშუალებით.
• როდესაც ყველაფერი დამთავრდა, მე სპრეით შეღება ჩარჩო ისე, რომ ყველა ნაჭერი დაემთხვა.

ნაბიჯი 4: სარკისთვის

ცალმხრივი ფილმის წებო, რომელიც Amazon- ში შევიძინე, დაახლოებით $ 10 იყო. არის უკეთესი ხარისხის, რომლებიც ცოტა უფრო ძვირი ღირს, თუ დაგაინტერესებთ. ის, რასაც მე ვიყენებ, ასახავს, მაგრამ თქვენ შეგიძლიათ თქვათ, რომ ეს არ არის ჩვეულებრივი სარკე, რომელსაც ნახავთ სახლში. უფრო ძვირი კი მოგანიჭებთ იმ იერს.

• გაწმინდეთ ჭიქა მინის გამწმენდით ორივე მხრიდან.
• გაშალეთ ცალმხრივი წებოვანი და დადეთ მინა თავზე. ამოიღეთ წებოვანი ისე, რომ მინიმუმ ½”ჭარბი იყოს შუშის თითოეულ მხარეს.
• დატოვე ჭიქა გვერდზე და დაასველე მისი ერთი მხარე წყლით. შემდეგ ამოიღეთ პლასტიკური ქურთუკი ცალმხრივი წებოვანიდან და დაასხით ახლად გამოვლენილი მხარე წყლით.
• მოათავსეთ შუშის სველი მხარე წებოს სველ მხარეს. გავაჩეროთ 30 წთ.
• გადაატრიალეთ და გამოიყენეთ ცერა თითი წებოსა და მინას შორის არსებული ბუშტუკების გასასწორებლად. შემდეგ მოჭერით ზედმეტი წებოვანი კიდეები გარშემო.

ნაბიჯი 5: დააინსტალირეთ Raspbian Stretch

ეს იყო პირველი შემთხვევა, როდესაც ჟოლოს გარე გარემოში დავიწყე ინსტრუქციების ძებნა, თუ როგორ უნდა დაინსტალირებულიყო OS. მე საბოლოოდ აღმოვაჩინე პირდაპირი გაკვეთილი Youtube– ზე TeCoEd– ის მიერ, რომელმაც გაიარა SD ბარათზე Stretch– ის დაყენების პროცესი (საკმაოდ მშვენიერი შესავლითაც). აქ მოცემულია ამ სამეურვეო პროგრამის ბმული:

სინამდვილეში, ყველაფერი რაც თქვენ გჭირდებათ არის:

• SD ბარათის ფორმატირება თქვენი Drive >> Drive Tools >> ფორმატის არჩევით. ჩამოტვირთეთ ZIP ფაილი Raspian Stretch– ისთვის (ნაპოვნია აქ:
• შეაერთეთ OS გამოსახულება SD ბარათზე. ამის დასასრულებლად TeCoEd– მა გამოიყენა Win32 Disk Imager. მე დავასრულე balenaEtcher– ის დაყენება, რომელიც ცოტა უფრო მარტივი ჩანდა. (აქ არის balenaEtcher– ის გადმოსაწერი ბმული:
• ერთხელ balenaEtcher- ში აირჩიეთ "Flash From File" და აირჩიეთ ადრე გადმოწერილი ZIP ფაილი. შემდეგი, შეარჩიეთ სასურველი SD ბარათი (თუ ავტომატურად არ არის არჩეული). შემდეგ დააჭირეთ წვნიანი ფლეშ ღილაკს და დაელოდეთ მაგიის მოხდენას.

SD ბარათზე დაყენების შემდეგ შეგიძლიათ ჩაწეროთ იგი Raspberry Pi- ში და გაიაროთ ზოგადი Pi დაყენების პროცესი.

ნაბიჯი 6: დააინსტალირეთ OpenCV

ახლა უფრო სახეზე ორიენტირებული ნაწილებისკენ. სახეების ამოცნობის მიზნით, ჩვენ უნდა გადმოვწეროთ OpenCV ბიბლიოთეკა, რომელიც შეიცავს უამრავ ინსტრუმენტს კომპიუტერულ ხედვასთან მუშაობისთვის.

OpenCV– ის დაყენება ჩემთვის ყველაზე რთული პროგრამული უზრუნველყოფის ასპექტი იყო. მაგრამ მრავალი მითითების შემდეგ საბოლოოდ ვიპოვე ემეტის სამეურვეო პროგრამა PiMyLifeUp– დან, რომელმაც შეასრულა ის ხრიკი, რომელიც აქ არის:

მე არ გადავდგამ ამ ნაბიჯებს, ვინაიდან თქვენ საუკეთესოდ შეეფერებით მათ ბმულიდან (მოცემული ახსნა -განმარტებებით და პირდაპირ საიტიდან კოპირების და ჩასმის უნარით უფრო მარტივად).

ნაბიჯი 7: ჩართეთ/შეამოწმეთ კამერა

OpenCV– ის დაყენების შემდეგ ჩემი დარჩენილი მოგზაურობა დასრულდა MJRoBot– ის სახელმძღვანელოს გამოყენებით Hackster.io– ზე ნაპოვნი აქ:

სანამ დავიწყებდეთ, მინდა შეგახსენოთ, რომ მე არ ვარ ამ სკრიპტების ორიგინალური შემქმნელი, მაგრამ საბოლოოდ შევცვალე მათი ნაწილები.

დასაწყისისთვის ჩვენ უნდა შევამოწმოთ კამერა, რათა დავრწმუნდეთ, რომ ჩვენ შეგვიძლია ვიდეოს ეკრანზე გადაღება. დაახლოებით ერთი საათი გავატარე MJRoBot– ის მე –3 საფეხურზე მოცემული სკრიპტის გაშვებაზე. როგორც ცხოვრება გვსურს, ჩვენ რეალურად უნდა გავააქტიუროთ კამერა Raspberry Pi– ზე (გამოდის, რომ კარგი იდეა იქნება მოცემული ინსტრუქციის წაკითხვა … მმმ არა). კამერის მის სწორ პორტთან დაკავშირების შემდეგ მიყევით ამ ნაბიჯებს:

• გახსენით ბრძანების ტერმინალი და ჩაწერეთ sudo raspi-config
• აირჩიეთ "კამერის ჩართვა" (ეს შეიძლება მოიძებნოს მოწყობილობების ვარიანტში)
• დააჭირეთ "Enter"
• გადადით "დასრულება" და მოგთხოვთ გადატვირთვა

შემდეგ მიჰყევით ამ ნაბიჯებს:

• გადადით ჟოლოს მთავარ მენიუში (ზედა მარცხნივ)
• პრეფერენციები
• ჟოლო Pi კონფიგურაცია
• ინტერფეისები
• შემდეგ კამერაში აირჩიეთ "ჩართული"
• შემდეგ "კარგი"

ახლა თქვენ უნდა შეგეძლოთ წარმატებით გაუშვათ ეს სკრიპტი MJRoBot– ის სამეურვეოდან კამერის შესამოწმებლად (გახსოვდეთ, რომ მთელი ეს კოდი პლუს უფრო სიღრმისეული აღწერილობა ნაპოვნია MJRobot– ის სახელმძღვანელოს ზემოთ მოცემულ ბმულში):

იმპორტირებული numpy როგორც np

იმპორტი cv2 cap = cv2. VideoCapture (0) cap.set (3, 640) # კომპლექტი სიგანე cap.set (4, 480) # კომპლექტი სიმაღლე ხოლო (ჭეშმარიტი): ret, frame = cap.read () frame = cv2. გადაბრუნება (ჩარჩო, -1) # გადატრიალება კამერა ვერტიკალურად ნაცრისფერი = cv2.cvtColor (ჩარჩო, cv2. COLOR_BGR2GRAY) cv2.imshow ("ჩარჩო", ჩარჩო) cv2.imshow ("ნაცრისფერი", ნაცრისფერი) k = cv2.waitKey (30) & 0xff, თუ k == 27: # დააჭირეთ 'ESC', რომ დატოვოთ break cap.release () cv2.destroyAllWindows ()

წინა კოდში უნდა იყოს ორი ფანჯარა, ერთი ფერადი და მეორე ნაცრისფერი. თუ აქამდე მიაღწიე, მე ვფიქრობ რომ შენ იმსახურებ ლამაზ სენდვიჩს.

ნაბიჯი 8: მონაცემთა შეგროვება და ტრენინგის მონაცემები

მოწოდებულ სახელმძღვანელოში ავტორი უფრო ღრმად იკვლევს კოდის პროცესებს, რომლებიც მალე იქნება გათვალისწინებული, მაგრამ ვინაიდან ეს არის ინსტრუქცია, თუ როგორ შეიქმნა ეს სარკე, მე არ ჩავუღრმავდები ისტორიას და არც რთულ მექანიკას. მე მაინც გირჩევთ, რომ ერთი თვე დაუთმოთ თქვენს ცხოვრებას ამ ორი საკითხის კითხვას, რადგან ისინი კარგად გვეხმარებიან თქვენს გონებაში.

სულ რაღაც სამი სკრიპტია გასაშვები, სანამ ამ ყველაფრის მუშაობას შევძლებთ. პირველი არის მონაცემთა შეგროვებისთვის, მეორე არის მისი მომზადებისთვის და ბოლო რეალურად აღიარებისთვის. მონაცემების შეგროვება მოითხოვს სახის რეალური სურათების გადაღებას და შენახვას სპეციალურ ადგილას ვარჯიშისათვის. ამ კოდის შემქმნელმა ძალიან გაადვილა ამ ყველაფრის გაკეთება, ამიტომ გირჩევთ დაიცვას ეს ინსტრუქციები თავის ტკივილის თავიდან ასაცილებლად.

გახსენით ბრძანების სტრიქონი და შექმენით ახალი დირექტორია, დაასახელეთ ის რაიმე სახალისო (მე დავურეკე ჩემს FaceRec)

mkdir FaceRec

ახლა შეცვალეთ დირექტორია FaceRec– ში და შექმენით ქვედირექტორი, რომელიც აუცილებლად ასახელებს მის მონაცემთა ნაკრებს

cd FaceRec

mkdir მონაცემთა ნაკრები

სანამ ჩვენ ამას ვაკეთებთ, ჩვენ შეგვიძლია შევქმნათ სხვა ქვე დირექტორიაც სახელად ტრენერი

mkdir ტრენერი

ახლა თქვენ შეგიძლიათ გაუშვათ და მიჰყევით პირველი სკრიპტის მითითებებს, რომელიც გადაიღებს მომხმარებლის სურათებს. (უბრალოდ თავით ზემოთ, დარწმუნდით, რომ შეიყვანეთ მომხმარებლის ID როგორც 1, 2, 3 და ა

იმპორტი cv2import os cam = cv2. VideoCapture (0) cam.set (3, 640) # set video width cam.set (4, 480) # set video height face_detector = cv2. CascadeClassifier ('haarcascade_frontalface_default.xml') # თითოეულისთვის პირი, შეიყვანე ერთი რიცხვითი სახის პიგმენტი face_id = შეყვანა ('\ n შეიყვანეთ მომხმარებლის იდენტიფიკატორი პრესა ==>') ბეჭდვა ("\ n [ინფორმაცია] სახის გადაღების ინიციალიზება. შეხედეთ კამერას და დაელოდეთ …") # ინდივიდუალური შერჩევის ინიციალიზაცია ითვლი = 0 ხოლო (მართალია): ret, img = cam.read () img = cv2.flip (img, -1) # გადაატრიალე ვიდეო სურათი ვერტიკალურად ნაცრისფერი = cv2.cvtColor (img, cv2. COLOR_BGR2GRAY) სახეები = face_detector.detectMultiScale (ნაცრისფერი, 1.3, 5) for (x, y, w, h) სახეებში: cv2. მართკუთხედი (img, (x, y), (x+w, y+h), (255, 0, 0), 2) დათვლა + = 1 # შეინახეთ გადაღებული სურათი მონაცემთა ნაკრების საქაღალდეში cv2.imwrite ("მონაცემთა ნაკრები/მომხმარებელი." + Str (face_id) + '.' + Str (რაოდენობა) + ".jpg", ნაცრისფერი [y: y +h, x: x+w]) cv2.imshow ('image', img) k = cv2.waitKey (100) & 0xff # დააჭირეთ 'ESC' ვიდეოს გასასვლელად, თუ k == 27: დაარღვიე elif რაოდენობა> = 30: # მიიღეთ 30 სახის ნიმუში და შეაჩერეთ ვიდეო brea k print ("\ n [INFO] პროგრამის გასვლა და გასუფთავება") cam.release () cv2.destroyAllWindows ()

ამ დროს დარწმუნდით, რომ Pi- ზე დააინსტალირეთ ბალიში. თუ არა, გაუშვით ბრძანება:

პიპის დაყენების ბალიში

ამის დასრულების შემდეგ თქვენ შეგიძლიათ გაუშვათ სასწავლო სკრიპტი (მეორე სკრიპტი), რომელიც შეუფერხებლად მოგაწვდით.yaml ფაილს, რომელიც გამოყენებული იქნება საბოლოო სკრიპტში

იმპორტი cv2 იმპორტი numpy როგორც np PIL– დან იმპორტი გამოსახულება იმპორტი os # გზა სახის გამოსახულების მონაცემთა ბაზის ბილიკი = 'მონაცემთა ნაკრები' ამოცნობა = cv2.face. LBPHFaceRecognizer_create () დეტექტორი = cv2. CascadeClassifier ("haarcascade_frontalface_default.xml"); # ფუნქცია სურათებისა და ეტიკეტის მონაცემების მისაღებად defIImagesAndLabels (გზა): imagePaths = [os.path.join (path, f) for f in os.listdir (path)] faceSamples = ids = imagePath in imagePaths: PIL_img = Image.open (imagePath).convert ('L') # გადაიყვანეთ ნაცრისფერში img_numpy = np.array (PIL_img, 'uint8') id = int (os.path.split (imagePath) [-1]. გაყოფა (".") [1]) სახეები = დეტექტორი. detectMultiScale (img_numpy) for (x, y, w, h) in სახეები: faceSamples.append (img_numpy [y: y+h, x: x+w]) ids.append (id) return faceSamples, ids print ("\ n [INFO] Training სახეები. დასჭირდება რამდენიმე წამი. დაელოდეთ …") სახეები, ids = getImagesAndLabels (გეზი) ამოცნობა.ტრენაჟი (სახეები, np.array (ID)) # შეინახეთ მოდელი ტრენერ/ტრენერში. ("\ n [ინფორმაცია] {0} გაწვრთნილი სახეები. პროგრამის გასვლა". ფორმატი (len (np.unique (ids))))

სკრიპტების ამ ნაკრებში ყველაზე საინტერესო ის არის, რომ სისტემაში მრავალი სახე შეიძლება შევიდეს, რაც იმას ნიშნავს, რომ სურვილის შემთხვევაში რამოდენიმე ადამიანს შეუძლია წვდომა სარკის შიგნიდან.

ქვემოთ მაქვს მონაცემთა გადაღების სკრიპტი და სასწავლო სკრიპტი ხელმისაწვდომია ჩამოსატვირთად.

ნაბიჯი 9: სახის ამოცნობის დრო

დაბოლოს, ჩვენ შეგვიძლია გაუშვათ ამოცნობის სკრიპტი. ამ კოდს დაემატა მეტი კოდი საავტომობილო პროცესის ფუნქციონირების მიზნით, ასე რომ მე ამ ნაწილებს უფრო დეტალურად ავუხსნი. მე მას დავყოფ ნაწილებად, მაგრამ მთელ სკრიპტს დავაყენებ ნაბიჯის ბოლოს, თუ თქვენ ამისკენ მიდიხართ.

ჩვენ დავიწყებთ ყველა მოდულის იმპორტით, რომელიც დაგვჭირდება და შემდეგ GPIO რეჟიმის დაყენებით GPIO. BCM

იმპორტირებული numpy როგორც np

იმპორტი os იმპორტის დრო იმპორტი RPi. GPIO როგორც GPIO GPIO.setwarnings (false) GPIO.setmode (GPIO. BCM)

ეს შემდეგი სია სახელწოდებით ControlPin არის რიცხვების მასივი, რომელიც წარმოადგენს გამომავალ ქინძისთავებს, რომლებიც გამოყენებული იქნება ჩვენი სტეპერი ძრავისთვის.

ControlPin = [14, 15, 18, 23]

For-loop ადგენს ამ ქინძისთავებს როგორც გამომავალს და შემდეგ დარწმუნდება, რომ ისინი გამორთულია. მე ჯერ კიდევ მაქვს კოდი, რომ უჯრა დაიხუროს ღილაკზე დაჭერით, მაგრამ მის მაგივრად გადავწყვიტე ტაიმერის გამოყენება.

GPIO.setup (ControlPin , GPIO. OUT)

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

შემდეგი ორი ცვლადი არის თანმიმდევრობა, რომელსაც ჩვენ გამოვიყენებთ ძრავის მართვისთვის. მე ვისწავლე ეს ინფორმაცია Gaven MacDonald– ის მშვენიერი ვიდეოდან, რომლის ნახვასაც გირჩევთ, რადგან ის სიღრმისეულად გადის არა მხოლოდ კოდზე, არამედ რეალურ ძრავზე (ნაპოვნია აქ: https://www.youtube.com/embed/Dc16mKFA7Fo) რა არსებითად, თითოეული თანმიმდევრობა განმეორდება ბუდეების ჩამონტაჟებული მარყუჟების გამოყენებით მომავალი openComp და closeComp ფუნქციებში. თუ კარგად დააკვირდებით, seq2 არის ზუსტად seq1– ის საპირისპირო. დიახ, თქვენ მიხვდით. ერთი არის ძრავის წინსვლისთვის, მეორე კი საპირისპიროდ.

სექ 1 =

სექ 2 =

ჩვენი openComp ფუნქციით დაწყებული ჩვენ ვქმნით for-loop- ს, რომელიც გაიმეორებს 1024-ჯერ. მაკდონალდსის ვიდეოს თანახმად, 512 გამეორება უზრუნველყოფს ძრავის სრულ ბრუნვას და აღმოვაჩინე, რომ დაახლოებით ორი ბრუნვა კარგი სიგრძის იყო, მაგრამ ეს შეიძლება მორგებული იყოს ინდივიდის ზომის მიხედვით. მომდევნო მარყუჟი შედგება 8 გამეორებისაგან, რათა გამოითვალოს 8 მასივი, რომლებიც ნაპოვნია 1 და 2 სექში. დაბოლოს, ბოლო მარყუჟი ოთხჯერ მეორდება იმ ოთხი ერთეულისთვის, რომლებიც გვხვდება თითოეულ ამ მასივში, ასევე 4 GPIO ქინძისთავთან, რომელთანაც დაკავშირებულია ჩვენი ძრავა. აქ ხაზი ირჩევს GPIO პინს და შემდეგ ჩართავს ან გამორთავს იმისდა მიხედვით, თუ რომელ გამეორებაზეა ის ჩართული. შემდეგ ხაზი იძლევა ბუფერულ დროს, რათა ჩვენი ძრავა საერთოდ არ ბრუნავდეს. მას შემდეგ, რაც ძრავა ბრუნავს უჯრის გადასატანად, მას სძინავს 5 წამი სანამ გადაადგილდება. ეს დრო შეიძლება მორგებული იყოს აქ ან შეგიძლიათ ჩართოთ კომენტარირებული კოდი, რომელიც საშუალებას გაძლევთ გამოიყენოთ ღილაკი სკრიპტის წინ გადასაყენებლად და არა ტაიმერით.

მე დიაპაზონში (1024):

დიაპაზონში (8): დიაპაზონში დიაპაზონში (4): GPIO.output (ControlPin [pin], seq1 [halfstep] [pin]) time.sleep (.001) "" "while True: if GPIO.input (2) == GPIO. LOW: შესვენება; "" დრო. ძილი (5)

CloseComp ფუნქცია მუშაობს ანალოგიურად. მას შემდეგ, რაც ძრავა უკან ბრუნდება, ვაგრძელებ ჩვენი ბოლო GPIO ქინძისთავების დაბალ მნიშვნელობას, რათა დავრწმუნდე, რომ ენერგიას არ ვკარგავთ და შემდეგ კიდევ სამ წამს ვამატებ დროზე გადასვლამდე.

მე დიაპაზონში (1024):

დიაპაზონში ნახევარი ნაბიჯისათვის (8): დიაპაზონში დიაპაზონისთვის (4): GPIO.output (ControlPin [pin], seq2 [halfstep] [pin]) time.sleep (.001) print ("Compartment Closed") GPIO.output (ControlPin [0], 0) GPIO.output (ControlPin [3], 0) time.sleep (3)

შემდეგი ნაწილის ძირითადი ნაწილი გამოიყენება კამერის დასაყენებლად და სახის ამოცნობის დასაწყებად. ისევ და ისევ, MKRoBot– ის მითითებები უფრო მეტად ნაწილდება, მაგრამ ჯერჯერობით, მე მხოლოდ სარკისთვის გამოყენებულ ნაწილებს ვაჩვენებ.

პირველ რიგში შევცვალე სიის სახელები ისე, რომ ჩემი სახელი იყოს იმ ინდექსში, რომელიც მე მას მივანიჭე მონაცემების შეგროვებისას (ჩემს შემთხვევაში 1). შემდეგ მე დავნიშნე დანარჩენი მნიშვნელობები None რადგან მონაცემთა ნაკრებში აღარ მქონდა სახეები.

სახელები = ['არცერთი', 'დანიელი', 'არცერთი', 'არცერთი', 'არცერთი', 'არცერთი']

ჩვენი კოდის ბოლო რამდენიმე ხაზი დანერგილია thicc for-loop- ში. მე შევქმენი ცვლადი ნდობის შესანახად მთელ რიცხვში (intConfidence) სანამ ცვლადი ნდობა გადაიქცევა სტრიქონად. შემდეგ ვიყენებ if- განცხადებას იმის შესამოწმებლად, არის თუ არა ნდობა 30-ზე მეტი და თუ id (რომელ ადამიანს კომპიუტერი აღმოაჩენს, ამ შემთხვევაში "დანიელი") ჩემი სახელის ტოლია.ამის დადასტურების შემდეგ ეწოდება openComp ფუნქცია, რომელიც (როგორც უკვე აღვნიშნეთ) ამოძრავებს ძრავას, ამოძრავებს 5 წამის შემდეგ და შემდეგ აგრძელებს დახურვას, რომელიც მოძრაობს ძრავას საპირისპირო მიმართულებით და აკეთებს გასუფთავებას thicc მარყუჟის გაგრძელებამდე.

თუ intConfidence> 30 და id == 'დანიელი':

openComp () closeComp ()

შეცდომა, რომელიც აქ აღმოვაჩინე ის არის, რომ ზოგჯერ closeComp– ის დაბრუნების შემდეგ, კოდი გრძელდება, მაგრამ პირობითი if- განცხადება კვლავ ჭეშმარიტი აღმოჩნდება, თითქოს ის კითხულობს ვიდეოს, რომელიც ჯერ კიდევ ბუფერშია. მიუხედავად იმისა, რომ ეს არ ხდება ყოველ ჯერზე, მე ჯერ კიდევ ვიპოვნე გზა იმის უზრუნველსაყოფად, რომ ეს არასოდეს მოხდეს, ასე რომ, თუ ვინმეს რაიმე იდეა აქვს, შემატყობინეთ კომენტარებში.

აქ არის მთელი სკრიპტი ერთ ადგილას (და ქვემოთ არის გადმოწერა):

იმპორტი cv2

იმპორტი numpy როგორც np იმპორტი os იმპორტის დრო იმპორტი RPi. GPIO როგორც GPIO GPIO.setwarnings (ყალბი) GPIO.setmode (GPIO. BCM) ControlPin = [14, 15, 18, 23] i დიაპაზონში (4): GPIO.setup (ControlPin , GPIO. OUT) GPIO.output (ControlPin , 0) GPIO.setup (2, GPIO. IN, pull_up_down = GPIO. PUD_DOWN) seq1 =

ნაბიჯი 10: Pi– ს დამონტაჟება და ძრავის დაკავშირება

Raspberry Pi- ს ჩარჩოზე დაყენება საკმაოდ მარტივი იყო. მე შევქმენი პატარა 90 გრადუსიანი იდაყვი, რომელსაც ერთი სახე ჰქონდა ხვრელით, ხოლო მეორე მხარე სრულიად ბრტყელი. 3D ბეჭდვის შემდეგ, ორი მათგანი შეიძლება მიმაგრდეს Raspberry Pi– ზე მისი სამონტაჟო ხვრელებით (მე გამოვიყენე GPIO ქინძის თითოეულ მხარეს ორი ხვრელი).

შემდეგ გავაგრძელე სუპერ წებოს გამოყენება 3D დაბეჭდილი იდაყვის საპირისპირო სახეებზე, რომ ჩამწეროთ Pi უჯრის ზემოთ ჩარჩოზე. მას შემდეგ, რაც წებო გაშრა, მე შევძელი ამოვიღო ან შევცვალო Pi პოზიციაში მარტივად და მოხერხებულად მხოლოდ ორი ხრახნით. ქვემოთ მაქვს იდაყვის.stl.

ახლა უბრალოდ დააკავშირეთ ძრავის მძღოლი PI– სთან IN1, IN2, IN3, IN4 შესაბამისად GPIO 14, 15, 18, 23 შესაბამისად. დაბოლოს, დააკავშირეთ კონტროლერის დაფის 5v და Ground ქინძისთავები Pi- ს 5v გამომავალ და Ground ქინძისთავებთან.

აქ არის ბმული Pi's Pinout– ზე გარკვეული მითითებისთვის:

ნაბიჯი 11: კამერის დამონტაჟება

კამერის დამონტაჟება Pi– ზე ოდნავ უფრო ძლიერი იყო, მაგრამ მეთოდმა შედეგი გამოიღო. თხელი სხივის შემუშავებისა და დაბეჭდვის შემდეგ, თითოეულ ბოლოში 2 ხვრელით, მე დავამატე სხივი Rasberry Pi– ს მისი სამონტაჟო ხვრელის მეშვეობით. შემდეგ უბრალოდ მიამაგრეთ კამერა სხივის მოპირდაპირე ბოლოს სხვა ხრახნით. ტა-და! ის საკმაოდ დაფრინავს.

ნაბიჯი 12: უჯრის გადაადგილების მექანიზმის შექმნა და მონტაჟი

ეს ნაბიჯი ადვილი გახდა დამსაქმებელთა საზოგადოების კეთილგანწყობილი საჩუქრების წყალობით. Thingiverse– ზე სწრაფი ძებნის შემდეგ მე შევძელი TucksProjects– ის მიერ შექმნილი წრფივი ამძრავის პოვნა (ნაპოვნია აქ: https://www.thingiverse.com/thing:2987762). დარჩა მხოლოდ SD ბარათზე მისი დარტყმა და პრინტერის მუშაობის ნება.

მე დავასრულე Fusion 360– ში შესვლა და შევცვალე სტიმული, რადგან ჩემი ძრავის ლილვი ძალიან დიდი იყო TucksProjects– ის მიერ მოწოდებული. მე მაქვს.stl ამისთვის ქვემოთ. დაბეჭდვის დასრულების შემდეგ, ჩვენ უბრალოდ უნდა შევიკრიბოთ იგი ძრავის ლილვზე დაყენებით, შემდეგ კი ძრავისა და გარს გვერდების დამაგრებით 2 ხრახნით (დარწმუნდით, რომ თარო დახურვის წინ დადეთ). მე საბოლოოდ მომიწია თაროდან ერთი სანტიმეტრის მოშორება ისე, რომ ის ჯდება უჯრასა და ჩარჩოს შორის.

ახლა რჩება მხოლოდ მექანიზმის მიმაგრება ჩარჩოსა და უჯრაზე.”როგორ გავიგოთ, როგორ ვიქცევით?” თქვენ გკითხავთ … დიახ, თქვით ჩემთან ერთად: სუპერ წებო. როგორც ზემოთ მოყვანილ სურათებშია ნაჩვენები, უბრალოდ მოათავსეთ მექანიზმი ჩარჩოს ბოლოში და მაღლა წაწიეთ ხის ნაჭერზე, რომელზედაც უჯრა სრიალებს. აქ სასიცოცხლოდ მნიშვნელოვანია, რომ თქვენ შეეცადოთ თარო/მექანიზმი მიიღოთ რაც შეიძლება პარალელურად ჩარჩოსთან ისე, რომ როდესაც მექანიზმი მოძრაობს ის უბიძგებს უჯრას პირდაპირ და არა კუთხეზე. მას შემდეგ, რაც წებო გაშრება, მოათავსეთ კიდევ რამდენიმე წებო თაროს კიდეზე და გადაიტანეთ უჯრა პოზიციაში და გააშრეთ. დასრულების შემდეგ ჩვენ გვაქვს მტკიცე მექანიზმი, რომ გავუშვათ ჩვენი საიდუმლო უჯრა შიგნით და გარეთ.

ნაბიჯი 13: დაამატეთ მუყაო სარკის მიღმა

იმისათვის, რომ ეს ორმხრივი ფილმი უფრო სარკისებური ყოფილიყო, აღმოვაჩინე, რომ ჩვენს მიზანს კარგად ემსახურება მინის უკან მუყაოს განთავსება. გამოყენებული მუყაო არის ის, რაც მოყვება ჩარჩოს, მაგრამ შესაფერისად დაჭრილი ნებისმიერი ნაჭერი იმუშავებს. ეს ასევე არ იძლევა შუქს კამერის LED- დან, ძრავის კონტროლერისგან ან Pi- ს ჩვენებიდან სარკის მეორე მხარეს. ყველაფერი თავის ადგილას გამოიყენეთ ფანქრით, რათა მონიშნოთ კამერა მუყაოზე. შემდეგ გამოიყენეთ საპარსი მართკუთხედის გასაჭრელად, რათა კამერამ შეხედოს მის ადგილს.

ნაბიჯი 14: საბოლოო ნაწილის ჩაცმა

ბოლო რაც უნდა გააკეთოთ არის უჯრის წინა ნაწილის დადება, რომელიც ადრე იყო გამოყოფილი. გადაადგილეთ ძრავა ისე, რომ უჯრა გამომაგრდეს. შემდეგ წებოვანა წინა ნაწილი ისე, რომ უჯრის ნაჭერი იყოს ცენტრში (უნდა იყოს ცოტაოდენი ჩამოკიდებული ყველა მხრიდან. შემდეგ შეგიძლიათ უბრალოდ ჩამოკიდოთ იგი კედელზე.

ნაბიჯი 15: ფინალი

აი ეს გაქვს! არსებობს რამოდენიმე გაუმჯობესება, როგორიცაა ღილაკის დამატება, უკეთესი ორმხრივი ფილმის ყიდვა და კოდში ამ ხარვეზის გამოსწორება, მაგრამ მთლიანობაში, ეს საქმეს ასრულებს: ის სარკეს ჰგავს, ის ცნობს წინასწარ განსაზღვრულს მომხმარებლის სახე და ის ხსნის იმ მიმზიდველ პატარა უჯრას. როგორც ყოველთვის, სიამოვნებით მოვისმენდი თქვენს აზრებს, კითხვებს და მოგონებებს ქვემოთ მოცემულ კომენტარებში.

საერთო რეიტინგი: 10/10

კომენტარები: #არ შევეცდები ისევ … თუკი არ შევასრულებ ამ ინსტრუქციას;)

დიდი პრიზი საიდუმლო განყოფილების გამოწვევაში