Pimp My Cam: 14 ნაბიჯი (სურათებით)

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

აი საიდან მოდის ეს პროექტი.

ცოტა ხნის წინ ვფიქრობდი გარკვეული დროის გადაღებების გადაღებაზე. "Როგორ?" ჩემს თავს ვკითხე? პირველი პასუხი იყო "კარგი.. შენ უბრალოდ გადაიღე რამე და დააჩქარე და ეს არის". მაგრამ მართლა ასე მარტივია? პირველ რიგში, მე მინდა გამოვიყენო ჩემი DSLR ამისათვის და ჩემს Nikon D3100– ს აქვს 10 წუთიანი შეზღუდვა ვიდეოს გადაღებისთვის. მეორე, მაშინაც კი, თუ მე მქონდა კამერა ვიდეოს გადაღების დროის ლიმიტით, რა მოხდება, თუ მსურს მართლაც გრძელი დროის გასვლა, როგორც 12 საათიანი? მე ვიღებ 12 საათის განმავლობაში 1080p ვიდეოს. ეჭვი მეპარება, რომ ბატარეა ასე დიდხანს გაგრძელდეს და, ეს არ არის ძალიან პრაქტიკული, არა? კარგი, გადაკვეთა "ვიდეო იდეის გადაღება". კარგი, მაშინ არის სურათები. კამერაზე ფოტოს გადაღება გარკვეული ინტერვალით და ასობით სურათის დამთავრება, რომელსაც პროგრამული უზრუნველყოფის საშუალებით ვამუშავებ ვიდეოს გადასაღებად..?

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

ნაბიჯი 1: მაგრამ.. როგორ?

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

ნიკონმა უკვე იცოდა, რომ თქვენ გინდათ დისტანციური და სხვა აქსესუარები და მათ თქვეს "კარგი, ჩვენ ყველაფერს მივცემთ მათ, მაგრამ ჩვენ გავაკეთებთ სპეციალურ პორტს, რათა ჩვენ შევძლოთ მეტი ფულის გამომუშავება იმ აქსესუარებზე", სირცხვილია შენ ნიკონ რა ამ პორტს (ჩემს შემთხვევაში) ჰქვია MC-DC2 და ყველაზე იაფად ჩვენს ხელში ჩაგდება არის eBay– ზე დისტანციური ჩამკეტის ყიდვა 2-3 დოლარად და უბრალოდ კაბელის გამოყენება.

*ზოგიერთ სხვა კამერას, როგორიცაა Canon, აქვს მარტივი 3.5 მმ ყურსასმენის ჯეკი, რომელიც დამზადებულია იმავე გამოყენებისთვის, ასე რომ თქვენ შეგიძლიათ გამოიყენოთ კაბელი ძველი დინამიკებიდან/ყურსასმენებიდან.

ნაბიჯი 2: ისწავლეთ როგორ დაიწყოთ კამერა

ყოველ შემთხვევაში, აქ არის გარიგება, პორტს ექნება 3 კავშირი, რომელიც იქნება ჩვენი ინტერესი (Ground, Focus და Shutter) და თქვენ გექნებათ ის, რაც თქვენს ახლად ნაყიდი დისტანციური საკეტის კაბელის ბოლოშია, რომელიც თქვენ უბრალოდ გაანადგურეთ. ეს სამი კავშირი ჩვენთვის მნიშვნელოვანია, რადგან თუ ჩვენ შევამცირებთ Ground- ს და Focus- ს, კამერა ფოკუსირდება ისევე, როგორც თქვენ დააჭირეთ ფოკუსირების ღილაკს და შემდეგ, სანამ ეს კავშირი რჩება, შეგიძლიათ შეამციროთ Ground და Shutter და კამერა გადაიღებს სურათს ისევე, როგორც კამერის ჩამკეტის ღილაკს.

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

გრუნტი = შავი; ფოკუსი = თეთრი; ჩამკეტი = წითელი.

კარგი, ახლა ჩვენ უნდა ვასწავლოთ არდუინოს ამის გაკეთება ჩვენთვის.

