Pimp My Cam: 14 Hakbang (na may Mga Larawan)

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:15

Narito kung saan nagmula ang proyektong ito.

Ilang sandali pa ay naisip ko ang tungkol sa pagkuha ng ilang mga timelapses. "Paano?" Tinanong ko ang sarili ko? Ang unang sagot ay "Buweno.. may kinukunan ka lang ng pelikula at pabilisin at iyan na". Ngunit ganun ba talaga kadali? Una, nais kong gamitin ang aking DSLR para doon, at ang aking Nikon D3100 ay may 10min na limitasyon sa oras para sa video ng video. Pangalawa, kahit na mayroon akong isang camera na walang limitasyon sa oras sa pagkuha ng video ng video, paano kung nais kong gumawa ng isang mahabang haba ng timelaps, tulad ng 12 oras ang haba? Gumagawa ako ng 12 oras na haba ng video na 1080p. Duda ako na ang baterya ay magtatagal ng ganoong katagal at, hindi ito masyadong praktikal, hindi ba? O sige, tumatawid sa "ideya ng video ng pagsasine". Kaya, pagkatapos ay may mga larawan. Ang pagkuha ng isang larawan sa camera sa isang tiyak na agwat at nagtatapos sa daan-daang mga imahe na kaysa sa proseso sa pamamagitan ng software upang makagawa ng isang video..?

Parang isang okay na ideya kaya't napagpasyahan kong bigyan ito ng shot. Kaya't natapos ako sa kagustuhan na gumawa ng isang aparato kung saan maaari kong mai-input ang isang tagal ng panahon, at batay sa panahong iyon ay patuloy itong magpapalitaw sa aking camera. At habang nasa amin ito, bakit hindi magdagdag ng iba pang mga bagay tulad ng paggalaw-galaw at iba pa?

Hakbang 1: Ngunit.. Paano?

PAANO ay ang aming susunod na tanong na nawawala ang isang sagot. Dahil sa tiyempo, pag-trigger, sensor at mga ganoong bagay hindi na sorpresa na ang una na naisip ko, syempre, isang Arduino. O sige, ngunit gayon pa man, kailangan naming malaman kung paano ma-trigger ang shutter sa aming camera. Hm.. servo hot nakadikit sa body camera? Hindi talaga, nais naming manahimik ito at mabisa. Mahusay na kuryente - bakit? Dahil nais kong gawin itong portable at mag-stick ng baterya dito, hindi ako malapit sa isang plug ng kuryente tuwing. Kaya paano natin ito mai-trigger kung gayon.. talagang simple ito.

Alam na ni Nikon na gugustuhin mo ang isang remote at iba pang mga accessories at sinabi nila na "okay, ibibigay namin sa kanila ang lahat ng iyon, ngunit gagawa kami ng isang espesyal na port upang makagawa kami ng mas maraming pera sa mga aksesorya na iyon", kahihiyan ka Nikon. Ang port na iyon ay (sa aking kaso) na tinatawag na MC-DC2, at ang pinakamurang paraan upang makuha ang aming mga kamay ay upang bumili ng isang remote shutter release sa eBay para sa 2-3 $ at gamitin lamang ang cable.

* Ang ilang iba pang mga camera, tulad ng Canon, ay may isang simpleng 3.5mm headphone jack na ginawa para sa parehong paggamit upang maaari mong gamitin ang ilang mga cable mula sa mga lumang speaker / headphone.

Hakbang 2: Pag-aaral Kung Paano Mag-trigger ng Camera

Gayunpaman, narito ang deal, ang port ay magkakaroon ng 3 mga koneksyon na magiging interesado namin (Ground, Focus at Shutter) at magkakaroon ka ng mga iyon sa dulo ng iyong cable ng bagong biniling remote shutter na nasira mo lang. Ang tatlong mga koneksyon na iyon ay mahalaga sa amin dahil kung maiikli namin ang Ground at Ituon ang camera ay tumututok tulad ng pagpindot mo sa pindutan ng pokus at pagkatapos, habang nananatili ang koneksyon na iyon, maaari mong paikliin ang Ground at Shutter at kukuha ng larawan ang camera tulad ng kung pinindot mo ang shutter button sa camera.

Maaari mong subukan ito sa pamamagitan ng literal na pagpapaikli ng mga live na wires sa dulo ng cable upang makilala kung aling kawad ang alin. Kapag nagawa mo na iyan, alang-alang sa mas madaling pagkilala, kulayan namin sila:

