Espelho de reconhecimento facial com compartimento secreto: 15 etapas (com fotos)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:35

Sempre fiquei intrigado com os compartimentos secretos sempre criativos usados em histórias, filmes e coisas do gênero. Então, quando eu vi o Concurso do Compartimento Secreto, decidi experimentar a ideia sozinho e fazer um espelho de aparência comum que abre uma gaveta lateral secreta quando a pessoa certa olha para ele.

Ao utilizar um Raspberry Pi, algum conhecimento de programação python e aula de oficina do 8º ano, podemos criar este dispositivo sofisticado para ocultar objetos à vista de todos aos quais apenas o usuário correto terá acesso.

Gostaria de dar um agradecimento especial a essas pessoas / plataformas de onde obtive minhas informações e recursos também:

TeCoEd - Canal do Youtube

Emmet de PiMyLifeUp

MJRoBot no Hackster.io (perfil)

Gaven MacDonald - Canal do Youtube

Tucker Shannon no Thingiverse (perfil)

Suprimentos

Suprimentos para quadros:

• Prancha de madeira (as dimensões desta placa eram 42 "por 7,5" por 5/16 ")
• Porta-retratos a lápis (com vidro)
• Tinta spray
• Adesivo reflexivo unilateral
• Limpador de vidro e pano
• Madeira MDF

Suprimentos de reconhecimento facial:

• Raspberry Pi (usei o Pi 3 B +, mas existem outras opções)
• Módulo de Câmera
• Motor de passo

Ferramentas:

• Serra de mesa
• Jig Saw
• SandpaperWood
• GlueTape
• Medir
• Tesoura
• Garrafa de spray
• impressora 3d
• Super cola

Etapa 1: cortes para a moldura da caixa

Comprei um porta-retratos em uma loja de segunda mão. Apenas um aviso, certifique-se de que as tábuas que compõem a moldura tenham pelo menos 1 1/2 de largura. Isso é para que você possa colar outras tábuas de madeira nela com espaço suficiente para trabalhar. Além disso, certifique-se de que o vidro esteja a moldura é totalmente transparente. Comprei um fosco por acidente e depois tive que comprar outra moldura só para o vidro transparente. Como minha moldura é usada, as medidas para a moldura da caixa podem variar.

• Coloque a moldura na orientação retrato. Meça os lados longos (LS) do lado do orifício de vidro na moldura com ½”adicional na parte superior e inferior. (ou seja, adicione uma polegada ao lado longo da medição do orifício de vidro. Registre isso e marque LSM (Medição do lado longo).
• Da mesma forma, meça o lado superior do orifício e adicione mais 1”. Registre e rotule SSM (Short Side Measurement).
• Pegue sua prancha e com uma serra de mesa, corte dois LSM x 2”e dois SSM x 2”.
• Pegue um dos cortes LSM e meça um retângulo de 2”x1” que está a 1”da parte inferior e ½” dos lados esquerdo e direito (como mostrado na figura 3).
• Use um quebra-cabeças para cortar o buraco. Em seguida, use a lixa para lixar as bordas.

Etapa 2: Cortes para a gaveta

Agora vamos começar a construir a gaveta (também conhecido como Compartimento Secreto).

• Corte dois lados de 4”x 1”, um 3 ⅜”x 1” (borda traseira), um 4 ¼”x 1 ¼” (borda frontal) e um 4”x 3 ⅜” (plataforma).
• Cole o primeiro lado 4”x 1” ao longo do lado 4”da plataforma. Coloquei alguns papéis dobrados sob o lado da plataforma para que ficasse ligeiramente levantado, assim não arrastaria no buraco que cortei na prancha LS. Defina para secar por 30 minutos.
• Da mesma forma, cole 3 ⅜”x 1” ao longo da borda de 3 ⅜”da plataforma. Defina para secar por 30 minutos. Em seguida, cole o segundo lado 4”x 1” no lado oposto do primeiro. Defina para secar por 30 minutos.
• Deixe de lado a borda frontal por enquanto. Será a última coisa colada na gaveta.
• Quando terminar, verifique se ele se encaixa no orifício que você fez na prancha LSM. Caso contrário, lixe o buraco até que a gaveta deslize facilmente para dentro e para fora e não haja resistência.

Etapa 3: juntando a estrutura

Com todas as peças concluídas, podemos começar a montar a totalidade do quadro.

• Cole a prancha LSM centrada no orifício de vidro com ½”de cada lado. Certifique-se de que está colado com ½”de distância do orifício (conforme mostrado na figura 1). Defina para secar por 30 minutos.
• Cole a primeira prancha SSM com a borda tocando o interior da prancha LSM que acabou de ser colada. (Use uma régua para se certificar de que está bem colada). Defina para secar por 30 minutos.
• Pegue o outro lado do LSM e cole semelhante ao primeiro. Certifique-se de que está ½”de distância do orifício e que o SSM que acabou de ser fixado está colado na parte interna da prancha. Defina para secar por 30 minutos.
• Cole o último SSM na borda superior. Uma vez que você tem dois LSMs em ambos os lados, dependendo de quão direto você os conectou, pode ser necessário lixar os lados do SSM para se certificar de que ele se encaixa (meu corte às vezes é incorreto). Defina para secar por 30 minutos.
• Meça o pequeno espaço entre o fundo da gaveta e a moldura. Corte um pedaço de madeira MDF com esta medida, em 4 ". Você quer fazer essa peça perto da gaveta, mas não encosta nela. Destina-se a apoiar a gaveta com o mínimo de atrito.
• Quando tudo pronto, eu pintei a moldura com spray para que todas as peças combinassem.

Etapa 4: para o espelho

O adesivo de filme descartável que comprei na Amazon custava cerca de US $ 10. Existem outros de melhor qualidade que são um pouco mais caros se você estiver interessado. O que eu uso reflete, mas você pode dizer que não é um espelho normal que você veria em uma casa. Os mais caros vão te dar esse visual.

• Limpe o vidro com limpa-vidros em ambos os lados.
• Desenrole o adesivo unilateral e coloque o vidro por cima. Corte o adesivo de forma que haja pelo menos ½”de excesso em cada lado do vidro.
• Coloque o copo de lado e molhe um lado dele com água. Em seguida, retire a camada de plástico do adesivo unilateral e borrife água no lado recém-exposto.
• Coloque o lado úmido do vidro no lado úmido do adesivo. Deixe descansar por 30 minutos.
• Vire e use o polegar para achatar as bolhas entre o adesivo e o vidro. Em seguida, corte o excesso de adesivo em torno das bordas.

Etapa 5: instale o Raspbian Stretch

Por ser a primeira vez que investiguei o ambiente do Raspberry Pi, comecei a procurar instruções sobre como instalar o sistema operacional. Acabei encontrando um tutorial simples no Youtube da TeCoEd que passou pelo processo de instalação do Stretch no cartão SD (com uma introdução bastante adorável também). Aqui está o link para esse tutorial:

Em essência, tudo que você precisa fazer é:

• Formate o cartão SD selecionando seu Drive >> Ferramentas do Drive >> Formatar. Baixe o arquivo ZIP para Raspian Stretch (encontrado aqui:
• Flash da imagem do sistema operacional para o cartão SD. A TeCoEd usou o Win32 Disk Imager para fazer isso. Acabei instalando o balenaEtcher que me pareceu um pouco mais direto. (Aqui está o link de download para balenaEtcher:
• Uma vez em balenaEtcher, selecione “Flash From File” e escolha o arquivo ZIP baixado anteriormente. Em seguida, selecione o cartão SD desejado (se não for selecionado automaticamente). Em seguida, aperte o botão do flash suculento e espere a mágica acontecer.

Uma vez instalado no cartão SD, você pode inseri-lo no Raspberry Pi e passar pelo processo de configuração do Pi genérico.

Etapa 6: Instale o OpenCV

Agora para as partes mais orientadas para o reconhecimento facial. Para reconhecer rostos, devemos baixar a biblioteca OpenCV que contém um grande número de ferramentas para trabalhar com visão computacional.

Instalar o OpenCV foi a parte mais árdua do aspecto do software para mim. Mas depois de seguir inúmeras instruções, finalmente encontrei um tutorial de Emmet, do PiMyLifeUp, que funcionou bem, que pode ser encontrado aqui:

Não percorrerei essas etapas, pois será mais adequado segui-las no link (com as explicações fornecidas e a capacidade de copiar e colar diretamente do site com mais facilidade).

Etapa 7: habilitar / testar a câmera

Depois de instalar o OpenCV, o resto da minha jornada foi concluído usando um tutorial de MJRoBot no Hackster.io encontrado aqui:

Antes de começar, gostaria de lembrar a você que não sou o criador original desses scripts, mas acabei modificando partes deles.

Para começar, devemos testar a câmera para ter certeza de que podemos capturar o vídeo na tela. Passei cerca de uma hora tentando executar o script fornecido na Etapa 3 do MJRoBot. Como a vida teria, realmente precisamos habilitar a câmera no Raspberry Pi (talvez seja uma boa ideia ler as instruções fornecidas … mmm nah). Portanto, após conectar a câmera à porta correta, siga estas etapas:

• Abra um terminal de comando e digite sudo raspi-config
• Selecione “Ativar câmera” (pode ser encontrado em uma opção de dispositivos)
• Pressione “Enter”
• Vá para “Concluir” e você será solicitado a reiniciar

Em seguida, siga estas etapas:

• Vá para o menu principal do Framboesa (canto superior esquerdo)
• Preferências
• Configuração Raspberry Pi
• Interfaces
• Em seguida, em Câmera, selecione “Ativado”
• Então ok"

Agora você deve ser capaz de executar com sucesso este script do tutorial do MJRoBot para testar a câmera (lembre-se de que todo esse código mais uma descrição mais detalhada pode ser encontrada no link fornecido acima para o tutorial do 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 (frame, -1) # Flip camera verticalmente gray = cv2.cvtColor (frame, cv2. COLOR_BGR2GRAY) cv2.imshow ('frame', frame) cv2.imshow ('gray', gray) k = cv2.waitKey (30) & 0xff if k == 27: # pressione 'ESC' para sair do break cap.release () cv2.destroyAllWindows ()

O código anterior deve exibir duas janelas, uma colorida e outra em tons de cinza. Se você chegou até aqui, acho que merece um bom sanduíche.

Etapa 8: coleta de dados e dados de treinamento

No tutorial fornecido, o autor vai em muito mais profundidade sobre os processos do código a ser fornecido em breve, mas como essas são instruções sobre como esse espelho foi feito, não vou entrar em detalhes sobre a história nem sobre a mecânica complicada. No entanto, recomendo que você passe um mês de sua vida lendo sobre essas duas coisas, pois elas podem servir bem à sua mente.

Existem apenas cerca de mais três scripts a serem executados antes que possamos fazer tudo isso funcionar. O primeiro é para coletar dados, o segundo é para treiná-los e o último é realmente para reconhecimento. A coleta de dados requer que fotos reais do rosto sejam tiradas e armazenadas em um local específico para treinamento. O criador deste código tornou muito simples fazer tudo isso, então recomendo seguir estas instruções para evitar dores de cabeça.

Abra uma linha de comando e crie um novo diretório com um nome divertido (chamei meu FaceRec)

mkdir FaceRec

Agora, mude o diretório para FaceRec e crie um subdiretório, certificando-se de nomeá-lo como conjunto de dados

cd FaceRec

conjunto de dados mkdir

Enquanto estamos nisso, também podemos criar o outro subdiretório denominado trainer

treinador mkdir

Agora você pode executar e seguir as instruções do primeiro script que irá capturar as fotos de um usuário. (Apenas para avisar, certifique-se de inserir o ID do usuário 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 pessoa, insira um id numérico de rosto face_id = input ('\ n insira o id do usuário e pressione ==>') print ("\ n [INFO] Inicializando a captura de rosto. Olhe para a câmera e aguarde …") # Inicialize a contagem de amostra de rosto individual count = 0 while (True): ret, img = cam.read () img = cv2.flip (img, -1) # inverter imagem de vídeo verticalmente cinza = cv2.cvtColor (img, cv2. COLOR_BGR2GRAY) faces = face_detector.detectMultiScale (cinza, 1,3, 5) para (x, y, w, h) nas faces: cv2.rectângulo (img, (x, y), (x + w, y + h), (255, 0, 0), 2) count + = 1 # Salve a imagem capturada na pasta de conjuntos de dados cv2.imwrite ("dataset / User." + Str (face_id) + '.' + Str (count) + ".jpg", cinza [y: y + h, x: x + w]) cv2.imshow ('imagem', img) k = cv2.waitKey (100) & 0xff # Pressione 'ESC' para sair do vídeo se k == 27: quebra de contagem elif> = 30: # Faça uma amostra de 30 rostos e interrompa a violação do vídeo k print ("\ n [INFO] Saindo do programa e coisas de limpeza") cam.release () cv2.destroyAllWindows ()

Neste ponto, certifique-se de ter instalado o travesseiro no Pi. Caso contrário, execute o comando:

pip instalar travesseiro

Depois de concluído, você pode executar o script de treinamento (segundo script), que fornecerá um arquivo.yaml que será usado no script final

import cv2import numpy como np de PIL import Image import os # Caminho para banco de dados de imagem de rosto path = 'dataset' reconhecizer = cv2.face. LBPHFaceRecognizer_create () detector = cv2. CascadeClassifier ("haarcascade_frontalface_default.xml"); # função para obter as imagens e os dados do rótulo def getImagesAndLabels (path): imagePaths = [os.path.join (path, f) for f em os.listdir (path)] faceSamples = ids = para imagePath em imagePaths: PIL_img = Image.open (imagePath).convert ('L') # converta para tons de cinza 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) em faces: faceSamples.append (img_numpy [y: y + h, x: x + w]) ids.append (id) return faceSamples, ids print ("\ n [INFO] Faces de treinamento. Demorará alguns segundos. Aguarde …") faces, ids = getImagesAndLabels (path) reconhecizer.train (faces, np.array (ids)) # Salve o modelo em trainer / trainer.yml reconhecizer.write ('trainer / trainer.yml') # reconhecizer.save () funcionou no Mac, mas não no Pi # Imprimir o número de faces treinadas e imprimir o programa final ("\ n [INFO] {0} faces treinadas. Saindo do programa".format (len (np.unique (ids))))

O que é legal sobre este conjunto de scripts é que várias faces podem ser inseridas no sistema, o que significa que vários indivíduos podem acessar as entranhas do espelho, se desejado.

Abaixo, tenho o script de captura de dados e o script de treinamento disponíveis para download.

Etapa 9: Tempo de reconhecimento facial

Finalmente, podemos executar o script do reconhecedor. Mais código foi adicionado a este script para tornar o processo motor funcional, então vou explicar essas partes um pouco mais detalhadamente. Vou dividi-lo em seções, mas colocarei todo o roteiro no final da etapa, se é isso que você deseja.

Começaremos importando todos os módulos de que precisaremos e, em seguida, configurando o modo GPIO para GPIO. BCM

importar numpy como np

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

A próxima lista chamada ControlPin é uma matriz de números que representa os pinos de saída que serão usados para nosso motor de passo.

ControlPin = [14, 15, 18, 23]

O loop for define esses pinos como saídas e, em seguida, certifica-se de que eles estão desligados. Ainda tenho algum código aqui para deixar a gaveta fechar com o apertar de um botão, mas decidi usar um cronômetro em vez disso.

GPIO.setup (ControlPin , GPIO. OUT)

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

As próximas duas variáveis são sequências que usaremos para acionar o motor. Eu aprendi essa informação em um vídeo maravilhoso de Gaven MacDonald que eu recomendo assistir enquanto ele se aprofunda não apenas no código, mas no motor real (encontrado aqui: https://www.youtube.com/embed/Dc16mKFA7Fo). Em essência, cada sequência será iterada usando os loops for aninhados nas funções openComp e closeComp que estão por vir. Se você olhar de perto, seq2 é exatamente o oposto de seq1. Sim, você adivinhou. Um é para mover o motor para frente e o outro é para trás.

seq1 =

seq2 =

Começando com nossa função openComp, criamos um loop for que irá iterar 1024 vezes. De acordo com o vídeo de MacDonald, 512 iterações forneceriam uma rotação completa do motor e eu descobri que cerca de duas rotações era um bom comprimento, mas isso pode ser ajustado dependendo do tamanho de um indivíduo. O próximo for-loop é composto de 8 iterações para considerar os 8 arrays encontrados em seq1 e seq2. E, finalmente, o último for-loop itera quatro vezes para os quatro itens que são encontrados em cada uma dessas matrizes, bem como os 4 pinos GPIO aos quais temos nosso motor conectado. A linha abaixo seleciona o pino GPIO e, em seguida, ativa ou desativa, dependendo de qual iteração ele está ativado. A linha seguinte fornece algum tempo de buffer para que nosso motor não gire. Depois que o motor gira para mover a gaveta para fora, ele dorme por 5 segundos antes de continuar. Este tempo pode ser ajustado aqui ou você pode habilitar o código comentado que permite o uso de um botão para avançar com o script em vez de um cronômetro.

para i no intervalo (1024):

para meio passo no intervalo (8): para pino no intervalo (4): GPIO.output (ControlPin [pin], seq1 [halfstep] [pin]) time.sleep (.001) '' 'enquanto True: se GPIO.input (2) == GPIO. LOW: pausa; '' 'tempo.sono (5)

A função closeComp funciona de maneira semelhante. Depois que o motor se move para trás, procuro definir nossos últimos pinos GPIO para baixo para ter certeza de que não estamos desperdiçando energia e, em seguida, adiciono mais três segundos de tempo antes de continuar.

para i no intervalo (1024):

para meio passo no intervalo (8): para pino no intervalo (4): GPIO.output (ControlPin [pino], seq2 [meio passo] [pino]) time.sleep (.001) print ("Compartimento fechado") GPIO.output (ControlPin [0], 0) GPIO.output (ControlPin [3], 0) time.sleep (3)

A maior parte da próxima parte é usada para configurar a câmera e iniciar o reconhecimento facial. Novamente, as instruções do MKRoBot vão mais para as partes, mas por agora, estou apenas mostrando as partes usadas para o espelho.

Primeiro mudei os nomes das listas para que meu nome estivesse no índice que atribuí enquanto colhia os dados (no meu caso 1). E então eu defini o resto dos valores para Nenhum, já que não tinha mais rostos no conjunto de dados.

nomes = ['Nenhum', 'Daniel', 'Nenhum', 'Nenhum', 'Nenhum', 'Nenhum']

Nossas últimas linhas de código são implementadas no loop for thicc. Eu criei uma variável para armazenar a confiança como um inteiro (intConfidence) antes que a confiança da variável seja transformada em uma string. Então eu uso uma declaração if para verificar se a confiança é maior que 30 e se o id (que pessoa o computador está detectando, neste caso, “Daniel”) é igual ao meu nome. Após isso ser confirmado, a função openComp é chamada, a qual (conforme explicado antes) move o motor, inicia após 5 segundos e, em seguida, prossegue para closeComp, que move o motor na direção oposta e faz alguma limpeza antes de prosseguir com o loop thicc.

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

openComp () closeComp ()

Um bug que encontrei aqui é que às vezes após o retorno de closeComp, o código continua, mas a instrução if condicional é considerada verdadeira novamente, como se estivesse lendo um feed de vídeo que ainda está no buffer. Embora isso não aconteça todas as vezes, eu ainda não encontrei uma maneira de garantir que isso nunca aconteça, então, se alguém tiver alguma ideia, deixe-me saber nos comentários.

Aqui está todo o script em um só lugar (e logo abaixo dele está o disponível para download):

import cv2

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

Etapa 10: Montagem do Pi e conexão do motor

Montar o Raspberry Pi no quadro foi bastante simples. Projetei um pequeno cotovelo de 90 graus com uma face com um orifício e o outro lado totalmente plano. Após a impressão 3D, dois deles podem ser fixados com parafusos no Raspberry Pi em seus orifícios de montagem (usei os dois orifícios em cada lado dos pinos GPIO).

Em seguida, comecei a usar supercola nas faces opostas dos cotovelos impressos em 3D para colar o Pi logo acima da gaveta na moldura. Depois de deixar a cola secar, consegui remover ou recolocar o Pi na posição de maneira simples e conveniente com apenas os dois parafusos. Eu tenho o.stl para o cotovelo no link abaixo.

Agora simplesmente conecte o driver do motor ao PI com IN1, IN2, IN3, IN4 conectando ao GPIO 14, 15, 18, 23 respectivamente. Por fim, conecte os pinos de 5v e de aterramento da placa controladora à saída de 5v e os pinos de aterramento do Pi.

Aqui está um link para a Pinagem do Pi para alguma referência:

Etapa 11: montagem da câmera

Montar a câmera foi um pouco menos robusto do que o Pi, mas o método deu certo. Depois de projetar e imprimir uma viga fina com 2 orifícios em cada extremidade, conectei a viga ao Rasberry Pi por meio de seu orifício de montagem. Em seguida, basta prender a câmera na extremidade oposta do feixe com outro parafuso. Ta-da! Parece muito voar.

Etapa 12: Criação e montagem do mecanismo de movimentação da gaveta

Essa etapa foi facilitada graças aos dons sempre benevolentes da comunidade de criadores. Após uma rápida pesquisa no Thingiverse, consegui encontrar um atuador linear criado por TucksProjects (encontrado aqui: https://www.thingiverse.com/thing:2987762). Tudo o que faltava fazer era colocá-lo em um cartão SD e deixar que a impressora fizesse o trabalho.

Acabei entrando no Fusion 360 e editei o spur, pois o eixo do meu motor era muito grande para o fornecido pela TucksProjects. Eu tenho o.stl para isso abaixo. Depois que a impressão foi feita, só precisamos montá-la colocando a espora no eixo do motor, em seguida, fixando as laterais do motor e do invólucro com 2 parafusos (certificando-se de colocar o rack no meio antes de fechá-lo). Acabei tendo que cortar um centímetro da prateleira para caber entre a gaveta e a moldura.

Agora tudo o que resta é prender o mecanismo à moldura e gaveta. “Mas como faremos isso?” você pergunta … sim, diga comigo: Super Cola. Conforme mostrado nas fotos acima, basta posicionar o mecanismo contra a parte inferior da moldura e empurrar contra o pedaço de madeira onde a gaveta desliza. É vital que você tente colocar o rack / mecanismo o mais paralelo possível à estrutura, de modo que, quando o mecanismo se mover, empurre a gaveta em linha reta e não em ângulo. Depois que a cola secar, coloque um pouco mais de cola na borda do rack e mova a gaveta para a posição e deixe secar. Depois de concluído, temos um mecanismo robusto para deslizar nossa gaveta secreta para dentro e para fora.

Etapa 13: adicionar papelão atrás do espelho

Para fazer com que esse filme bidirecional pareça mais espelhado, descobri que é útil colocar o papelão atrás do vidro. O papelão usado vem com a moldura, mas qualquer peça cortada para caber funcionará. Isso também garante que nenhuma luz do LED da câmera, do controlador do motor ou do Pi apareça no outro lado do espelho. Com tudo no lugar, use um lápis para marcar onde a câmera fica no papelão. Em seguida, use uma navalha para cortar um retângulo para que a câmera possa espiar quando estiver no lugar.

Etapa 14: Colocando a Peça Final

A última coisa a fazer é colocar a parte da frente da gaveta que foi colocada de lado anteriormente. Mova o motor para que a gaveta fique saliente. Em seguida, cole a parte da frente de modo que a peça da gaveta fique centralizada (deve haver um pouco de suspensão em todos os lados. Depois, você pode apenas pendurá-la na parede.

Etapa 15: Final

Aí está! Existem várias melhorias que poderiam ser feitas, como adicionar aquele botão, comprar algum filme bidirecional melhor e consertar o bug no código, mas no geral, ele faz o trabalho: parece um espelho, reconhece o predeterminado o rosto do usuário e abre aquela gavetinha fofa. Como sempre, adoraria ouvir seus pensamentos, perguntas e memórias nos comentários abaixo.

Avaliação geral: 10/10

Comentários: # WouldNotTryAgain… a menos que eu pudesse seguir este instrutível;)

Grande Prêmio no Desafio do Compartimento Secreto