ნაბიჯი 3: გააქტიურების გზები

უმარტივესი რამ რისი თქმაც შეგვიძლია არდუინოს გარე სამყაროში არის ციფრული გამომავალი სიგნალი. ეს სიგნალი შეიძლება იყოს მაღალი (ლოგიკური '1') ან დაბალი (ლოგიკური '0'), აქედან გამომდინარე, სახელი "ციფრული", ან მისი ძირითადი მნიშვნელობის გარდაქმნისას: 5V ლოგიკური მაღალი და 0V ლოგიკური დაბალი.

რა ვუყოთ ამ ციფრულ სიგნალებს? ჩვენ არ შეგვიძლია უბრალოდ დავუკავშიროთ ისინი კამერას და ველოდოთ, რომ კამერამ იცის რა გვინდა. როგორც ვნახეთ, ჩვენ უნდა შევამციროთ კავშირები კამერაზე, რათა მან მოახდინოს რეაგირება, ამიტომ ჩვენ უნდა გამოვიყენოთ Arduino– ს ციფრული სიგნალები ზოგიერთი კომპონენტის გადასაყვანად, რომელსაც შეუძლია მათი ტერმინალების შემცირება ამ ელექტრული სიგნალის მიხედვით. რა *როგორც მე აღვწერე, თქვენ ალბათ ფიქრობთ "აჰ, რელეები!" მაგრამ არა არა სარელეო საქმეს გააკეთებდა, მაგრამ ჩვენ საქმე გვაქვს ისეთ მცირე დენებთან, რომ ადვილად გამოვიყენებთ ნახევარგამტარების შავ მაგიას.

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

ამრიგად, ჩვენ ვიყენებთ ოპტოქუპერს: ჩვენ ვეუბნებით ჩვენს Arduino- ს გამოაგზავნოს ციფრული HIGH ერთზე, თუ ეს არის ციფრული ქინძისთავები, ეს სიგნალი არის პრაქტიკულად 5V, რომელიც ამოძრავებს LED- ს ოპტოქუპლერის შიგნით და მის შიგნით არსებული ფოტოტრანსისტორი იქნება "მოკლე" ეს არის გამომავალი ტერმინალები, როდესაც ის აღმოაჩენს ამ შუქს და პირიქით, ის "გამოაშკარავებს" მის ტერმინალებს, რადგან არ არის შუქდიოდური შუქდიოდური სიგნალი, როდესაც ჩვენ ვაგზავნით ციფრულ LOW- ს Arduino- ს საშუალებით.

პრაქტიკულად, ეს ნიშნავს: Arduino– ს ერთ – ერთი ციფრული ქინძისთავი მიმაგრებულია optocoupler– ის ANODE პინზე, Arduino– ს GND არის მიმაგრებული CATHODE– ზე, კამერის GND არის მიმაგრებული EMITTER– ზე და FOCUS (ან SHUTTER) კოლექტორზე. მიმართეთ ოპტოწყვილების მონაცემთა ფურცელს, რომელსაც თქვენ იყენებთ, რომ იპოვოთ ეს ქინძისთავები თქვენსზე. მე ვიყენებ 4N35- ს, ასე რომ თქვენ შეგიძლიათ ბრმად მიჰყევით ჩემს სქემატურს, თუ ნამდვილად არ გაინტერესებთ რა ხდება ოპტოოპლერის შიგნით. ზედმეტია იმის თქმა, რომ ჩვენ გვჭირდება ორი მათგანი, რადგან ჩვენ უნდა გავაკონტროლოთ როგორც კამერის ფოკუსი, ასევე ჩამკეტი.

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

კიდევ ერთხელ, ჩვენ გვჭირდება ორი მათგანი, რადგან ჩვენ ვაკონტროლებთ ორ სიგნალს. მე ვიყენებ BC547B- ს და თქვენ შეგიძლიათ გამოიყენოთ ნებისმიერი NPN ამისათვის, რადგან დენი, რომელსაც ჩვენ ვაკონტროლებთ არის ერთი მილიამპერი.

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

ნაბიჯი 4: კოდის წერა გააქტიურების მიზნით