Ground = BLACK; Tumuon = PUTI; Shutter = PULA.

Okay, ngayon kailangan nating turuan ang Arduino na gawin ito para sa atin.

Hakbang 3: Mga paraan upang Mag-trigger

Ang pinakasimpleng bagay na maaari nating sabihin sa isang Arduino na ipadala sa panlabas na mundo ay ang digital output signal. Ang senyas na ito ay maaaring maging TAAS (lohikal na '1') o LOW (lohikal na '0'), samakatuwid ang pangalang "digital", o kapag na-convert sa pangunahing kahulugan nito: 5V para sa isang lohikal na TAAS, at 0V para sa isang lohikal na LOW.

Ano ang gagawin natin sa mga digital signal na ito? Hindi namin simpleng makakonekta ang mga ito sa camera at asahan na malalaman ng camera kung ano ang gusto namin. Tulad ng nakita natin, kailangan nating paikliin ang mga koneksyon sa camera upang makapag-reaksyon ito, kaya kailangan naming gamitin ang mga digital signal ng Arduino upang himukin ang ilang mga bahagi na maaaring maikli ang kanilang mga terminal depende sa mga signal ng elektrikal na ipinapadala namin ito. * Sa paraang inilarawan ko ito, maaaring iniisip mo ang "Ah, Relay!" pero hindi hindi. Gagawa ng relay ang trabaho ngunit nakikipag-usap kami sa mga maliliit na alon na madali naming magagamit ang itim na mahika ng mga semiconductor.

Ang unang sangkap na susubukan ko ay isang optocoupler. Nakita ko na ipinatupad nila ang pinaka para dito at marahil ito ang pinakamahusay na solusyon. Ang Optocoupler ay isang de-koryenteng sangkap kung saan kinokontrol mo ang output circuit habang ang input circuit ay ganap na ihiwalay mula rito. Nakamit ito sa pamamagitan ng paglilipat ng impormasyon sa pamamagitan ng ilaw, ang pag-input ng circuit ay nagpapasindi ng isang LED, at ang phototransistor sa mga switch ng output nang naaayon.

Kaya gagamitin namin ang optocoupler sa ganitong paraan: sasabihin namin sa aming Arduino na magpadala ng isang digital TAAS sa isa kung ito ay mga digital na pin, ang senyas na iyon ay halos 5V na magdadala sa LED sa loob ng optocoupler at ang phototransistor sa loob nito ay "maikli" ito ay mga terminal ng output kapag nakita nito ang ilaw na iyon, at kabaligtaran, "tatanggalin" nito ang mga terminal dahil walang ilaw mula sa LED kapag nagpapadala kami ng isang digital na LOW sa pamamagitan ng Arduino.

Sa praktikal, nangangahulugan ito: ang isa sa mga digital na pin ng Arduino ay nakakabit sa ANODE pin ng optocoupler, ang GND ng Arduino ay nakakabit sa CATHODE, ang GND ng kamera ay nakakabit sa EMITTER at FOCUS (o SHUTTER) sa COLLECTOR. Sumangguni sa sheet ng data ng optocoupler na ginagamit mo upang hanapin ang mga pin na ito sa iyo. Gumagamit ako ng 4N35 upang maaari mong sundin ang aking eskematiko nang walang taros kung hindi mo talaga alintana ang nangyayari sa loob ng optocoupler. Hindi na kailangang sabihin, kakailanganin namin ang dalawa sa mga ito, dahil kailangan naming kontrolin ang parehong FOCUS at SHUTTER ng parehong camera.

Dahil nakita namin kung paano ito gumagana, na may isang phototransistor sa output, bakit hindi namin ito subukan lamang sa isang simpleng transistor ng NPN. Sa oras na ito, direkta naming dadalhin ang digital signal (sa isang risistor) sa base ng transistor at ikonekta ang parehong camera at GND ng Arduino sa emitter at pokus / shutter ng camera sa kolektor ng transistor.

Muli, kakailanganin namin ang dalawa sa mga ito dahil kinokontrol namin ang dalawang signal. Gumagamit ako ng BC547B at maaari mo talagang gamitin ang anumang NPN para dito dahil ang kasalukuyang kinokontrol namin ay isang solong milliamp.

