Pimp My Cam : 14 étapes (avec photos)

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:11

Voici d'où vient ce projet.

Il y a quelque temps, j'ai pensé à filmer des timelapses. "Comment?" Je me suis demandé? La première réponse était "Eh bien.. vous filmez juste quelque chose et l'accélérez et c'est tout". est-ce vraiment si simple? Tout d'abord, je souhaite utiliser mon reflex numérique pour cela, et mon Nikon D3100 a une limite de temps de 10 minutes pour filmer une vidéo. Deuxièmement, même si j'avais une caméra sans limite de temps pour filmer une vidéo, que se passe-t-il si je veux faire un timelapse vraiment long, comme 12 heures ? Je fais une vidéo 1080p de 12 heures. Je doute que la batterie dure aussi longtemps et, ce n'est pas très pratique, n'est-ce pas ? D'accord, je croise "idée de filmer une vidéo". Eh bien, il y a des images. Prendre une photo sur l'appareil photo à un certain intervalle et se retrouver avec des centaines d'images que je traite ensuite via un logiciel pour faire une vidéo.. ?

Cela semblait être une bonne idée, alors j'ai décidé de tenter le coup. J'ai donc fini par vouloir créer un appareil dans lequel je peux entrer une période de temps, et en fonction de cette période, il déclencherait mon appareil photo en permanence. Et pendant qu'on y est, pourquoi ne pas ajouter d'autres trucs comme le déclencheur de mouvement et ainsi de suite ?

Étape 1: Mais.. Comment ?

COMMENT? est notre prochaine question qui manque une réponse. En raison du timing, du déclenchement, des capteurs et autres, il ne sera pas surprenant que le premier qui me soit venu à l'esprit soit, bien sûr, un Arduino. D'accord, mais quand même, nous devons apprendre à déclencher l'obturateur de notre appareil photo. Hm.. servo collé à chaud sur la caméra du corps? Absolument pas, nous voulons que ce soit silencieux et économe en énergie. Efficacité énergétique - pourquoi ? Parce que je veux le rendre portable et y insérer une batterie, je ne serai pas à chaque fois près d'une prise de courant. Alors, comment pouvons-nous le déclencher alors.. c'est en fait assez simple.

Nikon savait déjà que vous allez vouloir une télécommande et d'autres accessoires et ils ont dit " d'accord, nous allons leur donner tout ça, mais nous allons faire un port spécial pour que nous puissions gagner plus d'argent sur ces accessoires ", honte à vous Nikon. Ce port s'appelle (dans mon cas) MC-DC2, et le moyen le moins cher de mettre la main dessus est d'acheter un déclencheur à distance sur eBay pour 2-3 $ et d'utiliser simplement le câble.

*Certains autres appareils photo, comme Canon, ont une simple prise casque 3,5 mm conçue pour le même usage, vous pouvez donc utiliser un câble d'anciens haut-parleurs/casque.

Étape 2: Apprendre à déclencher la caméra

Quoi qu'il en soit, voici le deal, le port aura 3 connexions qui seront de notre intérêt (Ground, Focus et Shutter) et vous aurez celles au bout de votre câble de l'obturateur déporté nouvellement acheté que vous venez de détruire. Ces trois connexions sont importantes pour nous car si nous court-circuitons le sol et la mise au point, la caméra se concentrera comme vous appuyez sur le bouton de mise au point, puis, tant que cette connexion reste, vous pouvez court-circuiter le sol et l'obturateur et la caméra prendra une photo comme si vous appuyiez sur le déclencheur de l'appareil photo.

Vous pouvez tester cela en court-circuitant littéralement les fils sous tension à l'extrémité du câble pour identifier quel fil est lequel. Une fois que vous avez fait cela, pour faciliter l'identification, nous les colorerons comme ceci:

Terre = NOIR; Mise au point = BLANC; Obturateur = ROUGE.

D'accord, maintenant nous devons apprendre à l'Arduino à le faire pour nous.

Étape 3: Façons de déclencher

La chose la plus simple que nous puissions dire à un Arduino d'envoyer dans le monde extérieur est son signal de sortie numérique. Ce signal peut être soit HIGH (logique '1') ou LOW (logique '0'), d'où le nom "numérique", ou lorsqu'il est converti en sa signification principale: 5 V pour un niveau logique HAUT et 0 V pour un niveau logique BAS.