როგორც უკვე ვთქვით, სიგნალისთვის Arduino– ს ციფრულ პინებს გამოვიყენებთ. Arduino– ს შეუძლია გამოიყენოს ეს ორივე მისგან მონაცემების წასაკითხად, ან მის დასაწერად, ასე რომ პირველი რაც ჩვენ გვჭირდება გავაკეთოთ მითითებულია setup () ფუნქციაში, რომ გამოვიყენოთ Arduino– ს ორი ციფრული ქინძისთავი გამომავალით ასე:

pinMode (FOCUS_PIN, OUTPUT);

pinMode (SHUTTER_PIN, OUTPUT);

სადაც FOCUS_PIN და SHUTTER_PIN შეიძლება განისაზღვროს "#განსაზღვრეთ NAME მნიშვნელობა" ან int როგორც setup () ფუნქციამდე, რადგან თქვენ შეგიძლიათ შეცვალოთ პინი, ასე რომ უფრო ადვილია მნიშვნელობის შეცვლა მხოლოდ ერთ ადგილზე, ვიდრე მთლიანი კოდის შემდგომ.

შემდეგი რაც ჩვენ გავაკეთებთ არის ჩაწეროთ triger () ფუნქცია, რომელიც შეასრულებს მხოლოდ ამას. მე დავამატებ სურათს კოდთან ერთად. ყველაფერი რაც თქვენ უნდა იცოდეთ არის ის, რომ ჯერ FOCUS_PIN- ს ვიღებთ HIGH- ზე გარკვეული პერიოდის განმავლობაში, რადგან უნდა დაველოდოთ კამერის ფოკუსირებას იმ საგანზე, რომელსაც ჩვენ ვაჩვენებთ და შემდეგ მხოლოდ ერთი წამით (სანამ FOCUS_PIN ჯერ კიდევ მაღალია)) განათავსეთ SHUTTER_PIN HIGH მხოლოდ სურათის გადასაღებად.

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

ნაბიჯი 5: კლასის ინტერვალი {};

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

ბათილი მარყუჟი () {

შეფერხება (ინტერვალი); გამომწვევი (); }

მინდა შემეძლოს ამ ინტერვალის შეცვლა, ვთქვათ, 5 წამიდან, ალბათ, 20-30 წუთამდე. და აქ არის პრობლემა, თუ მსურს მისი შეცვლა 5 – დან 16 – მდე ან სხვას შორის, გამოვიყენებ 1 – ის ნამატს, სადაც თითოეული ჩემი მოთხოვნისათვის ინტერვალის გაზრდა, ინტერვალი გაიზრდება 1 – ით. ეს მშვენიერია, მაგრამ რა მოხდება, თუ მსურს 5 წამიდან 5 წუთამდე წასვლა? დასჭირდება 295 მოთხოვნა, რომ 1 -ჯერ გაიზარდოს, ასე რომ მე აშკარად უნდა გავზარდო ნამატის მნიშვნელობა რაღაც უფრო დიდზე და მე უნდა განვსაზღვრო რომელი ინტერვალის ზუსტი მნიშვნელობა (ბარიერი) შეცვალოს ნამატი. ეს განვახორციელე:

5s- 60s: 1s ნამატი; 60-300-იანი წლები: 10 წმ ზრდა; 300–3600 – იანი წლები: 60 – იანი წლების ნამატი;

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

მაგალითი, რომელიც მე მოვიყვანე ინტერვალის მანიპულირებისას, აშკარად კეთდება კომპიუტერზე, ახლა ჩვენ უნდა გადავიტანოთ იგი არდუინოზე. მთელი ეს კლასი, ინტერვალი, მოთავსებულია ერთ სათაურში, რომელიც გამოიყენება დეკლარაციებისა და განმარტებების შესანახად (არა სინამდვილეში, მაგრამ ეს შეიძლება გაკეთდეს ამ მაგალითში ყოველგვარი ზიანის გარეშე) ჩვენი კლასის/ფუნქციებისათვის. ამ სათაურის ფაილის ჩვენს arduino კოდში შესასვლელად ჩვენ ვიყენებთ "#include" Interval.h "" (ფაილები უნდა იყოს ერთსა და იმავე დირექტორიაში), რაც დარწმუნებულია, რომ ჩვენ შეგვიძლია გამოვიყენოთ სათაურის ფაილში განსაზღვრული ფუნქციები ჩვენს მთავარ კოდში.