Parehong gagana ang mga bahagi na ito, ngunit ang pagpili ng optocoupler ay marahil ang mas mahusay na ideya dahil mas ligtas ito. Piliin lamang ang mga transistor kung alam mo kung ano ang iyong ginagawa.

Hakbang 4: Pagsulat ng Code para sa Pag-trigger

Tulad ng sinabi namin dati, gagamitin namin ang mga digital na pin ng Arduino para sa pagbibigay ng senyas. Maaaring gamitin ng Arduino ang pareho para sa pagbasa ng data mula rito, o pagsulat dito kaya ang unang bagay na kailangan naming gawin ay tukuyin sa pag-andar ng () pag-andar na gagamitin namin ang dalawa sa mga digital pin ng Arduino para sa output na tulad nito:

pinMode (FOCUS_PIN, OUTPUT);

pinMode (SHUTTER_PIN, OUTPUT);

kung saan ang FOCUS_PIN at SHUTTER_PIN ay maaaring tukuyin sa "#define NAME halaga" o bilang isang int bago ang pag-set up () function dahil maaari mong baguhin ang pin kaya mas madaling baguhin ang halaga sa isang lugar lamang sa halip na ang buong code pagkatapos.

Susunod na bagay na gagawin namin ay magsulat ng isang pag-andar na () pag-andar na gagawin lamang iyon kapag ito ay pinatakbo. Isasama ko lang ang isang larawan kasama ang code. Ang kailangan mo lang malaman ay ang unang hawak namin ang FOCUS_PIN sa TAAS sa isang tiyak na tagal ng panahon dahil kailangan nating maghintay para sa camera na tumuon sa paksang itinuturo namin dito at pagkatapos ay saglit lamang (habang ang FOCUS_PIN ay HIGAS pa rin) ilagay ang SHUTTER_PIN sa Taas upang makunan ng larawan.

Isinama ko rin ang kakayahang laktawan ang pagtuon dahil hindi na kakailanganin ito kung kinukunan namin ang isang timelapse ng isang bagay na hindi binabago ang distansya nito mula sa camera sa pamamagitan ng oras.

Hakbang 5: Class Interval {};

Ngayon na napalitaw namin ang camera sa paraang kailangan namin upang gawin ito sa isang intervalometer sa pamamagitan ng pagdaragdag ng pag-andar ng pagmamanipula ng tagal ng panahon sa pagitan ng dalawang mga pag-shot. Upang makuha mo ang larawan ng ginagawa namin narito ang ilang sinaunang code upang maipakita ang pag-andar na nais namin:

void loop () {

antala (agwat); gatilyo (); }

Nais kong mabago ang agwat na ito mula sa, sabihin nating, 5 segundo hanggang sa marahil 20-30minutes. At narito ang problema, kung nais kong baguhin ito mula 5s hanggang 16s o anumang bagay sa pagitan ay gagamit ako ng 1s increment, kung saan para sa bawat isa sa aking hiling na dagdagan ang agwat, ang agwat ay tataas para sa 1s. Mahusay iyon, ngunit paano kung nais kong pumunta mula 5s hanggang 5min? Dadalhin ako sa akin ng 295 na mga kahilingan sa mga dagdag na 1 kaya't malinaw na kailangan kong taasan ang halaga ng pagtaas sa isang bagay na mas malaki, at kailangan kong tukuyin kung aling eksaktong halaga ng agwat (threshold) upang baguhin ang pagtaas. Ipinatupad ko ito:

5s-60s: 1s increment; 60s-300s: 10s increment; 300s-3600s: 60s increment;

ngunit isinulat ko ang klase na ito upang maging naaayos upang maaari mong tukuyin ang iyong sariling mga threshold at palugit (ang lahat ay nagkomento sa.h file upang malaman mo kung saan babaguhin kung aling mga halaga).

Ang halimbawang ibinigay ko sa pagmamanipula ng agwat ay malinaw na tapos sa isang PC, ngayon kailangan naming ilipat ito sa Arduino. Ang buong klase na ito, Interval, ay inilalagay sa loob ng isang header file na ginagamit upang mag-imbak ng mga deklarasyon at kahulugan (hindi talaga, ngunit magagawa ito sa halimbawang ito nang hindi gumagawa ng anumang pinsala) ng aming klase / pagpapaandar. Upang ipakilala ang header file na ito sa aming arduino code ginagamit namin ang "#include" Interval.h "" (ang mga file ay dapat na nasa parehong direktoryo), na tinitiyak na maaari naming magamit ang mga pagpapaandar na tinukoy sa header file sa aming pangunahing code.