Que faire de ces signaux numériques ? Nous ne pouvons pas simplement les connecter à la caméra et nous attendre à ce que la caméra sache ce que nous voulons. Comme nous l'avons vu, nous devons court-circuiter les connexions de la caméra pour qu'elle réagisse, nous devons donc utiliser les signaux numériques de l'Arduino pour piloter certains composants qui peuvent court-circuiter leurs bornes en fonction de ces signaux électriques que nous leur envoyons.. *La façon dont je l'ai décrit, vous pourriez penser "Ah, les relais!" mais non non. Le relais ferait l'affaire mais nous avons affaire à des courants si faibles que nous pouvons facilement utiliser la magie noire des semi-conducteurs.

Le premier composant que je vais essayer est un optocoupleur. Je les ai vus mis en œuvre le plus pour cela et c'est probablement la meilleure solution. L'optocoupleur est un composant électrique avec lequel vous contrôlez le circuit de sortie tandis que le circuit d'entrée en est complètement isolé. Ceci est réalisé en transmettant des informations par la lumière, le circuit d'entrée allume une LED et le phototransistor sur la sortie commute en conséquence.

Nous allons donc utiliser l'optocoupleur de cette façon: nous disons à notre Arduino d'envoyer un HAUT numérique sur l'un si ce sont des broches numériques, ce signal est pratiquement de 5V qui entraînera la LED à l'intérieur de l'optocoupleur et le phototransistor à l'intérieur de celui-ci sera " court " ce sont des bornes de sortie lorsqu'il détecte cette lumière, et vice versa, il "détachera" ses bornes car il n'y a pas de lumière de la LED lorsque nous envoyons un LOW numérique via l'Arduino.

En pratique, cela signifie: l'une des broches numériques de l'Arduino est attachée à la broche ANODE de l'optocoupleur, le GND d'Arduino est attaché à la CATHODE, le GND de la caméra est attaché à l'ÉMETTEUR et le FOCUS (ou SHUTTER) au COLLECTEUR. Reportez-vous à la fiche technique de l'optocoupleur que vous utilisez pour trouver ces broches sur le vôtre. J'utilise 4N35 afin que vous puissiez suivre le mien schéma aveuglément si vous ne vous souciez pas vraiment de ce qui se passe à l'intérieur de l'optocoupleur. Inutile de dire que nous en aurons besoin de deux, car nous devons contrôler la FOCUS et l'OBTURATEUR de la caméra.

Puisque nous avons vu comment cela fonctionne, avec un phototransistor en sortie, pourquoi ne pas l'essayer uniquement avec un simple transistor NPN. Cette fois, nous allons amener le signal numérique directement (à travers une résistance) à la base du transistor et connecter le GND de la caméra et de l'Arduino à l'émetteur et la mise au point/l'obturateur de la caméra au collecteur du transistor.

Encore une fois, nous en aurons besoin de deux puisque nous contrôlons deux signaux. J'utilise le BC547B et vous pouvez essentiellement utiliser n'importe quel NPN pour cela, car le courant que nous contrôlons est d'un seul milliampère.

Ces deux composants fonctionneront, mais le choix de l'optocoupleur est probablement la meilleure idée car il est plus sûr. Ne choisissez les transistors que si vous savez ce que vous faites.

Étape 4: Rédaction du code pour le déclenchement

Comme nous l'avons dit précédemment, nous utiliserons les broches numériques de l'Arduino pour la signalisation. L'Arduino peut les utiliser à la fois pour lire des données à partir de celui-ci ou pour y écrire. La première chose à faire est donc de spécifier dans la fonction setup() que nous utiliserons deux des broches numériques d'Arduino pour la sortie comme suit:

pinMode(FOCUS_PIN, SORTIE);

pinMode(SHUTTER_PIN, SORTIE);

où FOCUS_PIN et SHUTTER_PIN peuvent être définis avec "#define NAME value" ou comme un int avant la fonction setup() car vous pouvez changer la broche, il est donc plus facile de changer la valeur à un seul endroit plutôt que le code entier par la suite.