ნაბიჯი 6: ინტერვალის მანიპულირება არდუინოს საშუალებით

ახლა ჩვენ გვსურს შევძლოთ ინტერვალის მნიშვნელობის შეცვლა, მისი გაზრდა ან შემცირება. ეს არის ორი რამ, ამიტომ ჩვენ გამოვიყენებთ ორ ციფრულ სიგნალს, რომელიც კონტროლდება ორი ღილაკით. ჩვენ არაერთხელ წავიკითხავთ ციფრული ქინძისთავების მნიშვნელობებს, რომლებიც ჩვენ მივანიჭეთ ღილაკებს და გავაანალიზებთ მათ მნიშვნელობას ფუნქციის checkButtons (int, int); რომელიც გაზრდის ინტერვალს ღილაკზე "up" დაჭერისას და შემცირდება ინტერვალით თუ ღილაკი "ქვემოთ". ასევე, ორივე ღილაკზე დაჭერის შემთხვევაში ის ცვლის ცვლადი ფოკუსის მნიშვნელობას, რომელიც აკონტროლებს ფოკუსირებას თუ არა გააქტიურების დროს.

კოდის ნაწილი ((millis () - prevBtnPress)> = debounceTime) გამოიყენება დენონსირებისთვის. როგორც დავწერე, ეს იმას ნიშნავს, რომ მე ვარეგისტრირებ ღილაკის პირველ დაჭერას ლოგიკური ცვლადი btnPressed და მახსოვს ის დრო, რაც მოხდა. ვიდრე ველოდები გარკვეულ დროს (debounceTime) და თუ ღილაკი კვლავ დაჭერილია მე ვრეაგირებ. ის ასევე აკეთებს "პაუზას" ღილაკის ყოველ მეორე დაჭერას შორის, რათა თავიდან აიცილოს მრავალჯერადი დაჭერა იქ, სადაც არ არის.

და ბოლოს, თან:

if ((millis () - prevTrigger) / 1000> = interval.getVal ()) {

prevTrigger = millis (); გამომწვევი (); }

ჩვენ პირველ რიგში ვამოწმებთ, არის თუ არა დროის ხანგრძლივობა ბოლო გაშვებას (prevTrigger) და მიმდინარე დროს (millis ()) (ყველაფერი იყოფა 1000 -ზე, რადგან ის არის მილიწამებში და ინტერვალი წამებშია) ტოლია თუ მეტი ინტერვალის ჩვენ გვსურს და თუ ეს არის, ჩვენ გვახსოვს მიმდინარე დრო, როგორც უკანასკნელი დრო, როდესაც ჩვენ ჩართეთ კამერა და შემდეგ ჩავრთეთ იგი.

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

ნაბიჯი 7: ინტერვალის ჩვენება

ეს არის სადაც ჩვენ წარმოგიდგენთ ჩვენებას. მე გამოვიყენე 4 ციფრიანი მოდული, რომელსაც ამოძრავებს TM1637, რადგან ის უნდა გამოვიყენო მხოლოდ დროის ჩვენებისათვის და სხვა არაფერი. არდუინოსთვის შექმნილი ამ მოდულების გამოყენების უმარტივესი გზაა მათთვის უკვე შექმნილი ბიბლიოთეკების გამოყენება. არდუინოს საიტზე არის გვერდი, სადაც აღწერილია TM1673 ჩიპი და ბმული შემოთავაზებულ ბიბლიოთეკასთან. მე გადმოვწერე ეს ბიბლიოთეკა და არსებობს ორი გზა, რომლითაც შეგიძლიათ ეს ბიბლიოთეკები გააცნოთ Arduino IDE– ს:

1. Arduino პროგრამული უზრუნველყოფიდან გადადით ჩანახატზე> ბიბლიოთეკის ჩართვა>. ZIP ბიბლიოთეკის დამატება და იქნებიან გადმოწერილი.zip ფაილი
2. თქვენ შეგიძლიათ გააკეთოთ ის, რასაც აკეთებს Arduino ხელით და უბრალოდ გახსენით ბიბლიოთეკა იმ საქაღალდეში, რომელშიც Arduino ინახავს ბიბლიოთეკებს, Windows- ზე: C: / Users / Username / Documents / Arduino / libraries \.

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

იგი იყენებს 4 ბიუჯეტიან რიცხვს 8 ბიტიდან თითოეული ციფრისთვის (0bB7, B6, B5, B4, B3, B2, B1, B0). თითოეული B6-B0 ბიტი გამოიყენება გარკვეული ციფრის თითოეული სეგმენტისთვის და თუ ბიტი არის 1, მის მიერ კონტროლირებადი მონაკვეთი ანათებს. ეს მთელი რიცხვები ინახება მასივში, რომელსაც ეწოდება მონაცემები . ამ ბიტების ჩვენება ეკრანზე ხორციელდება display.setSegments (მონაცემები); ან შეგიძლიათ ბუნებრივად შეხვიდეთ რომელიმე ციფრზე განსაკუთრებით და დააყენოთ ისინი ხელით (მონაცემები [0] = 0b01111001) ან გამოიყენოთ ფუნქცია encodeDigit (int); და გადააკეთეთ ციფრი, რომელსაც თქვენ აგზავნით ბიტებად (მონაცემები [0] = display.encodeDigit (3)); ბიტი B7 გამოიყენება მხოლოდ მეორე ციფრით, ანუ მონაცემებით [1], მსხვილი ნაწლავის გასააქტიურებლად.

ვინაიდან მე დავწერე ფუნქციები INTERVAL კლასის ჯადოქარში, რომლის საშუალებითაც შემიძლია მივიღო ინტერვალის გარკვეული ციფრები M1M0 სახით: S1S0, სადაც M დგას წუთებში და S წამებში, ბუნებრივია, რომ ვიყენებ encodeDigitFunction (int); ინტერვალის ასე ჩვენებისთვის:

displayInterval () {

მონაცემები [0] = display.encodeDigit (ინტერვალი. getM1 ()); მონაცემები [1] = 0x80 | display.encodeDigit (ინტერვალი.getM0 ()); მონაცემები [2] = display.encodeDigit (ინტერვალი.getS1 ()); მონაცემები [3] = display.encodeDigit (ინტერვალი.getS0 ()); display.setSegments (მონაცემები); }

ახლა, ნებისმიერ დროს, როდესაც მჭირდება ინტერვალის ჩვენება ეკრანზე, შემიძლია გამოვიძახო displayInterval () ფუნქცია.

*გაითვალისწინეთ "0x80 |…" მონაცემებზე [1]. იგი გამოიყენება იმის უზრუნველსაყოფად, რომ მონაცემთა B7 [1] ყოველთვის არის 1, ასე რომ მსხვილი ნაწლავი ანათებს.

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

ნაბიჯი 8: ყველაფერს ერთად ათავსებთ

ჩვენ ვიცით როგორ გავააქტიუროთ კამერა, როგორ ვამუშავოთ ინტერვალი და როგორ გამოვავლინოთ იგივე ინტერვალი ეკრანზე. ახლა ჩვენ უბრალოდ უნდა გავაერთიანოთ ეს ყველაფერი ერთად. ჩვენ, რა თქმა უნდა, დავიწყებთ loop () ფუნქციისგან. ჩვენ მუდმივად შევამოწმებთ ღილაკების დაჭერებს და შესაბამისად ვრეაგირებთ checkButtons (int, int) და შესაბამისად ვცვლით ინტერვალს და ვაჩვენებთ შეცვლილ ინტერვალს. ასევე მარყუჟში () ჩვენ მუდმივად ვამოწმებთ, გავიდა თუ არა საკმარისი დრო ბოლო გამშვებიდან ან ღილაკზე დაჭერით და საჭიროების შემთხვევაში დარეკეთ (). დაბალი ენერგიის მოხმარების მიზნით, ჩვენ გამოვრთავთ ეკრანს გარკვეული დროის შემდეგ.