Hakbang 6: Pagmanipula ng Pagitan sa Pamamagitan ng Arduino

Ngayon nais naming mabago ang halaga ng agwat, alinman sa taasan o bawasan ito. Kaya't iyan ang dalawang bagay kaya gagamit kami ng dalawang digital signal na makokontrol ng dalawang mga pindutan. Paulit-ulit naming babasahin ang mga halaga sa mga digital na pin na itinalaga namin sa mga pindutan at i-parse ang mga halagang iyon sa check check ng Mga Button (int, int); na magpapataas ng agwat kung ang pindutang "pataas" ay pinindot at bawasan ang agwat kung ang pindutan ay "pababa". Gayundin, kung ang parehong mga pindutan ay pinindot ibabago nito ang halaga ng variable na pokus na kumokontrol kung tumutok o hindi kapag nagti-trigger.

Ang bahagi ng code ((millis () - prevBtnPress)> = debounceTime) ay ginagamit para sa pag-debit. Ang paraan ng pagsulat ko nito, nangangahulugan ito na pinarehistro ko ang unang pindutin ang pindutan gamit ang boolean variable btnPressed at naaalala ang oras na nangyari ito. Kaysa maghintay ako para sa isang tiyak na dami ng oras (debounceTime) at kung ang pindutan ay pinindot pa rin gumanti ako. Gumagawa din ito ng isang "pause" sa pagitan ng bawat iba pang pagpindot sa pindutan upang maiwasan nito ang maraming pagpindot kung saan wala.

At sa wakas, kasama ang:

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

prevTrigger = millis (); gatilyo (); }

una naming suriin kung ang dami ng oras sa pagitan ng huling nagti-trigger (prevTrigger) at ng kasalukuyang oras (millis ()) (ang lahat ay nahahati sa isang 1000 sapagkat nasa milliseconds at ang agwat ay nasa segundo) ay katumbas o mas malaki kaysa sa agwat nais namin, at kung ito ay naaalala namin ang kasalukuyang oras bilang huling oras na na-trigger namin ang camera at pagkatapos ay na-trigger ito.

Sa kumpletong ito, karaniwang gumawa kami ng isang intervalometer, ngunit malayo kami sa higit. Hindi pa rin namin nakikita ang halaga ng intervalometer. Ipinapakita lamang ito sa Serial Monitor at hindi kami malapit sa isang computer palagi kaya't magpapatupad kami ngayon ng isang bagay na magpapakita sa amin ng agwat habang binabago namin ito.

Hakbang 7: Pagpapakita ng Agwat

Dito namin ipinakikilala ang display. Ginamit ko ang 4 na digit na module na hinihimok ng TM1637 dahil kailangan ko lamang itong gamitin para sa pagpapakita ng oras at wala nang iba pa. Ang pinakamadaling paraan upang magamit ang mga modyul na ito na ginawa para sa isang Arduino ay ang paggamit ng mga ginawang aklatan para sa kanila. Sa site ng Arduino mayroong isang pahina na naglalarawan sa chip ng TM1673 at isang link sa isang iminungkahing library. Na-download ko ang silid-aklatan na ito at mayroong dalawang paraan upang maipakilala mo ang mga aklatang ito sa Arduino IDE:

1. mula sa Arduino software pumunta sa Sketch> Isama ang Library> Magdagdag ng. ZIP library at hanapin ang.zip file na na-download mo lamang
2. magagawa mo kung ano ang manu-mano na ginagawa ng Arduino at i-unzip lamang ang library sa folder kung saan nag-iimbak ang Arduino ng mga aklatan, sa Windows: C: / Users / Username / Documents / Arduino / libraries \.

