Pimp My Cam: 14 stappen (met afbeeldingen)

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:19

Hier komt dit project vandaan.

Een tijdje terug dacht ik erover om wat timelapses te filmen. "Hoe?" Ik vroeg mezelf? Het eerste antwoord was "Nou.. je filmt gewoon iets en versnelt het en dat is het". Maar is het echt zo simpel? Ten eerste wil ik mijn DSLR daarvoor gebruiken en mijn Nikon D3100 heeft een tijdslimiet van 10 minuten voor het filmen van video. Ten tweede, zelfs als ik een camera had zonder tijdslimiet voor het filmen van video, wat als ik een echt lange time-lapse wil maken, zoals 12 uur lang? Ik maak een 12 uur lange 1080p video. Ik betwijfel of de batterij zo lang meegaat, en het is niet erg praktisch, toch? Oké, ik kruis 'video-idee voor filmen'. Nou, dan zijn er foto's. Met een bepaalde interval een foto maken op de camera en eindigen met honderden beelden die ik vervolgens softwarematig verwerk om een video te maken.. ?

Het leek me een goed idee, dus besloot ik het een kans te geven. Dus uiteindelijk wilde ik een apparaat maken waarin ik een tijdsperiode kan invoeren, en op basis van die periode zou mijn camera constant worden geactiveerd. En nu we toch bezig zijn, waarom zouden we niet wat andere dingen toevoegen, zoals bewegingstriggers enzovoort?

Stap 1: Maar.. Hoe?

HOE? is onze volgende vraag waarop een antwoord ontbreekt. Vanwege timing, triggering, sensoren en dergelijke dingen zal het geen verrassing zijn dat de eerste die in me opkwam natuurlijk een Arduino was. Oké, maar toch, we moeten leren hoe we de sluiter op onze camera kunnen activeren. Hm.. servo heet vastgelijmd aan de bodycamera? Absoluut niet, we willen dat deze stil en energiezuinig is. Energiezuinig - waarom? Omdat ik het draagbaar wil maken en er een batterij in wil steken, zal ik niet elke keer in de buurt van een stekker zijn. Dus hoe activeren we het dan.. het is eigenlijk vrij eenvoudig.

Nikon wist al dat je een afstandsbediening en andere accessoires zou willen en ze zeiden: "Ok, we zullen ze dat allemaal geven, maar we zullen een speciale poort maken zodat we meer geld kunnen verdienen aan die accessoires", jammer voor jou Nikon. Die poort heet (in mijn geval) MC-DC2 en de goedkoopste manier om deze te bemachtigen is door een externe ontspanknop op eBay te kopen voor 2-3 $ en gewoon de kabel te gebruiken.

*Sommige andere camera's, zoals Canon, hebben een eenvoudige hoofdtelefoonaansluiting van 3,5 mm die voor hetzelfde gebruik is gemaakt, zodat je een kabel van oude luidsprekers/koptelefoons kunt gebruiken.

Stap 2: Leren hoe de camera te activeren

Hoe dan ook, hier is de deal, de poort zal 3 verbindingen hebben die van ons belang zijn (Ground, Focus en Shutter) en je hebt die aan het einde van je kabel van de nieuw gekochte externe sluiter die je zojuist hebt vernietigd. Die drie verbindingen zijn belangrijk voor ons, want als we de grond en de focus kortsluiten, stelt de camera scherp alsof je op de focusknop drukt en dan, terwijl die verbinding blijft bestaan, kun je de grond en de sluiter kortsluiten en de camera maakt een foto net alsof u op de ontspanknop op de camera drukt.

U kunt dit testen door de stroomdraden aan het uiteinde van de kabel letterlijk kort te sluiten om te bepalen welke draad dat is. Als je dat eenmaal hebt gedaan, zullen we ze, om ze gemakkelijker te identificeren, als volgt inkleuren:

Massa = ZWART; Scherpstelling = WIT; Sluiter = ROOD.

Oké, nu moeten we de Arduino leren dit voor ons te doen.

Stap 3: Manieren om te triggeren

Het eenvoudigste dat we een Arduino kunnen vertellen om naar de buitenwereld te sturen, is het digitale uitgangssignaal. Dit signaal kan HOOG (logisch '1') of LAAG (logisch '0') zijn, vandaar de naam "digitaal", of wanneer het wordt omgezet in de kernbetekenis: 5V voor een logisch HOOG en 0V voor een logisch LAAG.