La prochaine chose que nous ferons est d'écrire une fonction trigger() qui fera exactement cela lorsqu'elle sera exécutée. Je vais juste inclure une image avec le code. Tout ce que vous devez savoir, c'est que nous maintenons d'abord le FOCUS_PIN sur HIGH pendant un certain temps car nous devons attendre que l'appareil photo se concentre sur le sujet sur lequel nous le dirigeons, puis pendant un instant (alors que FOCUS_PIN est toujours HIGH) mettez le SHUTTER_PIN sur HIGH juste pour prendre la photo.

J'ai également inclus la possibilité de sauter la mise au point car cela ne sera pas nécessaire si nous filmons un timelapse de quelque chose qui ne change pas sa distance par rapport à l'appareil photo dans le temps.

Étape 5: Intervalle de classe{};

Maintenant que nous n'avons plus besoin de déclencher la caméra, nous devons en faire un intervallomètre en ajoutant la fonctionnalité de manipulation de la période entre deux prises de vue. Juste pour que vous ayez une idée de ce que nous faisons, voici un code primitif pour démontrer la fonctionnalité que nous voulons:

boucle vide(){

Intervalle de retard); gâchette(); }

Je veux pouvoir changer cet intervalle de, disons, 5 secondes jusqu'à peut-être 20-30 minutes. Et voici le problème, si je veux le changer de 5s à 16s ou quelque chose entre les deux, j'utiliserai un incrément de 1s, où pour chacune de mes demandes d'augmentation de l'intervalle, l'intervalle s'incrémentera de 1s. C'est super, mais si je veux passer de 5s à 5min ? Il me faudrait 295 requêtes pour cela par incréments de 1 s, je dois donc évidemment augmenter la valeur de l'incrément à quelque chose de plus grand, et je dois définir sur quelle valeur d'intervalle exacte (seuil) modifier l'incrément. J'ai implémenté ceci:

5s-60s: incrément de 1s; 60s-300s: incrément de 10s; 300s-3600s: incrément de 60 s;

mais j'ai écrit cette classe pour qu'elle soit ajustable afin que vous puissiez définir vos propres seuils et incréments (tout est commenté dans le fichier.h afin que vous puissiez savoir où changer quelles valeurs).

L'exemple que j'ai donné de la manipulation de l'intervalle se fait évidemment sur un PC, il faut maintenant le déplacer vers l'Arduino. Toute cette classe, Interval, est placée dans un fichier d'en-tête qui est utilisé pour stocker les déclarations et les définitions (pas vraiment, mais cela peut être fait dans cet exemple sans faire de mal) de notre classe/fonctions. Pour introduire ce fichier d'en-tête dans notre code arduino, nous utilisons le " #include "Interval.h" " (les fichiers doivent être dans le même répertoire), ce qui garantit que nous pouvons utiliser les fonctions définies dans le fichier d'en-tête de notre code principal.

Étape 6: Manipulation de l'intervalle via Arduino

Maintenant, nous voulons pouvoir changer la valeur de l'intervalle, soit l'augmenter, soit la diminuer. Donc ça fait deux choses donc on va utiliser deux signaux numériques qui seront contrôlés par deux boutons. Nous allons lire à plusieurs reprises les valeurs sur les broches numériques que nous avons attribuées aux boutons et analyser ces valeurs à la fonction checkButtons(int, int); ce qui augmentera l'intervalle si le bouton "haut" est enfoncé et diminuera l'intervalle si le bouton "bas". De plus, si les deux boutons sont enfoncés, cela changera la valeur de la mise au point variable qui contrôle la mise au point ou non lors du déclenchement.

Une partie du code ((millis() - prevBtnPress) >= debounceTime) est utilisée pour l'anti-rebond. La façon dont je l'ai écrit, cela signifie que j'enregistre la première pression sur un bouton avec la variable booléenne btnPressed et que je me souviens de l'heure à laquelle cela s'est produit. Ensuite, j'attends un certain temps (debounceTime) et si le bouton est toujours enfoncé, je réagis. Il fait également une "pause" entre chaque autre pression sur le bouton afin d'éviter les pressions multiples là où il n'y en a pas.

Et enfin, avec:

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