Sa sandaling isinama mo ang silid-aklatan dapat mong basahin ang file na "ReadMe" kung saan makikita mo ang buod ng ginagawa ng iba't ibang mga pag-andar. Minsan hindi ito sapat kaya gugustuhin mong lumalim nang kaunti at tuklasin ang mga file ng header kung saan maaari mong makita kung paano ipinatupad ang mga pagpapaandar at kung ano ang kinakailangan nila bilang mga input ng argument. At syempre ang pinakamahusay na paraan upang makaramdam ng kung ano ang may kakayahan sa isang silid-aklatan na karaniwang nag-aalok ng isang halimbawa na maaari mong patakbuhin mula sa Arduino software sa pamamagitan ng File> Mga Halimbawa> LibraryName> HalimbawaName. Nag-aalok ang library na ito ng isang halimbawa kung saan inirerekumenda kong patakbuhin mo ang iyong display upang makita lamang kung gumagana nang maayos ang iyong display at hinihikayat ko kang i-tweak ang code na nakikita mo sa halimbawa at makita para sa iyong sarili kung ano ang ginagawa ng bawat pagpapaandar at kung ano ang reaksyon ng display ito Nagawa ko ito at ito ang nalaman ko:

gumagamit ito ng 4 na unsigned integer na 8 bits para sa bawat digit (0bB7, B6, B5, B4, B3, B2, B1, B0). At ang bawat isa sa mga piraso na B6-B0 ay ginagamit para sa bawat segment ng isang tiyak na digit at kung ang kaunti ay 1 ang segment na kinokontrol nito ay nag-iilaw. Ang mga integer na ito ay nakaimbak sa isang array na tinatawag na data . Ang pagtatakda ng mga piraso sa display ay magagawa ng display.setSegments (data); o maaari mong natural na ma-access ang anuman sa mga digit na partikular at itakda ang mga ito nang manu-mano (data [0] = 0b01111001) o maaari mong gamitin ang function na encodeDigit (int); at i-convert ang digit na ipadala mo ito sa mga naaayon na piraso (data [0] = display.encodeDigit (3));. Ang Bit B7 ay ginagamit lamang ng pangalawang digit, o data [1], para sa pag-aktibo ng colon.

Dahil isinulat ko ang mga pag-andar sa pang-klase na bruha ng INTERVAL kung saan makakakuha ako ng ilang mga digit ng agwat sa anyo ng M1M0: S1S0, kung saan ang M ay nakatayo nang minuto at S para sa mga segundo, natural na gamitin ko ang encodeDigitFunction (int); para sa pagpapakita ng agwat tulad nito:

displayInterval () {

data [0] = display.encodeDigit (interval.getM1 ()); data [1] = 0x80 | display.encodeDigit (interval.getM0 ()); data [2] = display.encodeDigit (interval.getS1 ()); data [3] = display.encodeDigit (interval.getS0 ()); display.setSegments (data); }

Ngayon, anumang oras na kailangan kong ipakita ang Interval papunta sa display, maaari kong tawagan ang displayInterval () na function.

* Tandaan ang "0x80 |…" sa data [1]. Ginagamit ito upang matiyak na ang bit B7 ng data [1] ay palaging 1 kaya't nag-iilaw ang colon.

Huling bagay tungkol sa display, pagkonsumo ng kuryente. Maaaring hindi ito napakahalaga dahil hindi namin ito panatilihin sa loob ng mahabang panahon, ngunit kung interesado kang gawin itong mas friendly na baterya pagkatapos ay isaalang-alang ang pagbaba ng ningning ng display dahil nakakakuha ito ng 3 beses na mas kasalukuyang sa maximum na ningning kaysa sa pinakamababa.

Hakbang 8: Pagsasama-sama sa Lahat ng Ito

Alam namin kung paano i-trigger ang camera, kung paano manipulahin ang agwat at kung paano ipakita ang parehong agwat sa isang display. Ngayon ay kailangan lang nating pagsamahin ang lahat ng mga bagay na ito. Magsisimula kami, syempre, mula sa pag-andar ng loop (). Patuloy naming susuriin ang mga pagpindot sa pindutan at tumutugon nang naaayon sa mga check Buttons (int, int) at palitan ang agwat nang naaayon at ipakita ang nabagong agwat. Gayundin sa loop () patuloy kaming susuriin kung ang sapat na oras ay lumipas mula sa huling pag-trigger o pindutin ang pindutan at tawagan ang function na () pag-trigger kung kinakailangan. Alang-alang sa mas mababang paggamit ng kuryente ay papatayin namin ang display pagkatapos ng ilang oras.

Nagdagdag ako ng isang bi-color led, (Pula at berde, karaniwang cathode) na kung saan ay ilaw up berde habang ang gatilyo () at ito ay ilaw up pula kasama ang display kung ang pagtuon ay nasa at ito ay manatili kung ang pagtuon ay off

Gayundin, lilipat kami sa isang mas maliit na Arduino, Pro Mini.