Wat moeten we met deze digitale signalen? We kunnen ze niet zomaar op de camera aansluiten en verwachten dat de camera weet wat we willen. Zoals we hebben gezien, moeten we de verbindingen op de camera kortsluiten om deze te laten reageren, dus we moeten de digitale signalen van de Arduino gebruiken om sommige componenten aan te sturen die hun terminals kunnen kortsluiten, afhankelijk van dit elektrische signaal dat we verzenden. * Zoals ik het beschreef, denk je misschien "Ah, Relays!" maar nee nee. Relais zou het werk doen, maar we hebben te maken met zulke kleine stromen dat we gemakkelijk de zwarte magie van halfgeleiders kunnen gebruiken.

Het eerste onderdeel dat ik ga proberen is een optocoupler. Ik heb gezien dat ze hiervoor het meest werden geïmplementeerd en het is waarschijnlijk de beste oplossing. Optocoupler is een elektrische component waarmee je het uitgangscircuit bestuurt terwijl het ingangscircuit er volledig van is geïsoleerd. Dit wordt bereikt door informatie door licht te verzenden, het ingangscircuit licht een LED op en de fototransistor op de uitgang schakelt dienovereenkomstig.

Dus we zullen de optocoupler op deze manier gebruiken: we vertellen onze Arduino om een digitale HIGH naar een te sturen als het digitale pinnen zijn, dat signaal is praktisch 5V, wat de LED in de optocoupler zal aansturen en de fototransistor erin zal "kortsluiten" het zijn uitgangsterminals wanneer het dat licht detecteert, en omgekeerd, het zal zijn terminals "losmaken", omdat er geen licht van de LED is wanneer we een digitale LOW door de Arduino sturen.

Praktisch betekent dit: een van de digitale pinnen van de Arduino is bevestigd aan de ANODE-pin van de optocoupler, Arduino's GND is bevestigd aan de KATHODE, de GND van de camera is bevestigd aan de EMITTER en FOCUS (of SHUTTER) aan de COLLECTOR. Raadpleeg het gegevensblad van de optocoupler die u gebruikt om deze pinnen op de uwe te vinden. Ik gebruik 4N35, dus je kunt mijn schema blindelings volgen als je niet echt geeft om wat er in de optocoupler gebeurt. Onnodig te zeggen dat we er twee nodig hebben, omdat we zowel de FOCUS als de SLUITER van de camera moeten bedienen.

Omdat we hebben gezien hoe dat werkt, met een fototransistor op de uitgang, waarom proberen we het niet alleen met een eenvoudige NPN-transistor. Deze keer brengen we het digitale signaal rechtstreeks (over een weerstand) naar de basis van de transistor en verbinden we zowel de camera's als Arduino's GND met de emitter en de focus/sluiter van de camera met de collector van de transistor.

Nogmaals, we hebben er twee nodig omdat we twee signalen besturen. Ik gebruik de BC547B en je kunt hiervoor in principe elke NPN gebruiken, omdat de stroom die we besturen een enkele milliampère is.

Beide componenten zullen werken, maar het kiezen van de optocoupler is waarschijnlijk het betere idee omdat het veiliger is. Kies de transistors alleen als je weet wat je doet.

Stap 4: De code schrijven voor triggering

Zoals we al eerder zeiden, gebruiken we de digitale pinnen van de Arduino voor signalering. De Arduino kan deze beide gebruiken om gegevens ervan te lezen of ernaar te schrijven, dus het eerste dat we moeten doen, specificeren in de setup () -functie dat we twee van Arduino's digitale pinnen voor de uitvoer als volgt zullen gebruiken:

pinMode (FOCUS_PIN, UITGANG);

pinMode (SHUTTER_PIN, UITGANG);

waarbij FOCUS_PIN en SHUTTER_PIN kunnen worden gedefinieerd met "#define NAME value" of als een int voor de setup()-functie, omdat je de pin zou kunnen veranderen, zodat het gemakkelijker is om de waarde op slechts één plek te wijzigen in plaats van de hele code achteraf.

