Miroir de reconnaissance faciale avec compartiment secret : 15 étapes (avec photos)

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

J'ai toujours été intrigué par les compartiments secrets toujours créatifs utilisés dans les histoires, les films, etc. Ainsi, lorsque j'ai vu le concours du compartiment secret, j'ai décidé d'expérimenter l'idée moi-même et de fabriquer un miroir ordinaire qui ouvre un tiroir latéral secret lorsque la bonne personne le regarde.

En utilisant un Raspberry Pi, une certaine connaissance de la programmation python et une classe de magasin de 8e année, nous pouvons créer cet appareil chic pour cacher des objets à la vue de tous auxquels seul le bon utilisateur aura accès.

Je tiens à remercier tout particulièrement ces personnes/plateformes d'où j'ai également obtenu mes informations et ressources:

TeCoEd - Chaîne Youtube

Emmet de PiMyLifeUp

MJRoBot sur Hackster.io (profil)

Gaven MacDonald - Chaîne Youtube

Tucker Shannon sur Thingiverse (profil)

Fournitures

Fournitures de cadre:

• Planche de bois (les dimensions de cette planche étaient de 42" par 7,5" par 5/16")
• Cadre photo crayon (avec verre)
• Peinture en aérosol
• Adhésif réfléchissant unidirectionnel
• Nettoyant pour vitres et chiffon
• Bois MDF

Fournitures de reconnaissance faciale:

• Raspberry Pi (j'ai utilisé le Pi 3 B+ mais il y a d'autres options)
• Module caméra
• Moteur pas à pas

Outils:

• Banc de scie
• Scie sauteuse
• Papier De VerreBois
• Ruban De Colle
• Mesure
• Ciseaux
• Vaporisateur
• Imprimante 3D
• Super colle

Étape 1: Découpes pour le cadre de la boîte

J'ai acheté un cadre photo en brocante. Juste un avertissement, assurez-vous que les planches qui composent le cadre mesurent au moins 1 1/2 de large. C'est ainsi que vous pouvez coller d'autres planches de bois dessus avec suffisamment d'espace pour travailler. Assurez-vous également que le verre dans le cadre est complètement transparent. J'ai acheté un cadre dépoli par accident et j'ai ensuite dû acheter un autre cadre juste pour le verre transparent. Parce que mon cadre est utilisé, les mesures du cadre de la boîte peuvent varier.

• Posez le cadre en orientation portrait. Mesurez les côtés longs (LS) du côté du trou de verre sur le cadre avec un ½" supplémentaire en haut et en bas. (c'est-à-dire ajouter un pouce au côté long de la mesure du trou de verre. Enregistrez-le et étiquetez LSM (mesure du côté long).
• De même, mesurez la partie supérieure du trou et ajoutez 1 po supplémentaire. Enregistrez-le et étiquetez SSM (Short Side Measurement).
• Obtenez votre planche et avec une scie à table, coupez deux LSM x 2" et deux SSM x 2".
• Prenez l'une des coupes LSM et mesurez un rectangle de 2"x1" qui est à 1" du bas et à ½" des côtés gauche et droit (comme indiqué sur l'image 3).
• Utilisez une scie sauteuse pour découper le trou. Ensuite, utilisez le papier de verre pour poncer les bords.

Étape 2: Découpes pour le tiroir

Nous allons maintenant commencer à construire le tiroir (alias compartiment secret).

• Découpez deux côtés de 4" x 1", un 3 ⅜" x 1" (bord arrière), un 4 ¼" x 1 ¼" (bord avant) et un 4" x 3 ⅜" (plate-forme).
• Collez le premier côté de 4" x 1" le long du côté de 4" de la plate-forme. J'ai mis quelques papiers pliés sous le côté de la plate-forme pour qu'il soit légèrement soulevé, de cette façon, il ne glisserait pas sur le trou que j'ai découpé dans la planche LS. Mettre à sécher pendant 30 minutes.
• De même, collez les 3 ⅜” x 1” le long du bord 3 ⅜” de la plate-forme. Mettre à sécher pendant 30 minutes. Collez ensuite le deuxième côté 4" x 1" sur le côté opposé du premier. Mettre à sécher pendant 30 minutes.
• Mettez de côté le bord avant pour le moment. Ce sera la dernière chose collée sur le tiroir.
• Lorsque vous avez terminé, vérifiez s'il s'insère dans le trou que vous avez découpé dans la planche LSM. Sinon, poncez le trou jusqu'à ce que le tiroir glisse facilement vers l'intérieur et l'extérieur et qu'il n'y ait pas de traînée.