მე დავამატე ორფერიანი ლიდერი, (წითელი და მწვანე, საერთო კათოდი), რომელიც აანთებს მწვანეს, სანამ გამოიწვევს () და ის წითლად ანათებს ეკრანთან ერთად, თუ ფოკუსირება ჩართულია და ის არ დარჩება, თუ ფოკუსირება არის გამორთული

ასევე, ჩვენ მივდივართ კიდევ უფრო პატარა Arduino– ში, Pro Mini– ში.

ნაბიჯი 9: დაამატეთ ერთი ბოლო რამ

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

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

პირველ რიგში, როგორ გავარკვიოთ, რომ ჩვენ დავამატეთ სენსორი?

სენსორებს, რომლებსაც ჩვენ გამოვიყენებთ/შევქმნით, დასჭირდება სამი მავთული, რომელიც აკავშირებს მათ არდუინოსთან (Vcc, GND, Signal). ეს ნიშნავს, რომ ჩვენ შეგვიძლია გამოვიყენოთ 3.5 მმ აუდიო ბუდე, როგორც სენსორის შეყვანის ბუდე. და როგორ წყვეტს ეს ჩვენს პრობლემას? არსებობს 3.5 მმ -იანი ბუდე "გადამრთველით", რომელსაც აქვს ქინძისთავები, რომლებიც მიმაგრებულია კონექტორის ქინძისთავებამდე, თუ მათში არ არის მამრობითი კონექტორი და ისინი იშლება, როდესაც კონექტორი არსებობს. ეს ნიშნავს, რომ ჩვენ გვაქვს ინფორმაცია სენსორის არსებობის საფუძველზე. მე გამოვიყენებ ჩამოსაშლელ რეზისტორს, როგორც ნაჩვენებია (ციფრული პინი წაიკითხავს HIGH სენსორის გარეშე, და LOW სენსორთან ერთად) სურათზე ან ასევე შეგიძლიათ ციფრული პინზე მიამაგროთ კონექტორის პინზე, რომელიც ჩვეულებრივ დაკავშირებულია მიწასთან და განსაზღვრავს ციფრულ პინს, როგორც INPUT_PULLUP, ის იმუშავებს ნებისმიერ შემთხვევაში. ასე რომ, ახლა ჩვენ უნდა შეცვალოთ ჩვენი კოდი, ასე რომ ის აკეთებს ყველაფერს რაც აქამდე დავწერეთ მხოლოდ იმ შემთხვევაში, თუ სენსორი არ არის, ან როდესაც ციფრული პინი ამოწმებს, რომ არის მაღალი. მე ასევე შევცვალე ის ისე, რომ ის აჩვენებს ეკრანზე "SENS" ინტერვალის ნაცვლად, რომელიც ამ რეჟიმში უსარგებლოა, მაგრამ ფოკუსირება მაინც აქტუალურია ჩვენთვის, ჩვენ შევინარჩუნებთ ფოკუსირების მონაცვლეობის ფუნქციონირებას ორივე ღილაკის დაჭერით და აჩვენებს ფოკუსის მდგომარეობას წითელი led- ის საშუალებით.

რას აკეთებს სენსორი სინამდვილეში?