Hakbang 9: Pagdaragdag ng Isang Huling Bagay

Sa ngayon.. lumikha lang kami ng isang Intervalometer. Kapaki-pakinabang, ngunit mas magagawa natin ang mas mahusay.

Narito kung ano ang nasa isip ko: ginagawa ng Intervalometer ito ng isang bagay sa pamamagitan ng default MALIBAN kapag nag-attach kami ng ilang uri ng panlabas na switch / sensor na pagkatapos ay ititigil ang intervalometer at tumutugon sa pag-input ng switch / sensor. Tawagin natin itong isang sensor, kinakailangang maging isang sensor na konektado ngunit tatawagin ko ito bilang iyon.

Una, paano namin matutukoy na naka-attach namin ang sensor?

Ang mga sensor na gagamitin / gagawin namin ay kailangan ng lahat ng mga wires na kumukonekta sa kanila sa arduino (Vcc, GND, Signal). Nangangahulugan iyon na maaari naming gamitin ang isang 3.5mm audio jack bilang isang input jack para sa sensor. At paano nito malulutas ang ating problema? Sa gayon, may mga uri ng isang 3.5mm jack na "may isang switch" na may mga pin na naikli sa mga pin ng konektor kung walang mga lalaki na konektor sa kanila, at sila ay makahiwalay kapag mayroong isang konektor na naroroon. Nangangahulugan iyon na mayroon kaming impormasyon batay sa pagkakaroon ng sensor. Gagamitin ko ang pull-down risistor tulad ng ipinapakita (ang digital pin ay basahin ang TAAS nang walang sensor, at LOW na may naka-attach na sensor) sa imahe o maaari mo ring ilakip sa digital pin sa pin ng konektor na karaniwang konektado sa lupa at tukuyin ang digital pin bilang INPUT_PULLUP, gagana ito sa alinman sa paraan. Kaya ngayon kailangan nating i-tweak ang aming code kaya't ginagawa ang lahat ng nasulat namin sa ngayon lamang kung wala ang sensor, o kapag ang pag-check ng digital pin na TAAS. Ni-tweak ko din ito kaya ipinapakita nito ang "SENS" sa display sa halip na ang agwat na walang silbi sa mode na ito, ngunit ang pagtuon ay nauugnay pa rin sa amin ay panatilihin namin ang pagpapaandar ng alternating ang pagtuon sa pagpindot sa parehong pindutan at ipinapakita ang pokus estado sa pamamagitan ng pulang humantong.

Ano talaga ang ginagawa ng sensor?

Ang kailangan lang gawin ay ilagay ang 5V sa ito ng Signal pin kapag nais naming ma-trigger ang camera. Nangangahulugan iyon na kakailanganin namin ng isa pang digital pin ng Arduino na suriin ang estado ng pin na ito at kapag nagrehistro ito ng TAAS, ang kailangan lang gawin ay tawagan ang function ng () pagpapaandar at ang camera ay mag-snap ng isang larawan. Ang pinakamadaling halimbawa, at ang gagamitin namin upang subukan kung ito ay gumagana, ay isang simpleng pindutan na may isang pull-down na risistor. Ikabit ang pindutan sa pagitan ng Vcc ng sensor at ng Signal pin at magdagdag ng risistor sa pagitan ng Signal pin at GND, sa ganitong paraan ang Signal pin ay nasa GND kapag ang pindutan ay hindi pinindot dahil walang kasalukuyang dumadaloy sa pamamagitan ng risistor, at kung kailan ang pindutan ay pinindot inilagay namin ang Signal pin nang direkta sa TAAS at binabasa iyon ng Arduino at pinapalitaw ang camera.

Sa pamamagitan nito natapos namin ang pagsusulat ng code.

* Gusto kong tandaan ang ilang mga problema na mayroon ako sa mga audio jack na ginamit ko. Habang pinapasok ang male jack sa konektor, ang GND at alinman sa isa sa iba pang dalawang mga pin ay paminsan-minsan ay maikli. Agad itong nangyayari at habang inilalagay lamang ang konektor, ngunit sapat pa rin ito para sa Arduino upang magparehistro ng isang maikli upang ang Arduino ay muling magsimula muli. Hindi ito nangyayari nang madalas ngunit maaari pa ring maging isang panganib at may potensyal na sirain ang Arduino kaya iwasan ang mga konektor na ginamit ko.