Het volgende dat we zullen doen, is een trigger()-functie schrijven die precies dat zal doen wanneer deze wordt uitgevoerd. Ik zal even een foto bij de code plaatsen. Het enige dat u hoeft te weten, is dat we eerst de FOCUS_PIN op HOOG houden voor een bepaalde periode omdat we moeten wachten tot de camera scherpstelt op het onderwerp waarop we het richten en dan een moment (terwijl FOCUS_PIN nog steeds HOOG is) zet de SHUTTER_PIN op HOOG om de foto te maken.

Ik heb ook de mogelijkheid toegevoegd om het scherpstellen over te slaan, omdat het niet nodig is als we een time-lapse maken van iets dat de afstand tot de camera door de tijd niet verandert.

Stap 5: Klasse-interval{};

Nu we de camera uit de weg hebben geruimd, moeten we er een intervalmeter van maken door de functionaliteit van het manipuleren van de tijdsperiode tussen twee opnamen toe te voegen. Om je een idee te geven van wat we doen, is hier wat primitieve code om de functionaliteit te demonstreren die we willen:

lege lus(){

vertragingsinterval); trekker(); }

Ik wil dit interval kunnen wijzigen van, laten we zeggen, 5 seconden tot misschien 20-30 minuten. En hier is het probleem, als ik het wil veranderen van 5s naar 16s of iets daartussenin, gebruik ik 1s-increment, waarbij voor elk van mijn verzoek om het interval te vergroten, het interval met 1s zou toenemen. Dat is geweldig, maar wat als ik van 5s naar 5min wil gaan? Het zou me 295 verzoeken kosten in stappen van 1 s, dus ik moet de toenamewaarde natuurlijk verhogen naar iets groters, en ik moet bepalen op welke exacte intervalwaarde (drempel) de toename moet worden gewijzigd. Ik heb dit geïmplementeerd:

5s-60s: 1s toename; 60s-300s: toename van 10s; 300s-3600s: toename van 60s;

maar ik heb deze klasse geschreven om aanpasbaar te zijn, zodat je je eigen drempels en stappen kunt definiëren (alles wordt becommentarieerd in het.h-bestand, zodat je weet waar je welke waarden kunt wijzigen).

Het voorbeeld dat ik heb gegeven van het manipuleren van het interval is duidelijk gedaan op een pc, nu moeten we het naar de Arduino verplaatsen. Deze hele klasse, Interval, wordt in één headerbestand geplaatst dat wordt gebruikt om declaraties en definities op te slaan (niet echt, maar het kan in dit voorbeeld worden gedaan zonder schade aan te richten) van onze klasse/functies. Om dit headerbestand in onze arduino-code te introduceren, gebruiken we de " #include "Interval.h" " (bestanden moeten in dezelfde map staan), wat ervoor zorgt dat we de functies kunnen gebruiken die in het headerbestand in onze hoofdcode zijn gedefinieerd.

Stap 6: Het interval manipuleren via Arduino

Nu willen we de waarde van het interval kunnen wijzigen, verhogen of verlagen. Dus dat zijn twee dingen, dus we gebruiken twee digitale signalen die met twee knoppen worden bestuurd. We zullen herhaaldelijk de waarden lezen op de digitale pinnen die we aan de knoppen hebben toegewezen en die waarden ontleden naar de functie checkButtons(int, int); die het interval vergroot als de knop "omhoog" wordt ingedrukt en het interval verkleint als de knop "omlaag". Als beide knoppen worden ingedrukt, verandert ook de waarde van de variabele focus die bepaalt of er wel of niet moet worden scherpgesteld tijdens het triggeren.

Een deel van de code ((millis() - prevBtnPress) >= debounceTime) wordt gebruikt voor debounce. Zoals ik het schreef, betekent het dat ik de eerste druk op de knop registreer met de booleaanse variabele btnPressed en de tijd onthoud dat het gebeurde. Dan wacht ik een bepaalde tijd (debounceTime) en als de knop nog steeds wordt ingedrukt, reageer ik. Het maakt ook een "pauze" tussen elke andere druk op de knop, zodat meerdere keren drukken wordt vermeden waar er geen zijn.

En tot slot, met:

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

prevTrigger = millis(); trekker(); }