prevTrigger = millis(); gâchette(); }

nous vérifions d'abord si le temps entre le dernier déclenchement (prevTrigger) et l'heure actuelle (millis()) (tout est divisé par 1000 car il est en millisecondes et l'intervalle est en secondes) est égal ou supérieur à l'intervalle nous voulons, et si c'est le cas, nous nous souvenons de l'heure actuelle comme la dernière fois que nous avons déclenché la caméra, puis la déclenchons.

Avec cela terminé, nous avons essentiellement fait un intervallomètre, mais nous sommes loin d'être terminés. On ne voit toujours pas la valeur de l'intervallomètre. Il n'est affiché que sur le moniteur série et nous ne serons pas toujours à proximité d'un ordinateur, nous allons donc maintenant implémenter quelque chose qui nous montrera l'intervalle au fur et à mesure que nous le modifions.

Étape 7: Affichage de l'intervalle

C'est ici que nous présentons l'affichage. J'ai utilisé le module à 4 chiffres qui est piloté par TM1637 car je n'ai besoin de l'utiliser que pour afficher l'heure et rien d'autre. Le moyen le plus simple d'utiliser ces modules conçus pour un Arduino est d'utiliser des bibliothèques déjà créées pour eux. Sur le site Arduino, il y a une page décrivant la puce TM1673 et un lien vers une bibliothèque suggérée. J'ai téléchargé cette bibliothèque et il existe deux manières d'introduire ces bibliothèques dans l'IDE Arduino:

1. à partir du logiciel Arduino, accédez à Sketch> Inclure la bibliothèque> Ajouter une bibliothèque. ZIP et localisez le fichier.zip que vous venez de télécharger
2. vous pouvez faire ce que fait l'Arduino manuellement et simplement décompresser la bibliothèque dans le dossier dans lequel l'Arduino stocke les bibliothèques, sous Windows: C:\Users\Username\Documents\Arduino\libraries\.

Une fois que vous avez inclus la bibliothèque, vous devriez lire le fichier "ReadMe" dans lequel vous trouverez le résumé de ce que font les différentes fonctions. Parfois, cela ne suffit pas, vous voudrez donc aller un peu plus loin et explorer les fichiers d'en-tête dans lesquels vous pouvez voir comment les fonctions sont implémentées et ce qu'elles nécessitent comme arguments d'entrée. Et bien sûr, le meilleur moyen d'avoir une idée de ce dont une bibliothèque est capable offre généralement un exemple que vous pouvez exécuter à partir du logiciel Arduino via File>Examples>LibraryName>ExampleName. Cette bibliothèque propose un exemple que je vous recommande d'exécuter sur votre écran juste pour voir si votre écran fonctionne correctement et que je vous encourage à modifier le code que vous voyez dans l'exemple et à voir par vous-même ce que fait chaque fonction et comment l'écran réagit à ce. Je l'ai fait et voici ce que j'ai compris:

il utilise 4 entiers non signés de 8 bits pour chaque chiffre (0bB7, B6, B5, B4, B3, B2, B1, B0). Et chacun de ces bits B6-B0 est utilisé pour chaque segment d'un certain chiffre et si le bit est à 1, le segment contrôlé par celui-ci s'allume. Ces entiers sont stockés dans un tableau appelé data. La définition de ces bits sur l'affichage est effectuée par display.setSegments(data); ou vous pouvez naturellement accéder à l'un des chiffres en particulier et les définir soit manuellement (data[0] = 0b01111001) ou vous pouvez utiliser la fonction encodeDigit(int); et convertissez le chiffre que vous l'envoyez en bits (data[0] = display.encodeDigit(3));. Le bit B7 n'est utilisé que par le deuxième chiffre, ou data[1], pour activer les deux points.

Depuis que j'ai écrit les fonctions dans la classe INTERVAL pour lesquelles je peux obtenir certains chiffres de l'intervalle sous la forme M1M0:S1S0, où M représente les minutes et S les secondes, il est naturel que j'utilise le encodeDigitFunction(int); pour afficher l'intervalle comme ceci:

displayInterval(){

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

Maintenant, chaque fois que j'ai besoin d'afficher l'intervalle sur l'écran, je peux appeler la fonction displayInterval().

*Notez le " 0x80 | … " sur les données[1]. Il permet de s'assurer que le bit B7 de la donnée[1] est toujours à 1 donc les deux points s'allument.

Dernière chose à propos de l'affichage, la consommation d'énergie. Ce n'est peut-être pas très important car nous ne le garderons pas longtemps, mais si vous souhaitez le rendre encore plus convivial pour la batterie, envisagez de réduire la luminosité de l'écran car il consomme 3 fois plus de courant sur la luminosité maximale. que sur le plus bas.

Étape 8: Tout assembler

Nous savons comment déclencher la caméra, comment manipuler l'intervalle et comment afficher ce même intervalle sur un écran. Maintenant, nous avons juste besoin de fusionner toutes ces choses ensemble. Nous commencerons, bien sûr, par la fonction loop(). Nous vérifierons constamment les pressions sur les boutons et réagirons en conséquence avec les checkButtons (int, int) et modifierons l'intervalle en conséquence et afficherons l'intervalle modifié. Également dans la boucle (), nous vérifierons constamment si suffisamment de temps s'est écoulé depuis le dernier déclenchement ou la dernière pression sur un bouton et appellerons la fonction trigger () si nécessaire. Pour réduire la consommation d'énergie, nous éteindrons l'écran après un certain temps.

J'ai ajouté une led bicolore (rouge et verte, cathode commune) qui s'allumera en vert pendant que la gâchette () et elle s'allumera en rouge avec l'affichage si la mise au point est activée et elle restera éteinte si la mise au point est désactivé.

De plus, nous allons migrer vers un Arduino encore plus petit, Pro Mini.

Étape 9: ajouter une dernière chose

Jusqu'à présent, nous n'avons créé qu'un Intervalomètre. Utile, mais nous pouvons faire mieux.

Voici ce que j'avais en tête: l'intervalomètre fait sa chose par défaut SAUF lorsque nous attachons une sorte de commutateur/capteur externe qui arrête alors l'intervalomètre et répond à l'entrée du commutateur/capteur. Appelons cela un capteur, ce ne sera pas nécessairement un capteur connecté mais je l'appellerai ainsi.

Premièrement, comment détectons-nous que nous avons attaché le capteur ?

Les capteurs que nous utiliserons / fabriquerons auront tous besoin de trois fils les reliant à l'arduino (Vcc, GND, Signal). Cela signifie que nous pouvons utiliser une prise audio 3,5 mm comme prise d'entrée pour le capteur. Et comment cela résout-il notre problème ? Eh bien, il existe des types de prise jack 3,5 mm "avec un interrupteur" dont les broches sont court-circuitées avec les broches du connecteur s'il n'y a pas de connecteur mâle à l'intérieur, et elles se détachent lorsqu'un connecteur est présent. Cela signifie que nous avons les informations basées sur la présence du capteur. J'utiliserai la résistance pull-down comme indiqué (la broche numérique lira HAUT sans le capteur et BAS avec le capteur attaché) dans l'image ou vous pouvez également attacher la broche numérique à la broche du connecteur qui est normalement connecté à la terre et définissez cette broche numérique comme INPUT_PULLUP, cela fonctionnera dans les deux cas. Nous devons donc maintenant modifier notre code pour qu'il fasse tout ce que nous avons écrit jusqu'à présent uniquement si le capteur n'est pas présent ou lorsque la broche numérique vérifie qu'elle est ÉLEVÉE. Je l'ai également modifié pour qu'il affiche " SENS " sur l'écran au lieu de l'intervalle qui est inutile dans ce mode, mais la mise au point est toujours pertinente pour nous, nous conserverons la fonctionnalité d'alternance de la mise au point avec la pression des deux boutons et montrant l'état de mise au point à travers la led rouge.

Que fait réellement le capteur ?

Tout ce qu'il faut faire est de mettre 5V sur sa broche Signal lorsque nous voulons déclencher la caméra. Cela signifie que nous aurons besoin d'une autre broche numérique de l'Arduino pour vérifier l'état de cette broche et lorsqu'elle enregistre HIGH, il suffit d'appeler la fonction trigger () et l'appareil photo prendra une photo. L'exemple le plus simple, et celui que nous utiliserons pour tester si cela fonctionne, est un simple bouton avec une résistance pull-down. Fixez le bouton entre le Vcc du capteur et la broche de signal et ajoutez une résistance entre la broche de signal et GND, de cette façon la broche de signal sera sur GND lorsque le bouton n'est pas enfoncé car il n'y a pas de courant traversant la résistance, et quand le bouton est enfoncé, nous mettons la broche Signal directement sur HIGH et l'Arduino lit cela et déclenche la caméra.

Avec cela, nous avons terminé l'écriture du code.

*Je voudrais signaler quelques problèmes que j'ai rencontrés avec les prises audio que j'ai utilisées. Lors de l'insertion de la prise mâle dans le connecteur, le GND et l'une des deux autres broches étaient parfois court-circuités. Cela se produit instantanément et uniquement lors de la mise en place du connecteur, mais il est encore assez long pour qu'Arduino enregistre un court-circuit afin que l'Arduino ne fasse que redémarrer. Cela n'arrive pas si souvent mais peut toujours être un danger et il y a un potentiel de destruction de l'Arduino, alors évitez les connecteurs que j'ai utilisés.

Étape 10: Contenir le désordre

Vous pouvez voir sur les images que la planche à pain devient en désordre et que nous avons terminé, nous devons donc tout transférer sur un perfboard/PCB. J'ai opté pour le PCB parce que je pense que je vais en faire plus afin de pouvoir les reproduire facilement.

J'ai utilisé Eagle pour la conception du PCB et j'ai trouvé des conceptions pour toutes les pièces que j'ai utilisées. Il y a une petite chose dans ma conception que j'aurais aimé ne pas avoir faite et c'est un fil pour le Vcc de l'écran. Je l'ai vu trop tard et je ne voulais pas gâcher ce que j'avais conçu auparavant et j'ai utilisé la manière paresseuse d'ajouter des pastilles de fil et de devoir plus tard ajouter du fil à ces connexions au lieu de traces de cuivre, alors faites attention si vous utilisez la conception du mien.

La carte Arduino et l'écran sont connectés au PCB via des en-têtes de broches femelles plutôt que d'être soudés directement sur le PCB, pour des raisons apparentes. De cette façon, il y a beaucoup d'espace pour d'autres composants sous l'écran pour d'autres composants tels que des résistances, des transistors et même la prise audio.

J'ai mis les micro boutons poussoirs qui, de par leur conception, doivent être soudés directement mais vous pouvez également utiliser les trous pour les embases à broches femelles et connecter les boutons avec du fil si vous voulez qu'ils soient montés sur le boîtier et non sur le PCB.

Nous mettrons également une autre prise audio femelle pour brancher le câble qui se connecte à la caméra. De cette façon, la carte devient plus polyvalente car nous pourrons ainsi nous connecter à d'autres caméras avec d'autres connecteurs.

Étape 11: Sens0rs

Considérons les moyens de mettre en œuvre le capteur.

Ainsi, le capteur aura la tension d'alimentation de 5V, et il devra être capable de fournir un HIGH numérique sur sa broche de signal lorsque nous voulons déclencher la caméra. La première chose qui m'est venue à l'esprit est un capteur de mouvement, PIR pour être précis. Il existe des modules vendus pour Arduino qui ont ce capteur sur eux et font exactement ce que nous voulons. Ils sont alimentés en 5V et ont une broche de sortie sur laquelle ils mettent 5V lorsqu'ils sont déclenchés, il suffit de connecter ses broches à une prise audio 3,5 mm et nous pouvons les brancher directement sur la carte. Une chose à noter cependant est que ce capteur a besoin de temps pour chauffer et commencer à fonctionner correctement, alors ne vous attendez pas à ce qu'il fonctionne correctement dès que vous le branchez, donnez-lui un peu de temps, puis configurez-le et tout ce qui est vivant entre dans son gamme déclenchera la caméra.

Puisque nous pensons aux cartes de capteurs Arduino déjà fabriquées, une autre nous vient à l'esprit, le son. Ces cartes sont généralement fabriquées de telle sorte qu'elles ont une broche qui produit la valeur analogique du son qu'elle capte et une autre, une numérique, qui produit un HAUT logique si le son qu'elle capte franchit un certain niveau. Nous pouvons régler ce niveau de telle sorte que le capteur ignore notre voix mais enregistre un applaudissement. De cette façon, à chaque fois que vous applaudissez, vous déclenchez la caméra.

Étape 12: PoweeEeEer

Je pense que le moyen le plus simple d'alimenter cette chose est d'utiliser une banque d'alimentation, et non de l'extérieur. Nous conserverons la fonctionnalité de chargement de notre téléphone ou autre et contrôlerons le flux de courant vers la carte via un interrupteur. Nous localiserons les broches du connecteur USB de sortie sur la carte de circuit imprimé dans la banque d'alimentation qui sont les fils GND et Vcc (5V) et à souder directement sur eux et de là dans notre carte.

Étape 13: Enceinte.. un peu

J'ai vraiment eu du mal avec ça. Lorsque j'ai acheté la boîte dans laquelle je voulais mettre le PCB existant, j'ai réalisé qu'il n'y avait pas de moyen de tout mettre comme je le voulais, puis j'ai décidé de concevoir un nouveau PCB, cette fois avec des optocoupleurs. Je voulais placer le PCB juste sous le côté sur lequel je percerais des trous pour certains composants qui doivent être vus/touchés. Pour que cela fonctionne, j'aurais besoin de souder l'écran et l'Arduino directement à la carte, sans sockets ni en-têtes, et c'est là que réside le premier problème. C'était absolument horrible de dépanner quoi que ce soit car je n'étais pas prêt à le souder tout de suite jusqu'à ce que je teste que tout fonctionne, et je ne pouvais pas vraiment tester quoi que ce soit car je ne pouvais pas le souder et ainsi de suite.. don fais pas ça. Problème numéro dos, faire des trous sur le boitier. Je suppose que j'ai mal pris les mesures car aucun des trous du boîtier n'était aligné avec les composants du PCB et j'ai dû les agrandir et les boutons étaient trop hauts sur le PCB et ils étaient toujours enfoncés lorsque je mettais la carte en place aaand puisque je voulais les prises audio sur le côté, j'ai dû agrandir ces trous aussi pour s'adapter aux prises d'abord, puis abaisser la carte pour que l'écran et les boutons passent… le résultat est terrible.

J'ai en quelque sorte rendu les trous terribles moins terribles en superposant le dessus avec du carton mince dans lequel j'ai découpé des trous plus raisonnables pour les composants et.. c'est toujours terrible mais plus agréable à l'œil je pense.

Verdict, je vous suggère de le faire en achetant des composants qui se montent sur le boîtier, et non directement sur le PCB. De cette façon, vous avez plus de liberté dans le placement des composants et moins d'endroits où faire des erreurs.

Étape 14: Aileron

J'ai terminé, mais voici quelque chose que j'aurais fait différemment:

Utilisez des prises audio 3,5 mm de meilleure qualité. Ceux que j'ai utilisés ont tendance à court-circuiter les bornes lors de l'insertion ou du retrait de la prise, ce qui a pour effet de court-circuiter l'alimentation, réinitialisant ainsi l'Arduino, ou de produire de faux déclencheurs. Je l'ai dit à l'étape précédente, mais je le répète. Ne soudez pas la carte Arduino sans en-têtes/prise, cela rend tout type de dépannage ou de téléchargement de nouveau code beaucoup plus difficile. Je pense aussi qu'avoir une led signalant que la chose est allumée aurait été utile car je ne peux souvent pas le dire sans appuyer sur le bouton car l'écran s'éteint. Et la dernière chose, une fonction pause. J'imagine que cela est utile lorsque, par exemple, lorsque vous branchez le capteur PIR, car il a besoin de temps pour chauffer, ou simplement lorsque vous le déplacez, vous ne voulez pas qu'il se déclenche, vous pouvez donc tout mettre en pause, mais vous pouvez aussi simplement tourner hors de la caméra donc.. peu importe.

Une autre chose intéressante est de le velcro sur le trépied car il est le plus susceptible d'être utilisé là-bas.

N'hésitez pas à poser des questions sur ce projet dans les commentaires et j'aimerais savoir si vous le construisez et comment cela s'est passé pour vous.