Hakbang 10: Naglalaman ng Gulo

Maaari mong makita mula sa mga imahe na ang tinapay sa tinapay ay nagiging magulo at tapos na kami kaya kailangan naming ilipat ang lahat sa isang perfboard / PCB. Nagpunta ako para sa PCB dahil sa palagay ko ay gagawin ko ang higit sa mga ito upang sa ganitong paraan madali ko silang kopyahin.

Ginamit ko ang Eagle para sa pagdidisenyo ng PCB at nakahanap ng mga disenyo para sa lahat ng mga bahagi na ginamit ko. Mayroong isang maliit na bagay sa aking disenyo na nais kong hindi ko nagawa at iyon ay isang wire pad para sa Vcc ng display. Nakita ko na ito huli na at ayokong sirain kung ano ang dati kong dinisenyo at napunta sa tamad na paraan ng pagdaragdag ng mga wire pad at kalaunan ay kailangang magdagdag ng kawad sa mga koneksyon na ito sa halip na mga bakas ng tanso kaya't tandaan na kung gumagamit ka ng disenyo ng minahan.

Ang Arduino Board at ang display ay konektado sa PCB sa pamamagitan ng mga header na pin ng babae kaysa sa direktang na-solder sa PCB, para sa maliwanag na mga kadahilanan. Sa ganitong paraan maraming puwang para sa iba pang mga bahagi sa ilalim ng display para sa iba pang mga bahagi tulad ng resistors, transistors at kahit na ang audio jack.

Inilagay ko ang mga micro push button na, sa pamamagitan ng disenyo, dapat na soldered nang direkta ngunit maaari mo ring gamitin ang mga butas para sa mga babaeng pin header at ikonekta ang mga pindutan na may kawad kung nais mong mai-mount ang mga ito sa enclosure at hindi sa PCB.

Maglalagay din kami ng isa pang babaeng audio jack upang mai-plug sa cable na kumokonekta sa camera. Sa ganitong paraan ang board ay magiging mas maraming nalalaman dahil sa ganoong paraan makakonekta kami sa iba pang mga camera sa iba pang mga konektor.

Hakbang 11: Sens0rs

Isaalang-alang natin ang mga paraan upang maipatupad ang sensor.

Kaya't ang sensor ay magkakaroon ng supply boltahe ng 5V, at kakailanganin na makapagbigay ng isang digital na TAAS sa signal pin nito kapag nais naming ma-trigger ang camera. Ang unang bagay na naisip ko ay isang sensor ng paggalaw, PIR upang maging tiyak. Mayroong mga module na ipinagbibili para sa Arduino na mayroong sensor na ito sa kanila at ginagawa lamang ang nais namin. Ang mga ito ay pinalakas sa 5V at mayroong isang output pin kung saan inilalagay nila ang 5V kapag na-trigger sila, kailangan lamang naming ikonekta ang mga pin nito sa isang 3.5mm audio jack at maaari kaming mai-plug pakanan sa board. Ang isang bagay na dapat tandaan ay ang sensor na ito na kailangan ng oras upang magpainit at magsimulang magtrabaho nang maayos kaya huwag asahan na gagana ito ng maayos sa sandaling na-plug mo ito, bigyan ito ng ilang oras at pagkatapos ay i-set up ito at kung anong buhay ang lumalakad dito ang saklaw ang magpapalitaw sa camera.

Dahil iniisip namin ang direksyon ng nagawa na ang Arduino sensor boards ay isa pa ang naisip, tunog. Ang mga board na ito ay karaniwang ginagawa sa paraang mayroon silang isang pin na naglalabas ng analog na halaga ng tunog na kinukuha nito at isa pa, isang digital, na naglalabas ng isang lohikal na TAAS kung ang tunog na kinukuha nito ay tumatawid sa isang tiyak na antas. Maaari naming itakda ang antas na ito na hindi pinapansin ng sensor ang aming boses ngunit nagrerehistro ng isang palakpak. Sa ganoong paraan, anumang oras na pumalakpak ka, na-trigger mo ang camera.

Hakbang 12: PoweeEeEer

Sa palagay ko ang pinakamadaling paraan upang mapagana ang bagay na ito ay sa isang power bank, at hindi sa panlabas. Panatilihin namin ang pagpapaandar ng singilin ang aming telepono o anupaman at makontrol ang kasalukuyang daloy sa board sa pamamagitan ng isang switch. Mahahanap namin ang mga pin ng konektor ng output USB sa circuit board sa power bank na kung saan ay GND at Vcc (5V) at mga wire ng Solder na direkta papunta sa kanila at mula doon sa aming board.

