Espejo de reconocimiento facial con compartimento secreto: 15 pasos (con imágenes)

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:40

Siempre me han intrigado los compartimentos secretos siempre creativos que se usan en historias, películas y cosas por el estilo. Entonces, cuando vi el Concurso de Compartimiento Secreto, decidí experimentar con la idea yo mismo y hacer un espejo ordinario que abre un cajón lateral secreto cuando la persona adecuada mira en él.

Al utilizar una Raspberry Pi, algunos conocimientos de programación de Python y una clase de taller de octavo grado, podemos crear este dispositivo elegante para ocultar objetos a simple vista a los que solo el usuario correcto tendrá acceso.

Me gustaría agradecer especialmente a estas personas / plataformas de las que también obtuve mi información y recursos:

TeCoEd - Canal de Youtube

Emmet de PiMyLifeUp

MJRoBot en Hackster.io (perfil)

Gaven MacDonald - Canal de Youtube

Tucker Shannon en Thingiverse (perfil)

Suministros

Suministros de marcos:

• Tablón de madera (las dimensiones de este tablero eran 42 "por 7.5" por 5/16 ")
• Marco de fotos a lápiz (con vidrio)
• Pintura en aerosol
• Adhesivo reflectante unidireccional
• Limpiacristales y trapo
• Madera MDF

Suministros de reconocimiento facial:

• Raspberry Pi (usé el Pi 3 B + pero hay otras opciones)
• Módulo de cámara
• Motor paso a paso

Instrumentos:

• Sierra de mesa
• Sierra caladora
• Papel de lijaMadera
• Cinta adhesiva
• La medida
• Tijeras
• Botella de spray
• impresora 3d
• Super pegamento

Paso 1: cortes para el marco de la caja

Compré un marco de fotos en la tienda de segunda mano. Solo una advertencia, asegúrese de que las tablas que componen el marco tengan al menos 1 1/2 de ancho. Esto es para que pueda pegar otras tablas de madera con suficiente espacio para trabajar. Además, asegúrese de que el vidrio esté El marco es completamente transparente. Compré uno esmerilado por accidente y luego tuve que comprar otro marco solo para el vidrio transparente. Debido a que mi marco se usa, las medidas para el marco de la caja pueden variar.

• Coloque el marco en orientación vertical. Mida los lados largos (LS) del lado del orificio del vidrio en el marco con ½”adicional tanto en la parte superior como en la inferior. (es decir, agregue una pulgada al lado largo de la medida del orificio del vidrio. Registre esto y etiquete LSM (Medición del lado largo).
• De manera similar, mida el lado superior del agujero y agregue 1”adicional. Registre esto y etiquete SSM (Medición del lado corto).
• Obtenga su tabla y con una sierra de mesa, corte dos LSM x 2”y dos SSM x 2”.
• Tome uno de los cortes LSM y mida un rectángulo de 2”x1” que esté a 1”de la parte inferior y ½” de los lados izquierdo y derecho (como se muestra en la imagen 3).
• Use una sierra de vaivén para cortar el agujero. Luego use el papel de lija para lijar los bordes.

Paso 2: cortes para el cajón

Ahora comenzaremos a construir el cajón (también conocido como Compartimiento Secreto).

• Corte dos lados de 4”x 1”, un 3 ⅜”x 1” (borde posterior), un 4 ¼”x 1 ¼” (borde frontal) y una 4”x 3 ⅜” (plataforma).
• Pegue el primer lado de 4 "x 1" a lo largo del lado de 4 "de la plataforma. Puse un par de papeles doblados debajo del costado de la plataforma para que se levantara ligeramente, de esta manera no se arrastraría en el agujero que corté en la tabla LS. Deje secar durante 30 minutos.
• De manera similar, pegue 3 ⅜”x 1” a lo largo del borde de 3 ⅜”de la plataforma. Deje secar durante 30 minutos. Luego pegue el segundo lado de 4”x 1” en el lado opuesto del primero. Deje secar durante 30 minutos.
• Deje a un lado el borde delantero por ahora. Será lo último que pegue en el cajón.
• Cuando termine, verifique si encaja en el orificio que hizo en la tabla LSM. De lo contrario, lije el orificio hasta que el cajón se deslice fácilmente hacia adentro y hacia afuera y no haya arrastre.

Paso 3: armar el marco

Con todas las piezas completas podemos empezar a montar la totalidad del marco.

• Pegue la tabla LSM centrada con el orificio del vidrio con ½”a cada lado. Asegúrese de que esté pegado a ½”de distancia del agujero (como se muestra en la imagen 1). Deje secar durante 30 minutos.
• Pegue la primera tabla SSM con el borde tocando el interior de la tabla LSM que acaba de pegar. (Use una regla para asegurarse de que esté pegada recta). Deje secar durante 30 minutos.
• Tome el otro lado LSM y péguelo de manera similar al primero. Asegúrese de que esté a ½”de distancia del agujero y que el SSM que acaba de colocar esté pegado en el interior de la tabla. Deje secar durante 30 minutos.
• Pegue el último SSM en el borde superior. Dado que tiene dos LSM en ambos lados, dependiendo de qué tan rectos los haya colocado, es posible que deba lijar los lados del SSM para asegurarse de que encaja (mi corte a veces está suelto). Deje secar durante 30 minutos.
• Mide el pequeño espacio entre la parte inferior del cajón y el marco. Corta un trozo de madera MDF con esta medida, por 4 ". Quieres que este trozo esté cerca del cajón pero no lo toques. Está destinado a sostener el cajón con una fricción mínima.
• Cuando terminé, pinté con aerosol el marco para que todas las piezas coincidieran.

Paso 4: para el espejo

El adhesivo de película unidireccional que compré en Amazon costaba alrededor de $ 10. Hay otros de mejor calidad que son un poco más caros si estás interesado. El que yo uso refleja, pero se nota que no es un espejo normal que verías en una casa. Los más caros te darán ese aspecto.

• Limpiar el cristal con limpiacristales por ambos lados.
• Desenrolle el adhesivo unidireccional y coloque el vidrio encima. Corte el adhesivo para que haya al menos ½”de exceso en cada lado del vidrio.
• Deje el vaso a un lado y humedezca un lado con agua. Luego retire la capa de plástico del adhesivo unidireccional y rocíe el lado recién expuesto con agua.
• Coloque el lado húmedo del vidrio sobre el lado húmedo del adhesivo. Deje reposar durante 30 minutos.
• Dale la vuelta y usa el pulgar para aplanar las burbujas entre el adhesivo y el vidrio. Luego corte el exceso de adhesivo de los bordes.

Paso 5: Instale Raspbian Stretch

Siendo esta la primera vez que profundizo en el entorno de Raspberry Pi, comencé a buscar instrucciones sobre cómo instalar el sistema operativo. Finalmente encontré un tutorial sencillo en Youtube de TeCoEd que pasó por el proceso de instalación de Stretch en la tarjeta SD (con una introducción bastante encantadora también). Aquí está el enlace a ese tutorial:

En esencia, todo lo que necesita hacer es:

• Formatee la tarjeta SD seleccionando Drive >> Drive Tools >> Format. Descargue el archivo ZIP para Raspian Stretch (que se encuentra aquí:
• Actualice la imagen del sistema operativo en la tarjeta SD. TeCoEd usó Win32 Disk Imager para completar esto. Terminé instalando balenaEtcher, que parecía un poco más sencillo. (Aquí está el enlace de descarga para balenaEtcher:
• Una vez en balenaEtcher, seleccione "Flash desde archivo" y elija el archivo ZIP descargado previamente. A continuación, seleccione la tarjeta SD deseada (si no se selecciona automáticamente). Luego presiona el jugoso botón de flash y espera a que suceda la magia.

Una vez instalada en la tarjeta SD, puede insertarla en la Raspberry Pi y pasar por el proceso de configuración genérico de Pi.

Paso 6: Instale OpenCV

Ahora pasemos a las partes más orientadas al reconocimiento facial. Para reconocer caras, debemos descargar la biblioteca OpenCV que contiene una gran cantidad de herramientas para trabajar con visión artificial.

La instalación de OpenCV fue la parte más ardua del aspecto del software para mí. Pero después de seguir numerosas instrucciones, finalmente encontré un tutorial de Emmet de PiMyLifeUp que hizo el truco que se encuentra aquí:

No seguiré estos pasos, ya que será más adecuado seguirlos desde el enlace (con las explicaciones dadas y la capacidad de copiar y pegar directamente desde el sitio con más facilidad).

Paso 7: Habilite / pruebe la cámara

Después de instalar OpenCV, el resto de mi viaje se completó usando un tutorial de MJRoBot en Hackster.io que se encuentra aquí:

Antes de comenzar, me gustaría recordarles que no soy el creador original de estos scripts, pero terminé modificando partes de ellos.

Para comenzar, debemos probar la cámara para asegurarnos de que podemos capturar video en la pantalla. Pasé aproximadamente una hora tratando de ejecutar el script proporcionado en el Paso 3 de MJRoBot. Como la vida lo tiene, necesitamos habilitar la cámara en la Raspberry Pi (resulta que podría ser una buena idea leer las instrucciones provistas… mmm nah). Entonces, después de conectar la cámara a su puerto correcto, siga estos pasos:

• Abra una terminal de comandos y escriba sudo raspi-config
• Seleccione "Habilitar cámara" (esto se puede encontrar en una opción de dispositivos)
• Pulsa Enter"
• Vaya a "Finalizar" y se le pedirá que reinicie

Luego sigue estos pasos:

• Vaya al menú principal de la frambuesa (arriba a la izquierda)
• Preferencias
• Configuración de Raspberry Pi
• Interfaces
• Luego, en Cámara, seleccione "Habilitado"
• Entonces OK"

Ahora debería poder ejecutar con éxito este script del tutorial de MJRoBot para probar la cámara (recuerde que todo este código más una descripción más detallada se encuentra en el enlace proporcionado arriba al tutorial de MJRobot):

importar numpy como 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 (marco, -1) # Voltear la cámara verticalmente gris = cv2.cvtColor (marco, cv2. COLOR_BGR2GRAY) cv2.imshow ('marco', marco) cv2.imshow ('gris', gris) k = cv2.waitKey (30) & 0xff si k == 27: # presione 'ESC' para salir de break cap.release () cv2.destroyAllWindows ()

El código anterior debería mostrar dos ventanas, una en color y la otra en escala de grises. Si llegaste tan lejos, creo que te mereces un buen sándwich.

Paso 8: recopilación de datos y datos de entrenamiento

En el tutorial proporcionado, el autor profundiza mucho más sobre los procesos del código que pronto se proporcionará, pero dado que estas son instrucciones sobre cómo se hizo este espejo, no profundizaré en la historia ni en la mecánica complicada. Sin embargo, te recomiendo que dediques un mes de tu vida a leer sobre estas dos cosas, ya que pueden ser útiles para tu mente.

Hay aproximadamente tres scripts más para ejecutar antes de que podamos hacer que todo funcione. El primero es para recopilar datos, el segundo es para entrenarlos y el último es en realidad para el reconocimiento. La recopilación de datos requiere que se tomen fotografías reales del rostro y se almacenen en un lugar específico para el entrenamiento. El creador de este código hizo que todo esto fuera muy sencillo, así que recomiendo seguir estas instrucciones para evitar un dolor de cabeza.

Abra una línea de comando y cree un nuevo directorio con el nombre de algo divertido (llamé al mío FaceRec)

mkdir FaceRec

Ahora, cambie el directorio a FaceRec y cree un subdirectorio asegurándose de nombrarlo conjunto de datos

cd FaceRec

conjunto de datos mkdir

Mientras estamos en eso, también podemos crear el otro subdirectorio llamado entrenador

entrenador mkdir

Ahora puede ejecutar y seguir las instrucciones del primer script que capturará imágenes de un usuario. (Solo un aviso, asegúrese de ingresar la identificación de usuario como 1, 2, 3, etc.)

import cv2import os cam = cv2. VideoCapture (0) cam.set (3, 640) # set video width cam.set (4, 480) # set video height face_detector = cv2. CascadeClassifier ('haarcascade_frontalface_default.xml') # Para cada persona, ingrese un ID de rostro numérico face_id = input ('\ n ingrese el ID de usuario y presione ==>') print ("\ n [INFO] Inicializando la captura de rostros. Mire la cámara y espere…") # Inicialice el conteo de rostros de muestreo individual count = 0 while (True): ret, img = cam.read () img = cv2.flip (img, -1) # voltear imagen de video verticalmente gris = cv2.cvtColor (img, cv2. COLOR_BGR2GRAY) caras = face_detector.detectMultiScale (gris, 1.3, 5) para (x, y, w, h) en caras: cv2.rectangle (img, (x, y), (x + w, y + h), (255, 0, 0), 2) count + = 1 # Guarde la imagen capturada en la carpeta de conjuntos de datos 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 # Presione 'ESC' para salir del video si k == 27: break elif count> = 30: # Tome 30 muestras faciales y detenga la violación de video. k print ("\ n [INFO] Saliendo del programa y cosas de limpieza") cam.release () cv2.destroyAllWindows ()

En este punto, asegúrese de haber instalado la almohada en el Pi. Si no es así, ejecute el comando:

pip instalar almohada

Una vez completado, puede ejecutar el script de entrenamiento (segundo script) que le proporcionará sin problemas un archivo.yaml que se utilizará en el script final

importar cv2import numpy como np desde PIL import Image import os # Ruta para la base de datos de la imagen de la cara ruta = 'dataset' Recognizer = cv2.face. LBPHFaceRecognizer_create () detector = cv2. CascadeClassifier ("haarcascade_frontalface_default.xml"); # función para obtener las imágenes y los datos de la etiqueta def getImagesAndLabels (ruta): imagePaths = [os.path.join (ruta, f) para f en os.listdir (ruta)] faceSamples = ids = para imagePath en imagePaths: PIL_img = Image.open (imagePath).convert ('L') # convertirlo a escala de grises img_numpy = np.array (PIL_img, 'uint8') id = int (os.path.split (imagePath) [- 1]. split (".") [1]) faces = detector.detectMultiScale (img_numpy) para (x, y, w, h) en caras: faceSamples.append (img_numpy [y: y + h, x: x + w]) ids.append (id) return faceSamples, ids print ("\ n [INFO] Entrenar caras. Tardará unos segundos. Espera…") caras, ids = getImagesAndLabels (ruta) Recognizer.train (caras, np.array (ids)) # Guarde el modelo en trainer / trainer.yml Recognizer.write ('trainer / trainer.yml') # Recognizer.save () funcionó en Mac, pero no en Pi # Imprima el número de caras entrenadas y finalice la impresión del programa ("\ n [INFO] {0} rostros entrenados. Saliendo del programa".format (len (np.unique (ids))))

Lo bueno de este conjunto de scripts es que se pueden ingresar varias caras en el sistema, lo que significa que varias personas pueden acceder a las entrañas del espejo si así lo desean.

Abajo tengo el script de captura de datos y el script de entrenamiento disponibles para descargar.

Paso 9: tiempo de reconocimiento facial

Finalmente, podemos ejecutar el script de reconocimiento. Se agregó más código a esta secuencia de comandos para que el proceso del motor sea funcional, así que explicaré esas partes un poco más a fondo. Lo dividiré en secciones, pero pondré el guión completo al final del paso si eso es lo que buscas.

Comenzaremos importando todos los módulos que necesitaremos y luego configurando el modo GPIO en GPIO. BCM

importar numpy como np

importar tiempo de importación del sistema operativo importar RPi. GPIO como GPIO GPIO.setwarnings (Falso) GPIO.setmode (GPIO. BCM)

La siguiente lista llamada ControlPin es una matriz de números que representa los pines de salida que se utilizarán para nuestro motor paso a paso.

ControlPin = [14, 15, 18, 23]

El bucle for establece estos pines como salidas y luego se asegura de que estén apagados. Todavía tengo un código aquí para dejar que el cajón se cierre con solo presionar un botón, pero decidí usar un temporizador en su lugar.

Configuración de GPIO (ControlPin , GPIO. OUT)

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

Las siguientes dos variables son secuencias que usaremos para impulsar el motor. Aprendí esta información de un video maravilloso de Gaven MacDonald que recomiendo ver a medida que profundiza no solo en el código, sino también en el motor real (que se encuentra aquí: https://www.youtube.com/embed/Dc16mKFA7Fo). En esencia, cada secuencia se repetirá mediante el uso de bucles for anidados en las próximas funciones openComp y closeComp. Si observa detenidamente, seq2 es exactamente lo contrario de seq1. Sí, lo adivinaste. Uno es para mover el motor hacia adelante y el otro es para retroceder.

seq1 =

seq2 =

Comenzando con nuestra función openComp creamos un bucle for que iterará 1024 veces. Según el video de MacDonald, 512 iteraciones proporcionarían una rotación completa del motor y descubrí que aproximadamente dos rotaciones era una buena longitud, pero esto se puede ajustar según el tamaño de cada individuo. El siguiente bucle for se compone de 8 iteraciones para tener en cuenta las 8 matrices que se encuentran en seq1 y seq2. Y finalmente, el último bucle for itera cuatro veces para los cuatro elementos que se encuentran en cada uno de estos arreglos, así como para los 4 pines GPIO a los que tenemos nuestro motor conectado. La línea debajo de aquí selecciona el pin GPIO y luego lo enciende o apaga dependiendo de en qué iteración esté. La línea siguiente proporciona un tiempo de búfer para que nuestro motor no gire en absoluto. Después de que el motor gira para sacar el cajón, duerme durante 5 segundos antes de continuar. Este tiempo se puede ajustar aquí o puede habilitar el código comentado que permite el uso de un botón para avanzar con el script en lugar de un temporizador.

para i en el rango (1024):

para medio paso en el rango (8): para el pin en el rango (4): GPIO.output (ControlPin [pin], seq1 [medio paso] [pin]) time.sleep (.001) '' 'while True: if GPIO.input (2) == GPIO. LOW: descanso; '' 'tiempo.sueño (5)

La función closeComp funciona de manera similar. Después de que el motor se mueve hacia atrás, procedo a configurar nuestros últimos pines GPIO a bajo para asegurarme de que no estamos desperdiciando energía y luego agrego tres segundos más de tiempo antes de continuar.

para i en el rango (1024):

para medio paso en el rango (8): para el pin en el rango (4): Salida GPIO (ControlPin [pin], seq2 [medio paso] [pin]) time.sleep (.001) print ("Compartimiento cerrado") GPIO.output (ControlPin [0], 0) GPIO.output (ControlPin [3], 0) time.sleep (3)

La mayor parte de la siguiente parte se utiliza para configurar la cámara y comenzar el reconocimiento facial. Nuevamente, las instrucciones de MKRoBot van más en las partes, pero por ahora, solo estoy mostrando las partes utilizadas para el espejo.

Primero cambié los nombres de la lista para que mi nombre esté en el índice que le asigné mientras recopilaba los datos (en mi caso 1). Y luego configuré el resto de los valores en Ninguno ya que no tenía más caras en el conjunto de datos.

nombres = ['Ninguno', 'Daniel', 'Ninguno', 'Ninguno', 'Ninguno', 'Ninguno']

Nuestras últimas líneas de código se implementan en thicc for-loop. Creé una variable para almacenar la confianza como un número entero (intConfidence) antes de que la variable confianza se convierta en una cadena. Luego uso una declaración if para verificar si la confianza es mayor que 30 y si la identificación (qué persona está detectando la computadora, en este caso, “Daniel”) es igual a mi nombre. Una vez confirmado esto, se llama a la función openComp que (como se explicó antes) mueve el motor, se apaga después de 5 segundos y luego procede a cerrarComp que mueve el motor en la dirección opuesta y hace una limpieza antes de continuar con el bucle thicc.

if intConfidence> 30 e id == 'Daniel':

openComp () closeComp ()

Un error que encontré aquí es que, a veces, después de que closeComp regresa, el código continúa, pero se encuentra que la instrucción if condicional vuelve a ser verdadera, como si estuviera leyendo un video que todavía está en el búfer. Aunque no sucede todas las veces, todavía tengo que encontrar una manera de asegurarme de que nunca suceda, así que si alguien tiene alguna idea, hágamelo saber en los comentarios.

Aquí está todo el script en un solo lugar (y justo debajo de este está el descargable):

importar cv2

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

Paso 10: Montaje del Pi y conexión del motor

Montar la Raspberry Pi en el marco fue bastante simple. Diseñé un codo pequeño de 90 grados con una cara con un agujero y el otro lado completamente plano. Después de imprimir en 3D, dos de estos se pueden unir con tornillos a la Raspberry Pi en sus orificios de montaje (utilicé los dos orificios a cada lado de los pines GPIO).

Luego procedí a usar superpegamento en las caras opuestas de los codos impresos en 3D para pegar el Pi justo encima del cajón en el marco. Después de dejar secar el pegamento, pude quitar o reemplazar el Pi en su posición de manera simple y conveniente con solo los dos tornillos. Tengo el.stl para el codo vinculado a continuación.

Ahora simplemente conecte el controlador del motor al PI con IN1, IN2, IN3, IN4 conectando a GPIO 14, 15, 18, 23 respectivamente. Finalmente, conecte los pines de 5v y de tierra de la placa del controlador a la salida de 5v y los pines de tierra del Pi.

Aquí hay un enlace al Pinout de Pi para alguna referencia:

Paso 11: Montaje de la cámara

Montar la cámara fue un poco menos robusto que el Pi, pero el método hizo el trabajo. Después de diseñar e imprimir una viga delgada con 2 orificios en cada extremo, conecté la viga a la Rasberry Pi a través de su orificio de montaje. Luego, coloque la cámara en el extremo opuesto del rayo con otro tornillo. ¡Ta-da! Se ve muy bien.

Paso 12: Creación y montaje del mecanismo de movimiento del cajón

Este paso se hizo fácil gracias a los siempre benévolos obsequios de la comunidad de creadores. Después de una búsqueda rápida en Thingiverse, pude encontrar un actuador lineal creado por TucksProjects (que se encuentra aquí: https://www.thingiverse.com/thing:2987762). Todo lo que quedaba por hacer era colocarlo en una tarjeta SD y dejar que la impresora hiciera el trabajo.

Terminé yendo a Fusion 360 y edité el espolón ya que el eje de mi motor era demasiado grande para el proporcionado por TucksProjects. Tengo el.stl para eso a continuación. Una vez realizada la impresión, solo tenemos que ensamblarla colocando el espolón en el eje del motor, luego uniendo el motor y los lados de la carcasa con 2 tornillos (asegurándose de colocar el bastidor en el medio antes de cerrarlo). Terminé teniendo que cortar una pulgada de la rejilla para que encajara entre el cajón y el marco.

Ahora todo lo que queda es colocar el mecanismo en el marco y el cajón. "¿PERO CÓMO HACEMOS ESO?" preguntas … sí, dilo conmigo: Super Glue. Como se muestra en las imágenes de arriba, simplemente coloque el mecanismo contra la parte inferior del marco y empújelo contra la pieza de madera sobre la que se desliza el cajón. Es vital aquí que intente que la rejilla / mecanismo esté lo más paralelo posible con el marco para que cuando el mecanismo se mueva empuje el cajón en línea recta y no en ángulo. Una vez que el pegamento se haya secado, coloque un poco más de pegamento en el borde de la rejilla, mueva el cajón a su posición y déjelo secar. Una vez terminado, tenemos un mecanismo robusto para deslizar nuestro cajón secreto hacia adentro y hacia afuera.

Paso 13: agregar cartón detrás del espejo

Para hacer que esta película bidireccional se parezca más a un espejo, descubrí que sirve bien para nuestro propósito colocar cartón detrás del vidrio. El cartón utilizado es el que viene con el marco, pero cualquier pieza cortada a la medida funcionará. Esto también asegura que no haya luz del LED de la cámara, el controlador del motor o el Pi se muestra en el otro lado del espejo. Con todo en su lugar, use un lápiz para marcar dónde se encuentra la cámara en el cartón. Luego, use una navaja para cortar un rectángulo de modo que la cámara pueda mirar a través cuando esté en su lugar.

Paso 14: Ponerse la pieza final

Lo último que debe hacer es colocar la parte frontal del cajón que se reservó anteriormente. Mueva el motor para que el cajón sobresalga. Luego pegue la parte frontal de modo que la pieza del cajón esté centrada (debe haber un poco de colgar en todos los lados. Luego puede colgarla en la pared.

Paso 15: final

¡Ahí tienes! Hay varias mejoras que se podrían hacer, como agregar ese botón, comprar una película bidireccional mejor y corregir ese error en el código, pero en general, hace el trabajo: parece un espejo, reconoce lo predeterminado cara del usuario y abre ese pequeño cajón lindo. Como siempre, me encantaría escuchar sus pensamientos, preguntas y memorias en los comentarios a continuación.

Calificación general: 10/10

Comentarios: # WouldNotTryAgain … a menos que pueda seguir este instructivo;)

Gran premio en el desafío del compartimento secreto