we controleren eerst of de hoeveelheid tijd tussen de laatste triggering (prevTrigger) en de huidige tijd (millis()) (alles is gedeeld door 1000 omdat het in milliseconden is en het interval in seconden) gelijk is aan of groter is dan het interval we willen, en als dat zo is, herinneren we ons de huidige tijd als de laatste keer dat we de camera hebben geactiveerd en vervolgens activeren.

Met deze compleet hebben we eigenlijk een intervalmeter gemaakt, maar we zijn nog lang niet klaar. We zien nog steeds de waarde van de intervalmeter niet. Het wordt alleen weergegeven op de seriële monitor en we zullen niet altijd in de buurt van een computer zijn, dus nu zullen we iets implementeren dat ons het interval laat zien als we het veranderen.

Stap 7: Het interval weergeven

Hier introduceren we het display. Ik heb de 4-cijferige module gebruikt die wordt aangestuurd door TM1637 omdat ik deze alleen moet gebruiken voor het weergeven van tijd en niets anders. De eenvoudigste manier om deze modules te gebruiken die voor een Arduino zijn gemaakt, is door er reeds gemaakte bibliotheken voor te gebruiken. Op de Arduino-site is er een pagina die de TM1673-chip beschrijft en een link naar een voorgestelde bibliotheek. Ik heb deze bibliotheek gedownload en er zijn twee manieren waarop je deze bibliotheken kunt introduceren in de Arduino IDE:

1. ga vanuit de Arduino-software naar Sketch>Include Library>Voeg. ZIP-bibliotheek toe en zoek het.zip-bestand dat u zojuist hebt gedownload
2. je kunt doen wat de Arduino handmatig doet en gewoon de bibliotheek uitpakken in de map waarin de Arduino bibliotheken opslaat, op Windows: C:\Gebruikers\Gebruikersnaam\Documents\Arduino\libraries\.

Als je de bibliotheek eenmaal hebt toegevoegd, moet je het "ReadMe"-bestand lezen waarin je een samenvatting vindt van wat de verschillende functies doen. Soms is dit niet genoeg, dus je wilt wat dieper gaan en de header-bestanden verkennen waarin je kunt zien hoe de functies zijn geïmplementeerd en wat ze nodig hebben als invoerargumenten. En natuurlijk is de beste manier om een idee te krijgen van waartoe een bibliotheek in staat is, meestal een voorbeeld dat u vanuit de Arduino-software kunt uitvoeren via Bestand>Voorbeelden>Bibliotheeknaam>Voorbeeldnaam. Deze bibliotheek biedt een voorbeeld dat ik u aanbeveel om op uw scherm te draaien om te zien of uw scherm goed werkt en dan moedig ik u aan om de code die u in het voorbeeld ziet aan te passen en zelf te zien wat elke functie doet en hoe het scherm reageert op het. Ik heb het gedaan en dit is wat ik bedacht:

het gebruikt 4 niet-ondertekende gehele getallen van 8 bits voor elk cijfer (0bB7, B6, B5, B4, B3, B2, B1, B0). En elk van die bits B6-B0 wordt gebruikt voor elk segment van een bepaald cijfer en als de bit 1 is, licht het door hem bestuurde segment op. Deze gehele getallen worden opgeslagen in een array met de naam data. Het instellen van deze bits op het display wordt bereikt door display.setSegments(data); of u kunt natuurlijk toegang krijgen tot een van de cijfers en deze handmatig instellen (data[0] = 0b01111001) of u kunt de functie encodeDigit(int) gebruiken; en converteer het cijfer dat u verzendt naar overeenkomstige bits (data[0] = display.encodeDigit (3));. Bit B7 wordt alleen gebruikt door het tweede cijfer, of data[1], voor het activeren van de dubbele punt.

Aangezien ik de functies in de INTERVAL-klasse heb geschreven waarmee ik bepaalde cijfers van het interval kan krijgen in de vorm van M1M0:S1S0, waarbij M staat voor minuten en S voor seconden, is het logisch dat ik de encodeDigitFunction(int) gebruik; voor het weergeven van het interval als volgt:

displayInterval(){

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

Nu, elke keer dat ik het Interval op het display moet weergeven, kan ik de functie displayInterval() aanroepen.

*Let op de " 0x80 | … " op de data[1]. Het wordt gebruikt om ervoor te zorgen dat de bit B7 van de data[1] altijd 1 is, zodat de dubbele punt oplicht.

Laatste ding over het display, stroomverbruik. Het is misschien niet van groot belang omdat we het niet lang aan zullen houden, maar als je geïnteresseerd bent om dit nog batterijvriendelijker te maken, overweeg dan om de helderheid van het scherm te verlagen, omdat het 3 keer meer stroom verbruikt op de maximale helderheid dan op de laagste.

Stap 8: Alles samenbrengen

We weten hoe we de camera moeten activeren, hoe we het interval moeten manipuleren en hoe we datzelfde interval op een display kunnen weergeven. Nu moeten we alleen al deze dingen samenvoegen. We beginnen natuurlijk met de functie loop(). We zullen constant controleren op het indrukken van knoppen en dienovereenkomstig reageren met de checkButtons (int, int) en het interval dienovereenkomstig wijzigen en het gewijzigde interval weergeven. Ook in de loop() zullen we constant controleren of er genoeg tijd is verstreken sinds de laatste activering of druk op de knop en indien nodig de functie trigger() aanroepen. Omwille van een lager stroomverbruik zullen we het display na enige tijd uitschakelen.

Ik heb een tweekleurige led toegevoegd, (rood en groen, gemeenschappelijke kathode) die groen zal oplichten terwijl de trigger () en het zal rood oplichten samen met het scherm als het scherpstellen is ingeschakeld en het zal uit blijven als het scherpstellen is uit.

We migreren ook naar een nog kleinere Arduino, Pro Mini.

Stap 9: Een laatste ding toevoegen

Tot nu toe hebben we alleen een intervalmeter gemaakt. Handig, maar het kan beter.

Dit is wat ik in gedachten had: de Intervalometer doet zijn ding standaard BEHALVE wanneer we een soort externe schakelaar/sensor aansluiten die dan de intervalmeter stopt en reageert op de invoer van de schakelaar/sensor. Laten we het een sensor noemen, het hoeft niet per se een sensor te zijn die is aangesloten, maar ik zal het zo noemen.

Ten eerste, hoe detecteren we dat we de sensor hebben bevestigd?

De sensoren die we zullen gebruiken / maken, hebben allemaal drie draden nodig die ze verbinden met de Arduino (Vcc, GND, Signaal). Dat betekent dat we een 3,5 mm audio-aansluiting kunnen gebruiken als ingang voor de sensor. En hoe lost dat ons probleem op? Welnu, er zijn types van een 3,5 mm-aansluiting "met een schakelaar" die pinnen hebben die kortgesloten zijn naar de pinnen van de connector als er geen mannelijke connector in zit, en ze worden losgemaakt als er een connector aanwezig is. Dat betekent dat we de informatie hebben op basis van de aanwezigheid van de sensor. Ik gebruik de pull-down-weerstand zoals weergegeven (de digitale pin zal HOOG zijn zonder de sensor en LAAG met de sensor bevestigd) in de afbeelding of je kunt ook de digitale pin aan de pin van de connector bevestigen die normaal is verbonden met aarde en definieer die digitale pin als INPUT_PULLUP, het zal hoe dan ook werken. Dus nu moeten we onze code aanpassen zodat deze alles doet wat we tot nu toe hebben geschreven, alleen als de sensor niet aanwezig is, of wanneer de digitale pincontrole HOOG is. Ik heb het ook aangepast zodat het " SENS " op het scherm toont in plaats van het interval dat nutteloos is in deze modus, maar de scherpstelling is nog steeds relevant voor ons. We behouden de functionaliteit van het wisselen van scherpstellen met de druk op beide knoppen en toont de focusstatus door de rode led.

Wat doet de sensor eigenlijk?

Het enige wat het hoeft te doen is 5V op de signaalpin te zetten wanneer we de camera willen activeren. Dat betekent dat we een andere digitale pin van de Arduino nodig hebben om de status van deze pin te controleren en wanneer hij HOOG registreert, hoeft hij alleen maar de trigger()-functie aan te roepen en de camera maakt een foto. Het eenvoudigste voorbeeld, en degene die we zullen gebruiken om te testen of dit werkt, is een eenvoudige knop met een pull-down-weerstand. Bevestig de knop tussen de Vcc van de sensor en de signaalpin en voeg een weerstand toe tussen de signaalpin en GND, op deze manier staat de signaalpin op GND wanneer de knop niet wordt ingedrukt omdat er geen stroom door de weerstand vloeit, en wanneer de knop wordt ingedrukt, we zetten de signaalpin direct op HIGH en de Arduino leest dat en activeert de camera.

Hiermee sloten we het schrijven van de code af.

*Ik wil graag enkele problemen opmerken die ik had met de audio-aansluitingen die ik gebruikte. Bij het invoegen van de mannelijke jack in de connector, zouden de GND en een van de andere twee pinnen soms kortsluiten. Dit gebeurt onmiddellijk en alleen tijdens het plaatsen van de connector, maar het is nog steeds lang genoeg voor Arduino om een kortsluiting te registreren, zodat de Arduino gewoon opnieuw zou opstarten. Dit gebeurt niet zo vaak, maar kan nog steeds een gevaar zijn en er is een potentieel om de Arduino te vernietigen, dus vermijd de connectoren die ik heb gebruikt.

Stap 10: de puinhoop bevatten

Je kunt aan de afbeeldingen zien dat het breadboard rommelig wordt en we zijn klaar, dus we moeten alles overzetten naar een perfboard / PCB. Ik ging voor PCB omdat ik denk dat ik er meer van ga maken, zodat ik ze op deze manier gemakkelijk kan reproduceren.

Ik gebruikte Eagle voor het ontwerpen van de PCB en vond ontwerpen voor alle onderdelen die ik gebruikte. Er is een klein ding in mijn ontwerp dat ik wou dat ik niet had gedaan en dat is een draadpad voor de Vcc van het scherm. Ik heb het te laat gezien en wilde niet verpesten wat ik eerder had ontworpen en ging de luie manier om draadpads toe te voegen en later draad aan deze verbindingen toe te voegen in plaats van koperen sporen, dus let erop dat als je mijnontwerp gebruikt.

Het Arduino-bord en het display zijn om duidelijke redenen met de PCB verbonden via vrouwelijke pin-headers in plaats van rechtstreeks op de PCB te worden gesoldeerd. Zo is er onder het display voldoende ruimte voor andere componenten voor andere componenten zoals weerstanden, transistors en zelfs de audio jack.

Ik heb de microdrukknoppen geplaatst die, door het ontwerp, direct moeten worden gesoldeerd, maar je kunt ook de gaten voor vrouwelijke pin-headers gebruiken en knoppen met draad verbinden als je ze op de behuizing wilt monteren en niet op de PCB.

We zullen ook een andere vrouwelijke audio-aansluiting plaatsen om de kabel aan te sluiten die op de camera is aangesloten. Op deze manier wordt het bord veelzijdiger, omdat we op die manier verbinding kunnen maken met andere camera's met andere connectoren.

Stap 11: Sens0rs

Laten we eens kijken naar manieren om de sensor te implementeren.

De sensor heeft dus een voedingsspanning van 5V en moet een digitale HIGH op zijn signaalpin kunnen leveren wanneer we de camera willen activeren. Het eerste dat in me opkwam, was een bewegingssensor, PIR om precies te zijn. Er zijn modules verkocht voor Arduino die deze sensor hebben en precies doen wat we willen. Ze worden gevoed op 5V en hebben een uitgangspin waarop ze 5V plaatsen wanneer ze worden geactiveerd, we hoeven alleen maar de pinnen aan te sluiten op een 3,5 mm audio-aansluiting en we kunnen rechtstreeks op het bord aansluiten. Een ding om op te merken is echter dat deze sensor tijd nodig heeft om op te warmen en goed te gaan werken, dus verwacht niet dat hij goed werkt zodra je hem aansluit, geef hem wat tijd en stel hem dan in en wat er levends in zijn bereik activeert de camera.

Omdat we denken in de richting van reeds gemaakte Arduino-sensorborden, komt er nog een bij, geluid. Deze borden zijn meestal zo gemaakt dat ze één pin hebben die de analoge waarde van het oppikt geluid uitvoert en een andere, digitale, die een logisch HOOG uitvoert als het geluid dat het oppikt een bepaald niveau overschrijdt. We kunnen dit niveau zo instellen dat de sensor onze stem negeert maar een klap registreert. Op die manier activeer je elke keer dat je klapt de camera.

Stap 12: PoweeEeEer

Ik denk dat de gemakkelijkste manier om dit ding van stroom te voorzien, is met een powerbank, en niet extern. We behouden de functionaliteit van het opladen van onze telefoon of wat dan ook en regelen de stroom naar het bord via een schakelaar. We lokaliseren de pinnen van de USB-uitgangsconnector op de printplaat in de powerbank, die GND en Vcc (5V) zijn en soldeerdraden er rechtstreeks op en van daaruit naar ons bord.

Stap 13: Behuizing.. Kinda

Ik worstelde hier echt mee. Toen ik de doos kocht waarin ik de bestaande PCB wilde plaatsen, realiseerde ik me dat er geen mooie manier is om alles te passen zoals ik wilde en toen besloot ik een nieuwe PCB te ontwerpen, dit keer met optocouplers. Ik wilde de print precies onder de zijkant plaatsen waar ik gaten zou boren voor bepaalde componenten die gezien/aangeraakt moeten worden. Om dit te laten werken, zou ik het display en Arduino rechtstreeks op het bord moeten solderen, zonder sockets of headers, en dat is waar het eerste probleem ligt. Het was absoluut verschrikkelijk om iets op te lossen, omdat ik niet klaar was om het meteen vast te solderen totdat ik testte dat alles werkt, en ik kon niets echt testen omdat ik het niet kon solderen enzovoort.. don doe dit niet. Probleem numero dos, gaten maken in de kast. Ik denk dat ik de metingen verkeerd heb gedaan omdat geen van de gaten in de behuizing was uitgelijnd met de componenten op de printplaat en ik ze moest vergroten en de knoppen te hoog op de printplaat zaten en ze altijd zouden worden ingedrukt als ik de printplaat op zijn plaats zette en aangezien ik de audio-aansluitingen aan de zijkant wilde hebben, moest ik die gaten ook vergroten om eerst in de aansluitingen te passen en vervolgens het bord laten zakken zodat het display en de knoppen erdoor konden komen. Het resultaat is verschrikkelijk.

Ik heb de vreselijke gaten een beetje minder erg gemaakt door de bovenkant te bedekken met wat dun karton waarin ik meer redelijke gaten voor de componenten heb uitgesneden en.. het is nog steeds verschrikkelijk, maar gemakkelijker voor het oog denk ik.

Oordeel, ik stel voor dat u dit doet door componenten te kopen die op de behuizing worden gemonteerd en niet rechtstreeks op de PCB. Zo heb je meer vrijheid bij het plaatsen van de componenten en minder plekken om fouten te maken.

Stap 14: Fin

Ik ben klaar, maar hier zijn enkele dingen die ik anders zou hebben gedaan:

Gebruik 3,5 mm audio-aansluitingen van betere kwaliteit. Degenen die ik gebruikte, hebben de neiging om de aansluitingen kort te sluiten tijdens het plaatsen of uittrekken van de aansluiting, wat resulteert in kortsluiting van de voeding en dus het resetten van de Arduino of het produceert gewoon nep-triggers. Ik heb dit in de vorige stap gezegd, maar ik zeg het nog een keer … soldeer het Arduino-bord niet zonder headers / socket, het maakt elke vorm van probleemoplossing of het uploaden van nieuwe code enzovoort veel moeilijker. Ik denk ook dat het handig zou zijn geweest om een led te hebben die aangeeft dat het ding aan staat, omdat ik het vaak niet kan zien zonder op de knop te drukken, omdat het scherm uitgaat. En als laatste een pauzefunctie. Ik kan me voorstellen dat het handig is wanneer je bijvoorbeeld de PIR-sensor aansluit, omdat hij tijd nodig heeft om op te warmen, of als je hem gewoon beweegt, je niet wilt dat hij wordt geactiveerd, zodat je gewoon alles kunt pauzeren, maar je kunt ook gewoon draaien uit de camera dus.. wat dan ook.

Een ander leuk ding is om het op het statief te klitten, omdat het daar waarschijnlijk wordt gebruikt.

Voel je vrij om iets over dit project te vragen in de comments en ik zou graag willen weten of je het hebt gebouwd en hoe het voor je is geworden.