Étape 3: Assembler le cadre

Une fois toutes les pièces terminées, nous pouvons commencer à assembler l'intégralité du cadre.

• Collez la planche LSM centrée avec le trou de verre avec un ½" de chaque côté. Assurez-vous qu'il est collé à ½" du trou (comme indiqué sur l'image 1). Mettre à sécher pendant 30 minutes.
• Collez la première planche SSM avec le bord touchant l'intérieur de la planche LSM qui vient d'être collée. (Utilisez une règle pour vous assurer qu'il est collé droit). Mettre à sécher pendant 30 minutes.
• Prenez l'autre côté LSM et collez comme le premier. Assurez-vous qu'il est à ½" du trou et que le SSM qui vient d'être attaché est collé à l'intérieur de la planche. Mettre à sécher pendant 30 minutes.
• Collez le dernier SSM sur le bord supérieur. Étant donné que vous avez deux LSM des deux côtés, selon la façon dont vous les avez attachés, vous devrez peut-être poncer les côtés du SSM pour vous assurer qu'il s'adapte (ma coupe est parfois éteinte). Mettre à sécher pendant 30 minutes.
• Mesurez le petit espace entre le bas du tiroir et le cadre. Coupez un morceau de bois MDF avec cette mesure, par 4". Vous voulez faire cette pièce près du tiroir mais ne la touchez pas. Elle est destinée à soutenir le tiroir avec un minimum de friction.
• Lorsque tout est terminé, j'ai peint le cadre à la bombe pour que toutes les pièces correspondent.

Étape 4: Pour le miroir

Le film adhésif à sens unique que j'ai acheté sur Amazon coûtait environ 10 $. Il y en a de meilleure qualité qui sont un peu plus chères si ça vous intéresse. Celui que j'utilise reflète, mais vous pouvez dire que ce n'est pas un miroir ordinaire que vous verriez dans une maison. Les plus chers vous donneront ce look.

• Nettoyez la vitre avec un nettoyant pour vitres des deux côtés.
• Déroulez l'adhésif à sens unique et posez le verre sur le dessus. Découpez l'adhésif de manière à ce qu'il y ait au moins ½" d'excès de chaque côté du verre.
• Mettez le verre de côté et mouillez-en un côté avec de l'eau. Retirez ensuite la couche de plastique de l'adhésif à sens unique et vaporisez de l'eau sur le côté nouvellement exposé.
• Placez le côté humide du verre sur le côté humide de l'adhésif. Laisser reposer 30 min.
• Retournez et utilisez votre pouce pour aplatir les bulles entre l'adhésif et le verre. Ensuite, coupez l'excès d'adhésif sur les bords.

Étape 5: Installez Raspbian Stretch

C'est la première fois que je me plonge dans l'environnement Raspberry Pi, j'ai commencé à chercher des instructions sur la façon d'installer le système d'exploitation. J'ai finalement trouvé un tutoriel simple sur Youtube par TeCoEd qui a suivi le processus d'installation de Stretch sur la carte SD (avec une introduction plutôt agréable également). Voici le lien vers ce tutoriel:

En gros, tout ce que vous avez à faire est de:

• Formatez la carte SD en sélectionnant Drive >> Drive Tools >> Format. Téléchargez le fichier ZIP pour Raspian Stretch (trouvé ici:
• Flashez l'image du système d'exploitation sur la carte SD. TeCoEd a utilisé Win32 Disk Imager pour effectuer cette opération. J'ai fini par installer balenaEtcher qui semblait un peu plus simple. (Voici le lien de téléchargement pour balenaEtcher:
• Une fois dans balenaEtcher, sélectionnez « Flash From File » et choisissez le fichier ZIP précédemment téléchargé. Ensuite, sélectionnez la carte SD souhaitée (si elle n'est pas sélectionnée automatiquement). Appuyez ensuite sur le bouton flash juteux et attendez que la magie opère.

Une fois installé sur la carte SD, vous pouvez l'insérer dans le Raspberry Pi et suivre le processus d'installation générique du Pi.

Étape 6: Installez OpenCV

Passons maintenant aux parties plus axées sur la reconnaissance faciale. Afin de reconnaître les visages, nous devons télécharger la bibliothèque OpenCV qui contient un grand nombre d'outils pour travailler avec la vision par ordinateur.

L'installation d'OpenCV a été pour moi la partie la plus ardue de l'aspect logiciel. Mais après avoir suivi de nombreuses instructions, j'ai finalement trouvé un tutoriel d'Emmet de PiMyLifeUp qui a fait le tour que l'on trouve ici:

Je ne vais pas parcourir ces étapes car vous serez mieux à même de les suivre à partir du lien (avec les explications données et la possibilité de copier-coller directement depuis le site avec plus de facilité).

Étape 7: Activer/tester la caméra

Après avoir installé OpenCV, le reste de mon parcours a été effectué à l'aide d'un didacticiel de MJRoBot sur Hackster.io trouvé ici:

Avant de commencer, je voudrais vous rappeler que je ne suis pas le créateur original de ces scripts mais que j'ai fini par en modifier certaines parties.

Pour commencer, nous devons tester la caméra pour nous assurer que nous pouvons capturer la vidéo à l'écran. J'ai passé environ une heure à essayer d'exécuter le script fourni à l'étape 3 de MJRoBot. Comme la vie le voudrait, nous devons en fait activer la caméra sur le Raspberry Pi (il s'avère que ce pourrait être une bonne idée de lire les instructions fournies… mmm nah). Donc, après avoir connecté la caméra à son port correct, suivez ces étapes:

• Ouvrez un terminal de commande et tapez sudo raspi-config
• Sélectionnez « Activer la caméra » (cela peut être trouvé sous une option de périphérique)
• Appuyez sur "Entrée"
• Allez dans "Terminer" et vous serez invité à redémarrer

Suivez ensuite ces étapes:

• Accédez au menu principal de Raspberry (en haut à gauche)
• Préférences
• Configuration du Raspberry Pi
• Interfaces
• Puis dans Appareil photo, sélectionnez « Activé »
• Alors ok"

Vous devriez maintenant pouvoir exécuter avec succès ce script à partir du didacticiel de MJRoBot pour tester la caméra (rappelez-vous que tout ce code ainsi qu'une description plus détaillée se trouvent dans le lien fourni ci-dessus vers le didacticiel de MJRobot):

importer numpy en tant que np

import cv2 cap = cv2. VideoCapture(0) cap.set(3, 640) # set Width cap.set(4, 480) # set Height while(True): ret, frame = cap.read() frame = cv2. flip(frame, -1) # Retourner la caméra verticalement gray = cv2.cvtColor(frame, cv2. COLOR_BGR2GRAY) cv2.imshow('frame', frame) cv2.imshow('gray', gray) k = cv2.waitKey(30) & 0xff if k == 27: # appuyez sur 'ESC' pour quitter break cap.release() cv2.destroyAllWindows()

Le code précédent doit afficher deux fenêtres, l'une en couleur et l'autre en niveaux de gris. Si vous êtes arrivé jusqu'ici, je pense que vous méritez un bon sandwich.

Étape 8: Collecter des données et des données d'entraînement

Dans le tutoriel fourni, l'auteur approfondit beaucoup plus les processus du code qui sera bientôt fourni, mais comme il s'agit d'instructions sur la façon dont ce miroir a été fabriqué, je n'entrerai pas dans les détails de l'histoire ni de la mécanique compliquée. Je vous recommande cependant de prendre un mois de votre vie à lire sur ces deux choses car elles peuvent bien servir votre esprit.

Il y a à peu près trois autres scripts à exécuter avant que tout cela fonctionne. Le premier est pour la collecte de données, le second pour l'entraînement et le dernier est en fait pour la reconnaissance. La collecte de données nécessite que des photos réelles du visage soient prises et stockées dans un endroit spécifique pour la formation. Le créateur de ce code a rendu très simple la réalisation de tout cela, je vous recommande donc de suivre ces instructions pour éviter les maux de tête.

Ouvrez une ligne de commande et créez un nouveau répertoire en le nommant quelque chose d'amusant (j'ai appelé le mien FaceRec)

mkdir FaceRec

Maintenant, changez de répertoire en FaceRec et créez un sous-répertoire en vous assurant de le nommer dataset

cd FaceRec

jeu de données mkdir

Pendant que nous y sommes, nous pouvons également créer l'autre sous-répertoire nommé trainer

entraîneur mkdir

Vous pouvez maintenant exécuter et suivre les instructions du premier script qui capturera des images d'un utilisateur. (Juste un avertissement, assurez-vous d'entrer l'identifiant de l'utilisateur sous la forme 1, 2, 3, etc.)

import cv2import os cam = cv2. VideoCapture(0) cam.set(3, 640) # définir la largeur de la vidéo cam.set(4, 480) # définir la hauteur de la vidéo face_detector = cv2. CascadeClassifier('haarcascade_frontalface_default.xml') # Pour chaque personne, entrez un identifiant de visage numérique face_id = input('\n entrez l'identifiant de l'utilisateur et appuyez sur ==> ') print("\n [INFO] Initialisation de la capture de visage. Regardez la caméra et attendez …") # Initialisez le nombre de visages d'échantillonnage individuel count = 0 while(True): ret, img = cam.read() img = cv2.flip(img, -1) # retourne l'image vidéo verticalement gray = cv2.cvtColor(img, cv2. COLOR_BGR2GRAY) faces = face_detector.detectMultiScale (gris, 1.3, 5) pour (x, y, w, h) dans les faces: cv2.rectangle(img, (x, y), (x+w, y+h), (255, 0, 0), 2) count += 1 # Enregistrez l'image capturée dans le dossier des ensembles de données cv2.imwrite("dataset/User." + str(face_id) + '.' + str(count) + ".jpg", gray[y:y +h, x:x+w]) cv2.imshow('image', img) k = cv2.waitKey(100) & 0xff # Appuyez sur 'ESC' pour quitter la vidéo si k == 27: break elif count >= 30: # Prenez 30 échantillons de visage et arrêtez la vidéo k print("\n [INFO] Quitter le programme et nettoyer les choses") cam.release() cv2.destroyAllWindows()

À ce stade, assurez-vous d'avoir installé un oreiller sur le Pi. Sinon, exécutez la commande:

pip installer oreiller

Une fois cette opération terminée, vous pouvez exécuter le script de formation (deuxième script) qui vous fournira de manière transparente un fichier.yaml qui sera utilisé dans le script final

import cv2import numpy as np de PIL import Image import os # Chemin de la base de données d'images de visage chemin = 'dataset' reconnaisseur = cv2.face. LBPHFaceRecognizer_create() detecteur = cv2. CascadeClassifier("haarcascade_frontalface_default.xml"); # fonction pour obtenir les images et les données d'étiquette def getImagesAndLabels(path): imagePaths = [os.path.join(path, f) for f in os.listdir(path)] faceSamples= ids = for imagePath in imagePaths: PIL_img = Image.open(imagePath).convert('L') # le convertit en niveaux de gris img_numpy = np.array(PIL_img, 'uint8') id = int(os.path.split(imagePath)[-1]. split(".")[1]) faces = detect.detectMultiScale(img_numpy) pour (x, y, w, h) dans les faces: faceSamples.append(img_numpy[y:y+h, x:x+w]) ids.append(id) return faceSamples, ids print ("\n [INFO] Entraînement des visages. Cela prendra quelques secondes. Attendez …") faces, ids = getImagesAndLabels(path) Recognizer.train(faces, np.array(ids)) # Enregistrer le modèle dans trainer/trainer.yml reconnaissant.write('trainer/trainer.yml') # reconnaître.save() a fonctionné sur Mac, mais pas sur Pi # Imprimer le nombre de visages entraînés et terminer l'impression du programme ("\n [INFO] {0} visages entraînés. Sortie du programme".format(len(np.unique(ids)))))

Ce qui est bien avec cet ensemble de scripts, c'est que plusieurs visages peuvent être entrés dans le système, ce qui signifie que plusieurs personnes peuvent accéder aux entrailles du miroir si elles le souhaitent.

Ci-dessous, j'ai le script de capture de données et le script de formation disponibles en téléchargement.

Étape 9: Temps de reconnaissance faciale

Enfin, nous pouvons exécuter le script de reconnaissance. Plus de code a été ajouté à ce script afin de rendre le processus moteur fonctionnel, je vais donc expliquer ces parties un peu plus en détail. Je vais le diviser en sections mais je mettrai tout le script à la fin de l'étape si c'est ce que vous recherchez.

Nous allons commencer par importer tous les modules dont nous aurons besoin, puis définir le mode GPIO sur GPIO. BCM

importer numpy en tant que np

import os import time import RPi. GPIO as GPIO GPIO.setwarnings(False) GPIO.setmode(GPIO. BCM)

Cette liste suivante nommée ControlPin est un tableau de nombres qui représente les broches de sortie qui seront utilisées pour notre moteur pas à pas.

ControlPin = [14, 15, 18, 23]

La boucle for définit ces broches comme sorties, puis s'assure qu'elles sont désactivées. J'ai encore du code ici pour laisser le tiroir se fermer en appuyant sur un bouton, mais j'ai décidé d'utiliser une minuterie à la place.

GPIO.setup(ControlPin, GPIO. OUT)

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

Les deux variables suivantes sont des séquences que nous utiliserons pour entraîner le moteur. J'ai appris cette information grâce à une merveilleuse vidéo de Gaven MacDonald que je recommande vivement de regarder car il approfondit non seulement le code mais le moteur lui-même (trouvé ici: https://www.youtube.com/embed/Dc16mKFA7Fo). En substance, chaque séquence sera itérée en utilisant les boucles for imbriquées dans les prochaines fonctions openComp et closeComp. Si vous regardez de près, seq2 est exactement le contraire de seq1. Ouais, vous l'avez deviné. L'un sert à faire avancer le moteur et l'autre à l'inverse.

seq1 =

seq2 =

En commençant par notre fonction openComp, nous créons une boucle for qui itérera 1024 fois. Selon la vidéo de MacDonald, 512 itérations fourniraient une rotation complète du moteur et j'ai trouvé qu'environ deux rotations étaient une bonne longueur, mais cela peut être ajusté en fonction de la taille d'un individu. La prochaine boucle for est composée de 8 itérations afin de prendre en compte les 8 tableaux trouvés dans seq1 et seq2. Et enfin, la dernière boucle for itère quatre fois pour les quatre éléments qui se trouvent dans chacun de ces tableaux ainsi que pour les 4 broches GPIO auxquelles notre moteur est connecté. La ligne ci-dessous sélectionne la broche GPIO, puis l'active ou la désactive en fonction de l'itération sur laquelle elle est activée. La ligne après fournit un certain temps tampon de peur que notre moteur ne tourne du tout. Une fois que le moteur a tourné pour sortir le tiroir, il se met en veille pendant 5 secondes avant de continuer. Ce temps peut être ajusté ici ou vous pouvez activer le code commenté qui permet l'utilisation d'un bouton-poussoir pour avancer avec le script plutôt qu'un minuteur.

pour i dans la plage (1024):

pour un demi-pas dans la plage (8): pour la broche dans la plage(4): GPIO.output(ControlPin[pin], seq1[halfstep] [pin]) time.sleep(.001) '''while True: si GPIO.input (2) == GPIO. LOW: pause;''' time.sleep(5)

La fonction closeComp fonctionne de manière similaire. Une fois que le moteur a reculé, je règle nos dernières broches GPIO sur un niveau bas afin de m'assurer que nous ne gaspillons pas d'énergie, puis j'ajoute trois secondes de plus avant de continuer.

pour i dans la plage (1024):

pour demi-pas dans la plage (8): pour la broche dans la plage(4): GPIO.output(ControlPin[pin], seq2[halfstep] [pin]) time.sleep(.001) print("Compartiment fermé") GPIO.output (ControlPin[0], 0) GPIO.output(ControlPin[3], 0) time.sleep(3)

La majeure partie de la partie suivante est utilisée pour configurer la caméra et commencer la reconnaissance faciale. Encore une fois, les instructions de MKRoBot abordent davantage les pièces, mais pour l'instant, je ne fais que montrer les pièces utilisées pour le miroir.

J'ai d'abord changé les noms de la liste pour que mon nom soit dans l'index que je lui ai attribué lors de la collecte des données (dans mon cas 1). Et puis j'ai défini le reste des valeurs sur Aucun car je n'avais plus de visages dans l'ensemble de données.

noms = ['Aucun', 'Daniel', 'Aucun', 'Aucun', 'Aucun', 'Aucun']

Nos dernières lignes de code sont implémentées dans la boucle for thicc. J'ai créé une variable pour stocker la confiance sous forme d'entier (intConfidence) avant que la confiance de la variable ne soit transformée en chaîne. Ensuite, j'utilise une instruction if pour vérifier si la confiance est supérieure à 30 et si l'identifiant (quelle personne l'ordinateur détecte, dans ce cas, "Daniel") est égal à mon nom. Une fois cela confirmé, la fonction openComp est appelée qui (comme expliqué précédemment) déplace le moteur, démarre après 5 secondes, puis procède à closeComp qui déplace le moteur dans la direction opposée et effectue un nettoyage avant de procéder à la boucle thicc.

si intConfidence > 30 et id == 'Daniel':

openComp() closeComp()

Un bogue que j'ai trouvé ici est que parfois, après le retour de closeComp, le code continue mais l'instruction conditionnelle if est à nouveau vraie comme si elle lisait le flux vidéo qui est toujours dans la mémoire tampon. Bien que cela n'arrive pas à chaque fois, je n'ai pas encore trouvé de moyen de m'assurer que cela n'arrive jamais, donc si quelqu'un a des idées, faites-le moi savoir dans les commentaires.

Voici tout ce script au même endroit (et juste en dessous, c'est le téléchargeable):

importer cv2

import numpy as np import os import time import RPi. GPIO as GPIO GPIO.setwarnings(False) GPIO.setmode(GPIO. BCM) ControlPin = [14, 15, 18, 23] for i in range(4): GPIO.setup (ControlPin, GPIO. OUT) GPIO.output(ControlPin, 0) GPIO.setup(2, GPIO. IN, pull_up_down=GPIO. PUD_DOWN) seq1 =

Étape 10: Montage du Pi et connexion du moteur

Le montage du Raspberry Pi sur le cadre était plutôt simple. J'ai conçu un petit coude à 90 degrés avec une face ayant un trou et l'autre côté étant complètement plat. Après avoir imprimé en 3D deux d'entre eux, ils peuvent être fixés avec des vis au Raspberry Pi sur ses trous de montage (j'ai utilisé les deux trous de chaque côté des broches GPIO).

J'ai ensuite utilisé de la super colle sur les faces opposées des coudes imprimés en 3D pour coller le Pi juste au-dessus du tiroir sur le cadre. Après avoir laissé la colle sécher, j'ai pu retirer ou remplacer le Pi en position simplement et commodément avec juste les deux vis. J'ai le.stl pour le coude lié ci-dessous.

Maintenant, connectez simplement le pilote de moteur au PI avec IN1, IN2, IN3, IN4 en vous connectant aux GPIO 14, 15, 18, 23 respectivement. Enfin, connectez les broches 5v et Ground de la carte contrôleur à la sortie 5v et aux broches Ground du Pi.

Voici un lien vers le Pinout du Pi pour référence:

Étape 11: montage de la caméra

Le montage de la caméra était légèrement moins robuste que le Pi, mais la méthode a fait le travail. Après avoir conçu et imprimé une poutre fine avec 2 trous à chaque extrémité, j'ai attaché la poutre au Rasberry Pi à travers son trou de montage. Ensuite, fixez simplement la caméra à l'extrémité opposée du faisceau avec une autre vis. Ta-da ! Ça a l'air plutôt sympa.

Étape 12: Création et montage du mécanisme de déplacement du tiroir

Cette étape a été rendue facile grâce aux dons toujours bienveillants de la communauté des maker. Après une recherche rapide sur Thingiverse, j'ai pu trouver un actionneur linéaire créé par TucksProjects (trouvé ici: https://www.thingverse.com/thing:2987762). Il ne restait plus qu'à l'insérer sur une carte SD et à laisser l'imprimante faire le travail.

J'ai fini par entrer dans Fusion 360 et j'ai modifié l'éperon car l'arbre de mon moteur était trop grand pour celui fourni par TucksProjects. J'ai le.stl pour cela ci-dessous. Une fois l'impression terminée, il suffit de l'assembler en plaçant l'éperon sur l'arbre moteur, puis en fixant les côtés moteur et boîtier avec 2 vis (en veillant à bien mettre le rack entre les deux avant de le refermer). J'ai fini par devoir couper un pouce du rack pour qu'il s'insère entre le tiroir et le cadre.

Il ne reste plus qu'à fixer le mécanisme au cadre et au tiroir. « MAIS COMMENT ALLONS-NOUS FAIRE ÇA ? » vous demandez… ouais, dites-le avec moi: Super Glue. Comme le montrent les images ci-dessus, placez simplement le mécanisme contre le bas du cadre et poussez-le contre le morceau de bois sur lequel le tiroir glisse. Il est essentiel ici que vous essayiez d'obtenir la crémaillère/mécanisme aussi parallèle que possible au cadre de sorte que lorsque le mécanisme se déplace, il pousse le tiroir droit et non en biais. Une fois la colle sèche, placez un peu plus de colle sur le bord du rack et déplacez le tiroir en position et laissez-le sécher. Une fois terminé, nous avons un mécanisme robuste pour faire glisser notre tiroir secret à l'intérieur et à l'extérieur.

Étape 13: ajouter du carton derrière le miroir

Afin de rendre ce film bidirectionnel plus semblable à un miroir, j'ai trouvé qu'il servait bien notre objectif de placer du carton derrière le verre. Le carton utilisé est celui qui est venu avec le cadre, mais toute pièce coupée pour s'adapter fonctionnera. Cela garantit également qu'aucune lumière provenant de la LED de la caméra, du contrôleur de moteur ou du Pi ne s'affiche de l'autre côté du miroir. Une fois que tout est à sa place, utilisez un crayon pour marquer l'emplacement de la caméra sur le carton. Ensuite, utilisez un rasoir pour découper un rectangle afin que la caméra puisse regarder à travers lorsqu'elle est en place.

Étape 14: Mettre la pièce finale

La dernière chose à faire est de mettre sur la partie avant du tiroir qui a été mis de côté plus tôt. Déplacez le moteur de sorte que le tiroir dépasse. Collez ensuite la partie avant de manière à ce que la pièce du tiroir soit centrée (il doit y avoir un peu d'accrochage de tous les côtés. Ensuite, vous pouvez simplement l'accrocher au mur.

Étape 15: Finaliser

Voilà! Plusieurs améliorations pourraient être apportées, telles que l'ajout de ce bouton-poussoir, l'achat d'un meilleur film bidirectionnel et la correction de ce bogue dans le code, mais dans l'ensemble, le travail est fait: il ressemble à un miroir, il reconnaît le le visage de l'utilisateur et il ouvre ce joli petit tiroir. Comme toujours, j'aimerais entendre vos pensées, vos questions et vos mémoires dans les commentaires ci-dessous.

Note globale: 10/10

Commentaires: #WouldNotTryAgain…sauf si je pouvais suivre cette instructable;)

Grand prix du défi du compartiment secret