Hakbang 13: Enclosure.. Kinda

Pinaghirapan ko talaga ito. Nang malagay ko ang kahon na nais kong ilagay ang mayroon nang PCB, napagtanto ko na walang magandang paraan upang magkasya ang lahat ayon sa gusto ko at pagkatapos ay nagpasya akong mag-disenyo ng isang bagong PCB, sa oras na ito sa mga optocoupler. Nais kong ilagay ang PCB sa kanan sa ilalim ng gilid kung saan mag-drill ako ng mga butas para sa ilang mga bahagi na kailangang makita / hawakan. Upang gumana ito kakailanganin kong maghinang ng display at Arduino nang direkta sa board, nang walang mga socket o header, at doon namamalagi ang unang problema. Ito ay ganap na kakila-kilabot na i-troubleshoot ang anumang bagay dahil hindi ako handa na maghinang ito kaagad hanggang sa masubukan ko na ang lahat ay gumagana, at hindi ko talaga masubukan ang anumang bagay dahil hindi ko ito ma-solder at iba pa.. don huwag gawin ito Problema numero dos, paggawa ng mga butas sa kaso. Mali yata ang aking mga pagsukat dahil wala sa mga butas sa kaso ang nakahanay sa mga bahagi sa PCB at kailangan kong palakihin ang mga ito at ang mga pindutan ay masyadong mataas sa PCB at palagi silang mapipindot kapag inilagay ko ang board sa lugar. aaand dahil gusto ko ang mga audio jack sa gilid, kailangan kong palakihin ang mga butas na iyon upang magkasya muna ang mga jack at pagkatapos ay ibaba ang board para sa display at mga pindutan na dumaan.. ang kahihinatnan ay kahila-hilakbot.

Medyo ginawa kong hindi gaanong kahila-hilakbot ang mga kahila-hilakbot na butas sa pamamagitan ng pag-overlay sa tuktok ng ilang manipis na karton kung saan pinutol ko ang mas makatuwirang mga butas para sa mga sangkap at.. kahila-hilakbot pa rin ngunit mas madali sa mata sa palagay ko.

Hatol, iminumungkahi kong gawin mo ito sa pamamagitan ng pagbili ng mga sangkap na naka-mount sa enclosure, at hindi direkta papunta sa PCB. Sa ganoong paraan mayroon kang higit na kalayaan sa paglalagay ng mga bahagi at mas kaunting mga lugar upang magkamali.

Hakbang 14: Fin

Tapos na ako, ngunit narito ang ilang bagay na gagawin ko sana nang iba:

Gumamit ng mas mahusay na kalidad na 3.5mm audio jacks. Ang mga ginamit ko ay may posibilidad na paikliin ang mga terminal habang pinapasok o hinihila ang jack na nagreresulta sa alinman sa pagpapaikli ng supply sa gayon muling pag-set sa Arduino o gumagawa lamang ito ng pekeng mga pag-trigger. Nasabi ko ito sa nakaraang hakbang ngunit sasabihin kong muli. Huwag solder ang Arduino board nang walang mga header / socket, ginagawang mas mahirap ang anumang uri ng pag-troubleshoot o pag-upload ng bagong code at iba pa. Sa palagay ko rin na ang pagkakaroon ng isang humantong pagbibigay ng senyas na ang bagay ay nasa ay magiging kapaki-pakinabang dahil madalas kong hindi masabi nang hindi pinipilit ang pindutan dahil ang display ay naka-off. At ang huling bagay, isang pagpapaandar na pag-andar. Naiisip ko na kapaki-pakinabang ito kapag halimbawa kapag isinaksak ang sensor ng PIR kaya't kailangan ng oras upang magpainit, o kapag inililipat mo ito ay hindi mo nais na mag-trigger upang mapahinto mo lang ang lahat, ngunit maaari mo ring simpleng i-on off the camera so.. whatever.

Ang isa pang maayos na bagay ay ang Velcro ito sa tripod dahil malamang na ito ay magamit doon.

Huwag mag-atubiling magtanong ng anuman tungkol sa proyektong ito sa mga komento at nais kong malaman kung binubuo mo ito at kung paano ito naging para sa iyo.