ყველაფერი რაც უნდა გავაკეთოთ არის 5V მის სიგნალის პინზე დაყენება, როდესაც ჩვენ გვინდა კამერის ჩართვა. ეს ნიშნავს, რომ ჩვენ დაგვჭირდება Arduino– ს კიდევ ერთი ციფრული პინი, რომელიც შეამოწმებს ამ პინის მდგომარეობას და როდესაც ის დარეგისტრირდება HIGH– ზე, ყველაფერი რაც მას სჭირდება არის დარეკვა გამოიწვევს () ფუნქციას და კამერა გადაიღებს სურათს. უმარტივესი მაგალითი და ის, რომელსაც ჩვენ გამოვიყენებთ იმის შესამოწმებლად, მუშაობს თუ არა, არის მარტივი ღილაკი ჩამოსაშლელი რეზისტორით. მიამაგრეთ ღილაკი სენსორის Vcc- სა და სიგნალის პინს შორის და დაამატეთ რეზისტორი სიგნალის პინსა და GND- ს შორის, ამგვარად სიგნალის პინი იქნება GND- ზე, როდესაც ღილაკს არ დააჭერთ, რადგან რეზისტორში არ გადის დენი და როდის ღილაკზე დაჭერილი ჩვენ სიგნალის პინს პირდაპირ HIGH- ზე ვათავსებთ და Arduino კითხულობს ამას და იწვევს კამერას.

ამით ჩვენ დავამთავრეთ კოდის წერა.

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

ნაბიჯი 10: შეიცავს არეულობას

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

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

Arduino დაფა და ეკრანი დაკავშირებულია PCB– თან მდედრობითი pin სათაურებით, ვიდრე აშკარად მიზეზების გამო პირდაპირ PCB– ზე არ არის შეკრული. ამრიგად, ეკრანის ქვეშ სხვა კომპონენტებისთვის არის საკმარისი სივრცე სხვა კომპონენტებისთვის, როგორიცაა რეზისტორები, ტრანზისტორები და აუდიო ჯეკიც კი.

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

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

ნაბიჯი 11: Sens0rs

განვიხილოთ სენსორის დანერგვის გზები.

ასე რომ, სენსორს ექნება მიწოდების ძაბვა 5V და მას უნდა შეეძლოს ციფრული HIGH სიგნალის პინზე მიწოდება, როდესაც ჩვენ გვინდა კამერის გააქტიურება. პირველი რაც თავში მომივიდა არის მოძრაობის სენსორი, სპეციფიკური PIR. არის მოდულები, რომლებიც იყიდება Arduino– ზე, რომლებსაც აქვთ ეს სენსორი და აკეთებენ იმას, რაც ჩვენ გვსურს. ისინი იკვებება 5V- ზე და აქვს გამომავალი პინი, რომელზედაც ისინი ირთვება 5V როდესაც ისინი გააქტიურდებიან, ჩვენ უბრალოდ უნდა დავუკავშიროთ ის ქინძისთავები 3.5 მმ აუდიო ჯეკს და შეგვიძლია პირდაპირ ჩავრთოთ დაფაზე. ერთი რამ უნდა აღინიშნოს, რომ ამ სენსორს სჭირდება დრო, რომ გაცხელდეს და სწორად დაიწყოს მუშაობა, ასე რომ ნუ ელოდებით რომ ის იმუშავებს როგორც კი შეაერთებთ, დაუთმეთ დრო და შემდეგ დააყენეთ და რაც ცოცხალი შემოდის მასში დიაპაზონი გამოიწვევს კამერას.

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

ნაბიჯი 12: PoweeEeEer

მე ვფიქრობ, რომ ამ საქმის გაძლიერების უმარტივესი გზა არის დენის ბანკი და არა გარედან. ჩვენ შევინარჩუნებთ ტელეფონის დამუხტვის ფუნქციებს ან სხვას და ვაკონტროლებთ მიმდინარე დინებას დაფაზე გადამრთველის საშუალებით. ჩვენ განვსაზღვრავთ გამომავალი USB კონექტორის ბუდეებს სქემის დაფაზე დენის ბანკში, რომლებიც არის GND და Vcc (5V) და Solder მავთულები პირდაპირ მათზე და იქიდან ჩვენს დაფაზე.

ნაბიჯი 13: დანართი.. სახის

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

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

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

ნაბიჯი 14: დაასრულეთ

მე დავამთავრე, მაგრამ აქ არის რამოდენიმე რამ, რასაც სხვანაირად გავაკეთებდი:

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

კიდევ ერთი სისუფთავე ის არის, რომ ის სამფეხაზე დააბრკოლოთ, რადგან ის სავარაუდოდ იქ იქნება გამოყენებული.

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