Gezichtsherkenningsspiegel met geheim compartiment - Ajarnpa

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

Ik ben altijd geïntrigeerd geweest door de altijd creatieve geheime compartimenten die worden gebruikt in verhalen, films en dergelijke. Dus toen ik de wedstrijd voor het geheime compartiment zag, besloot ik zelf met het idee te experimenteren en een gewoon uitziende spiegel te maken die een geheime zijlade opent wanneer de juiste persoon erin kijkt.

Door gebruik te maken van een Raspberry Pi, enige kennis van python-programmering en 8e-klasse winkelklasse, kunnen we dit slimme apparaat maken om objecten in het zicht te verbergen waar alleen de juiste gebruiker toegang toe heeft.

Ik wil deze mensen/platforms waar ik mijn informatie en bronnen vandaan heb gehaald ook speciaal bedanken:

TeCoEd - YouTube-kanaal

Emmet van PiMyLifeUp

MJRoBot op Hackster.io (profiel)

Gaven MacDonald - YouTube-kanaal

Tucker Shannon op Thingiverse (profiel)

Benodigdheden

Lijstbenodigdheden:

• Houten plank (de afmetingen van dit bord waren 42" bij 7,5" bij 5/16")
• Potlood Fotolijst (met glas)
• Spuitverf
• Eenrichtings reflecterende lijm
• Glasreiniger & Rag
• MDF Hout

Benodigdheden voor gezichtsherkenning:

• Raspberry Pi (ik gebruikte de Pi 3 B+ maar er zijn andere opties)
• Cameramodule
• Stappenmotor

Gereedschap:

• Tafelzaag
• Decoupeerzaag
• SchuurpapierHout
• LijmTape
• Meeteenheid
• Schaar
• Spuitfles
• 3D-printer
• Superlijm

Stap 1: Bezuinigingen voor het frame van de doos

Ik kocht een fotolijst in de tweedehandswinkel. Gewoon een waarschuwing, zorg ervoor dat de planken waaruit het frame bestaat minstens 1 1/2 breed zijn. Dit is zodat je andere houten planken erop kunt lijmen met voldoende ruimte om mee te werken. Zorg er ook voor dat het glas in de lijst is helemaal helder. Ik heb per ongeluk een matte gekocht en moest toen een andere lijst kopen alleen voor het heldere glas. Omdat mijn lijst wordt gebruikt, kunnen de afmetingen voor de doosomlijsting variëren.

• Leg het frame in staande richting. Meet de lange zijden (LS) van de zijde met het glasgat op het frame met een extra ½” aan zowel de boven- als onderkant. (d.w.z. voeg een inch toe aan de lange zijde van de meting van het glasgat. Noteer dit en label LSM (Long Side Measurement).
• Meet op dezelfde manier de bovenkant van het gat en voeg een extra 1 "toe. Noteer dit en label SSM (Short Side Measurement).
• Pak je bord en snijd met een tafelzaag twee LSM x 2 "en twee SSM x 2".
• Neem een van de LSM-uitsnijdingen en meet een rechthoek van 2”x1” die 1” van de onderkant en ½” van de linker- en rechterkant is (zoals weergegeven in afbeelding 3).
• Gebruik een decoupeerzaag om het gat uit te snijden. Gebruik vervolgens het schuurpapier om de randen weg te schuren.

Stap 2: Uitsnijdingen voor de lade

Nu zullen we beginnen met het bouwen van de lade (ook wel een geheim compartiment genoemd).

• Knip twee kanten van 4"x 1" uit, een 3 " x 1" (achterrand), een 4 ¼" x 1 ¼" (voorrand) en een 4" x 3 ⅜" (platform).
• Lijm de eerste 4 "x 1" kant langs de 4" kant van het platform. Ik heb een paar gevouwen papieren onder de platformkant gelegd, zodat het een beetje werd opgetild, zodat het niet zou slepen over het gat dat ik in de LS-plank had uitgesneden. Stel 30 minuten in om te drogen.
• Lijm op dezelfde manier de 3 ⅜ "x 1" langs de 3 ⅜" rand van het platform. Stel 30 minuten in om te drogen. Lijm vervolgens de tweede kant van 4 "x 1" aan de andere kant van de eerste. Stel 30 minuten in om te drogen.
• Leg de voorkant voor nu opzij. Het zal het laatste zijn dat op de lade wordt gelijmd.
• Als u klaar bent, controleert u of het in het gat past dat u in de LSM-plank hebt gezaagd. Als dat niet het geval is, schuurt u het gat totdat de lade gemakkelijk in en uit schuift en er geen weerstand is.

Stap 3: Het frame in elkaar zetten

Met alle onderdelen compleet kunnen we beginnen met het monteren van het geheel van het frame.

• Lijm de LSM-plank gecentreerd met het glazen gat met een ½ "aan elke kant. Zorg ervoor dat het is gelijmd met een afstand van ½ "van het gat (zoals weergegeven in afbeelding 1). Stel 30 minuten in om te drogen.
• Lijm de eerste SSM-plank met de rand tegen de binnenkant van de LSM-plank die net was verlijmd. (Gebruik een liniaal om ervoor te zorgen dat het recht wordt gelijmd). Stel 30 minuten in om te drogen.
• Neem de andere LSM-kant en lijm zoals de eerste. Zorg ervoor dat het ½” verwijderd is van het gat en dat de SSM die zojuist was bevestigd aan de binnenkant van de plank is gelijmd. Stel 30 minuten in om te drogen.
• Lijm de laatste SSM op de bovenrand. Aangezien je aan beide kanten twee LSM's hebt, moet je, afhankelijk van hoe recht je ze hebt bevestigd, mogelijk de zijkanten van de SSM schuren om er zeker van te zijn dat hij past (mijn zaagsnede is soms niet mogelijk). Stel 30 minuten in om te drogen.
• Meet de kleine ruimte tussen de onderkant van de lade en het frame. Snijd een stuk MDF-hout met deze afmeting, met 4 ". Je wilt dit stuk dicht bij de lade maken, maar het niet aanraken. Het is bedoeld om de lade met minimale wrijving te ondersteunen.
• Toen alles klaar was, heb ik het frame gespoten, zodat alle stukken bij elkaar pasten.

Stap 4: Voor de spiegel

De eenrichtingsfilmlijm die ik van Amazon kocht, was ongeveer $ 10. Er zijn betere kwaliteit die een beetje duurder zijn als je geïnteresseerd bent. Degene die ik gebruik weerspiegelt, maar je kunt zien dat het geen gewone spiegel is die je in een huis zou zien. De duurdere zullen je die look geven.

• Reinig het glas aan beide zijden met glasreiniger.
• Rol de eenrichtingslijm uit en leg het glas erop. Knip de lijm uit zodat er aan elke kant van het glas minstens ½ "overschot is.
• Zet het glas opzij en maak een kant nat met water. Trek vervolgens de plastic laag van de eenrichtingslijm en spuit de nieuw blootgestelde kant met water.
• Plaats de natte kant van het glas op de natte kant van de lijm. Laat 30 min zitten.
• Draai om en gebruik je duim om eventuele luchtbellen tussen de lijm en het glas plat te maken. Knip vervolgens de overtollige lijm langs de randen af.

Stap 5: Installeer Raspbian Stretch

Omdat dit de eerste keer was dat ik me in de Raspberry Pi-omgeving verdiepte, begon ik te zoeken naar instructies om het besturingssysteem te installeren. Ik vond uiteindelijk een eenvoudige tutorial op YouTube door TeCoEd die het proces doorliep om Stretch op de SD-kaart te installeren (met ook een vrij mooie introductie). Hier is de link naar die tutorial:

In wezen hoeft u alleen maar:

• Formatteer de SD-kaart door uw Drive >> Drive Tools >> Format te selecteren. Download het ZIP-bestand voor Raspian Stretch (hier te vinden:
• Flash de OS-afbeelding naar de SD-kaart. TeCoEd gebruikte Win32 Disk Imager om dit te voltooien. Uiteindelijk heb ik balenaEtcher geïnstalleerd, wat een beetje eenvoudiger leek. (Hier is de downloadlink voor balenaEtcher:
• Eenmaal in balenaEtcher selecteert u “Flash From File” en kiest u het eerder gedownloade ZIP-bestand. Selecteer vervolgens de gewenste SD-kaart (indien niet automatisch geselecteerd). Druk vervolgens op de sappige flitsknop en wacht tot de magie gebeurt.

Eenmaal geïnstalleerd op de SD-kaart, kunt u deze in de Raspberry Pi plaatsen en het generieke Pi-installatieproces doorlopen.

Stap 6: Installeer OpenCV

Nu over naar de meer op gezichtsherkenning gerichte onderdelen. Om gezichten te herkennen, moeten we de OpenCV-bibliotheek downloaden die een groot aantal hulpmiddelen bevat om met computervisie te werken.

Het installeren van OpenCV was voor mij het moeilijkste onderdeel van het softwareaspect. Maar na het volgen van talloze instructies vond ik eindelijk een tutorial van Emmet van PiMyLifeUp die de truc deed die hier te vinden is:

Ik zal deze stappen niet doorlopen, omdat je ze beter kunt volgen via de link (met de gegeven uitleg en de mogelijkheid om gemakkelijker rechtstreeks vanaf de site te kopiëren en plakken).

Stap 7: De camera inschakelen/testen

Nadat ik OpenCV had geïnstalleerd, werd de rest van mijn reis voltooid met behulp van een tutorial van MJRoBot op Hackster.io die hier te vinden is:

Voordat we beginnen, wil ik je eraan herinneren dat ik niet de oorspronkelijke maker van deze scripts ben, maar dat ik uiteindelijk delen ervan heb gewijzigd.

Om te beginnen moeten we de camera testen om er zeker van te zijn dat we video op het scherm kunnen vastleggen. Ik heb ongeveer een uur besteed aan het proberen om het script uit te voeren in stap 3 van MJRoBot. Zoals het leven zou willen, moeten we de camera op de Raspberry Pi inschakelen (het blijkt een goed idee te zijn om de meegeleverde instructies te lezen … mmm nah). Dus na het aansluiten van de camera op de juiste poort volgt u deze stappen:

• Open een opdrachtterminal en typ sudo raspi-config
• Selecteer "Camera inschakelen" (dit kan worden gevonden onder een optie voor apparaten)
• Druk op "Enter"
• Ga naar "Voltooien" En u wordt gevraagd om opnieuw op te starten

Volg dan deze stappen:

• Ga naar het hoofdmenu van de Raspberry (linksboven)
• Voorkeuren
• Raspberry Pi-configuratie
• Interfaces
• Selecteer vervolgens in Camera "Ingeschakeld"
• Dan ok"

Nu zou je dit script met succes moeten kunnen uitvoeren vanuit de tutorial van MJRoBot om de camera uit te testen (onthoud dat al deze code plus een meer diepgaande beschrijving te vinden is in de bovenstaande link naar de tutorial van MJRobot):

importeer numpy als 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) # Camera verticaal kantelen grijs = cv2.cvtColor(frame, cv2. COLOR_BGR2GRAY) cv2.imshow('frame', frame) cv2.imshow('grijs', grijs) k = cv2.waitKey(30) & 0xff if k == 27: # druk op 'ESC' om break cap.release() cv2.destroyAllWindows() te stoppen

De vorige code zou twee vensters moeten weergeven, één in kleur en één in grijstinten. Als je zo ver bent gekomen, denk ik dat je een lekker broodje verdient.

Stap 8: Gegevens verzamelen en trainingsgegevens

In de meegeleverde zelfstudie gaat de auteur veel dieper in op de processen van de code die binnenkort zal worden verstrekt, maar aangezien dit instructies zijn over hoe deze spiegel is gemaakt, zal ik niet dieper ingaan op de geschiedenis of de gecompliceerde mechanica. Ik raad je echter aan om een maand van je leven te lezen over deze twee dingen, omdat ze je geest goed kunnen dienen.

Er moeten nog ongeveer drie scripts worden uitgevoerd voordat we dit allemaal werkend kunnen krijgen. De eerste is voor het verzamelen van gegevens, de tweede is voor het trainen ervan en de laatste is eigenlijk voor herkenning. Het verzamelen van gegevens vereist dat er daadwerkelijke foto's van het gezicht worden gemaakt en op een specifieke plaats worden opgeslagen voor training. De maker van deze code heeft het heel eenvoudig gemaakt om dit allemaal voor elkaar te krijgen, dus ik raad aan om deze instructies te volgen om hoofdpijn te voorkomen.

Open een opdrachtregel en maak een nieuwe map met een leuke naam (ik noemde de mijne FaceRec)

mkdir FaceRec

Verander nu de directory in FaceRec en maak een subdirectory en zorg ervoor dat u deze een naam geeft dataset

cd FaceRec

mkdir-gegevensset

Nu we toch bezig zijn, kunnen we ook de andere submap met de naam trainer maken

mkdir-trainer

Nu kunt u de aanwijzingen van het eerste script uitvoeren en volgen dat foto's van een gebruiker zal vastleggen. (Let op, zorg ervoor dat u de gebruikers-ID invoert als 1, 2, 3 enz.)

import cv2import os cam = cv2. VideoCapture(0) cam.set(3, 640) # stel videobreedte in cam.set(4, 480) # stel videohoogte in face_detector = cv2. CascadeClassifier('haarcascade_frontalface_default.xml') # Voor elk persoon, voer één numeriek gezichts-ID in face_id = input('\n voer gebruikers-ID in end press ==> ') print("\n [INFO] Initialiseren van gezichtsopname. Kijk in de camera en wacht …") # Initialiseer individuele bemonstering van gezichten count = 0 while(True): ret, img = cam.read() img = cv2.flip(img, -1) # flip videobeeld verticaal grijs = cv2.cvtColor(img, cv2. COLOR_BGR2GRAY) faces = face_detector.detectMultiScale (grijs, 1.3, 5) voor (x, y, w, h) in vlakken: cv2.rectangle(img, (x, y), (x+w, y+h), (255, 0, 0), 2) count += 1 # Sla de vastgelegde afbeelding op in de map datasets cv2.imwrite("dataset/User." + str(face_id) + '.' + str(count) + ".jpg", grey[y:y +h, x:x+w]) cv2.imshow('image', img) k = cv2.waitKey(100) & 0xff # Druk op 'ESC' om de video te verlaten als k == 27: break elif count >= 30: # Neem 30 gezichtsmonsters en stop de videopauze k print("\n [INFO] Programma afsluiten en dingen opruimen") cam.release() cv2.destroyAllWindows()

Zorg er op dit moment voor dat je een kussen op de Pi hebt geïnstalleerd. Als dat niet het geval is, voert u de opdracht uit:

pip installeren kussen

Nadat dat is voltooid, kunt u het trainingsscript (tweede script) uitvoeren dat u naadloos een.yaml-bestand zal geven dat in het uiteindelijke script zal worden gebruikt

import cv2import numpy als np van PIL import Image import os # Pad voor gezicht afbeelding database path = 'dataset' herkenner = cv2.face. LBPHFaceRecognizer_create() detector = cv2. CascadeClassifier("haarcascade_frontalface_default.xml"); # functie om de afbeeldingen en labelgegevens te krijgen 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') # converteer het naar grijswaarden img_numpy = np.array(PIL_img, 'uint8') id = int(os.path.split(imagePath)[-1]. split(".")[1]) faces = detector.detectMultiScale(img_numpy) for (x, y, w, h) in faces: faceSamples.append(img_numpy[y:y+h, x:x+w]) ids.append(id) return faceSamples, ids print ("\n [INFO] Gezichten trainen. Het duurt een paar seconden. Wacht …") faces, ids = getImagesAndLabels(pad) herkenner.train(gezichten, np.array(ids)) # Sla het model op in trainer/trainer.yml herkenner.write('trainer/trainer.yml') # herkenner.save() werkte op Mac, maar niet op Pi # Druk het aantal getrainde gezichten af en beëindig het afdrukken van het programma ("\n [INFO] {0} gezichten getraind. Programma verlaten".format(len(np.unique(ids))))

Het leuke van deze set scripts is dat er meerdere gezichten in het systeem kunnen worden ingevoerd, wat betekent dat meerdere personen desgewenst toegang hebben tot de binnenkant van de spiegel.

Hieronder heb ik het Data Capture script en Training script beschikbaar om te downloaden.

Stap 9: Gezichtsherkenningstijd

Ten slotte kunnen we het herkennerscript uitvoeren. Er is meer code aan dit script toegevoegd om het motorproces functioneel te maken, dus ik zal die onderdelen wat grondiger uitleggen. Ik zal het opsplitsen in secties, maar ik zal het hele script aan het einde van de stap plaatsen als dat is wat je zoekt.

We beginnen met het importeren van alle modules die we nodig hebben en stellen vervolgens de GPIO-modus in op GPIO. BCM

importeer numpy als np

import os import tijd import RPi. GPIO als GPIO GPIO.setwarnings(False) GPIO.setmode(GPIO. BCM)

Deze volgende lijst met de naam ControlPin is een reeks getallen die de uitgangspinnen vertegenwoordigen die voor onze stappenmotor zullen worden gebruikt.

ControlePin = [14, 15, 18, 23]

De for-loop stelt deze pinnen in als uitgangen en zorgt er vervolgens voor dat ze zijn uitgeschakeld. Ik heb hier nog een code om de la met een druk op de knop te laten sluiten, maar ik besloot in plaats daarvan een timer te gebruiken.

GPIO.setup(ControlPin, GPIO. OUT)

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

De volgende twee variabelen zijn reeksen die we zullen gebruiken om de motor aan te drijven. Ik heb deze informatie geleerd van een prachtige video van Gaven MacDonald die ik ten zeerste aanbeveel om te bekijken, aangezien hij niet alleen dieper ingaat op de code, maar ook op de eigenlijke motor (hier te vinden: https://www.youtube.com/embed/Dc16mKFA7Fo). In wezen zal elke reeks worden herhaald met behulp van de geneste for-loops in de komende openComp- en closeComp-functies. Als je goed kijkt, is seq2 precies het tegenovergestelde van seq1. Ja, je raadt het al. De ene is om de motor vooruit te bewegen en de andere is om achteruit te rijden.

volgende1 =

volgende2 =

Beginnend met onze openComp-functie maken we een for-loop die 1024 keer zal herhalen. Volgens MacDonald's video zouden 512 iteraties een volledige rotatie van de motor opleveren en ik ontdekte dat ongeveer twee rotaties een goede lengte was, maar dit kan worden aangepast afhankelijk van de maat van een persoon. De volgende for-lus bestaat uit 8 iteraties om rekening te houden met de 8 arrays in seq1 en seq2. En tot slot herhaalt de laatste for-loop vier keer voor de vier items die in elk van deze arrays worden gevonden, evenals voor de 4 GPIO-pinnen waarop onze motor is aangesloten. De regel hieronder selecteert de GPIO-pin en schakelt deze vervolgens in of uit, afhankelijk van de iteratie waarop deze zich bevindt. De regel erna biedt enige buffertijd, zodat onze motor helemaal niet draait. Nadat de motor draait om de lade naar buiten te bewegen, slaapt hij 5 seconden voordat hij verder gaat. Deze tijd kan hier worden aangepast of u kunt de uitgecommentarieerde code inschakelen waarmee u een drukknop kunt gebruiken om het script door te sturen in plaats van een timer.

voor i binnen bereik (1024):

voor halfstep in range(8): voor pin in range(4): GPIO.output(ControlPin[pin], seq1[halfstep] [pin]) time.sleep(.001) '''while True: if GPIO.input (2) == GPIO. LOW: pauze;''' tijd.slaap (5)

De closeComp-functie werkt op een vergelijkbare manier. Nadat de motor terug is bewogen, ga ik verder met het instellen van onze laatste GPIO-pinnen op laag om ervoor te zorgen dat we geen energie verspillen en dan voeg ik nog drie seconden toe voordat ik verder ga.

voor i binnen bereik (1024):

voor halfstep in range(8): voor pin in range(4): GPIO.output(ControlPin[pin], seq2[halfstep] [pin]) time.sleep(.001) print("Compartment Closed") GPIO.output (ControlPin[0], 0) GPIO.output(ControlPin[3], 0) time.sleep(3)

Het grootste deel van het volgende deel wordt gebruikt om de camera in te stellen en de gezichtsherkenning te starten. Nogmaals, de instructies van MKRoBot gaan meer in op de onderdelen, maar voor nu laat ik alleen de onderdelen zien die voor de spiegel zijn gebruikt.

Eerst heb ik de lijstnamen gewijzigd zodat mijn naam in de index staat die ik eraan heb toegewezen tijdens het verzamelen van de gegevens (in mijn geval 1). En toen stelde ik de rest van de waarden in op Geen, omdat ik geen gezichten meer in de dataset had.

namen = ['Geen', 'Daniel', 'Geen', 'Geen', 'Geen', 'Geen']

Onze laatste paar regels code zijn geïmplementeerd in de thicc for-loop. Ik heb een variabele gemaakt om het vertrouwen op te slaan als een geheel getal (intConfidence) voordat het vertrouwen van de variabele in een tekenreeks wordt omgezet. Vervolgens gebruik ik een if-statement om te controleren of het vertrouwen groter is dan 30 en of de id (welke persoon de computer detecteert, in dit geval "Daniel") gelijk is aan mijn naam. Nadat dit is bevestigd, wordt de functie openComp aangeroepen die (zoals eerder uitgelegd) de motor beweegt, na 5 seconden uitschakelt en vervolgens doorgaat naar closeComp die de motor in de tegenovergestelde richting beweegt en wat opruimt voordat verder wordt gegaan met de thicc-lus.

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

openComp() closeComp()

Een bug die ik hier heb gevonden, is dat soms nadat closeComp terugkeert, de code doorgaat, maar de voorwaardelijke if-statement weer waar blijkt te zijn alsof het videofeed leest die zich nog in de buffer bevindt. Hoewel het niet elke keer gebeurt, moet ik nog een manier vinden om ervoor te zorgen dat het nooit gebeurt, dus als iemand ideeën heeft, laat het me dan weten in de reacties.

Hier is dat hele script allemaal op één plek (en net daaronder is het downloadbare):

import cv2

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

Stap 10: De Pi monteren en de motor aansluiten

Het monteren van de Raspberry Pi op het frame was vrij eenvoudig. Ik ontwierp een kleine 90-graden elleboog met één gezicht met een gat en de andere kant volledig plat. Na het 3D-printen van twee hiervan kunnen ze met schroeven aan de Raspberry Pi worden bevestigd op de montagegaten (ik gebruikte de twee gaten aan elke kant van de GPIO-pinnen).

Vervolgens ging ik superlijm gebruiken op de tegenovergestelde zijden van de 3D-geprinte ellebogen om de Pi net boven de lade op het frame te lijmen. Nadat ik de lijm had laten drogen, kon ik de Pi eenvoudig en gemakkelijk op zijn plaats verwijderen of terugplaatsen met slechts twee schroeven. Ik heb de.stl voor de elleboog hieronder gelinkt.

Sluit nu eenvoudig de motordriver aan op de PI met IN1, IN2, IN3, IN4 respectievelijk aansluitend op GPIO 14, 15, 18, 23. Sluit ten slotte de 5v- en aarde-pinnen van de controllerkaart aan op de 5v-uitgang en de massa-pinnen van de Pi.

Hier is een link naar de Pi's Pinout voor wat referentie:

Stap 11: De camera monteren

Het monteren van de camera was iets minder robuust dan de Pi, maar de methode heeft de klus geklaard. Na het ontwerpen en afdrukken van een dunne balk met 2 gaten aan elk uiteinde, heb ik de balk via het montagegat aan de Rasberry Pi bevestigd. Bevestig vervolgens de camera met een andere schroef aan het andere uiteinde van de balk. Ta-da! Het ziet er behoorlijk vliegend uit.

Stap 12: Het lade-verplaatsingsmechanisme maken en monteren

Deze stap werd gemakkelijk gemaakt dankzij de altijd welwillende giften van de maker-gemeenschap. Na een snelle zoektocht op Thingiverse kon ik een lineaire actuator vinden die is gemaakt door TucksProjects (hier te vinden: https://www.thingiverse.com/thing:2987762). Het enige wat je hoefde te doen was het op een SD-kaart te plakken en de printer het werk te laten doen.

Ik ging uiteindelijk naar Fusion 360 en bewerkte de uitloper omdat de as van mijn motor te groot was voor die van TucksProjects. Ik heb de.stl daarvoor hieronder. Nadat de print klaar is, hoeven we hem alleen nog maar in elkaar te zetten door het spoor op de motoras te plaatsen en vervolgens door de motor en de zijkanten van de behuizing te bevestigen met 2 schroeven (zorg ervoor dat u het rek ertussen plaatst voordat u het sluit). Uiteindelijk moest ik een centimeter van het rek afsnijden zodat het tussen de lade en het frame zou passen.

Nu hoeft u alleen nog het mechanisme aan het frame en de lade te bevestigen. “Maar HOE ZULLEN WE DIT DOEN?” je vraagt … yup, zeg het met mij: Super Glue. Zoals op de bovenstaande afbeeldingen te zien is, plaatst u het mechanisme gewoon tegen de onderkant van het frame en duwt u het omhoog tegen het stuk hout waar de lade op schuift. Het is hierbij van essentieel belang dat u probeert het rek/mechanisme zo parallel mogelijk met het frame te krijgen, zodat wanneer het mechanisme beweegt, het de lade recht duwt en niet onder een hoek. Nadat de lijm is opgedroogd, plaatst u wat meer lijm op de rand van het rek en schuift u de lade op zijn plaats en laat u deze drogen. Eenmaal voltooid hebben we een stevig mechanisme om onze geheime lade in en uit te schuiven.

Stap 13: Karton achter de spiegel toevoegen

Om deze bidirectionele film er meer spiegelachtig uit te laten zien, ontdekte ik dat het ons doel goed dient om karton achter het glas te plaatsen. Het gebruikte karton is er een die bij het frame is geleverd, maar elk stuk dat op maat is gesneden, zal werken. Dit zorgt er ook voor dat er geen licht komt van de camera-LED, de motorcontroller of de Pi-shows aan de andere kant van de spiegel. Met alles op zijn plaats gebruik je een potlood om op het karton te markeren waar de camera zit. Gebruik vervolgens een scheermes om een rechthoek te snijden, zodat de camera er doorheen kan kijken als hij op zijn plaats zit.

Stap 14: Het laatste stuk aantrekken

Het laatste wat u moet doen, is het voorste deel van de lade opzij leggen die eerder was gereserveerd. Verplaats de motor zodat de lade uitsteekt. Lijm vervolgens het voorste deel zo dat het ladestuk gecentreerd is (er moet aan alle kanten een klein beetje hangen. Dan kun je het gewoon aan een muur hangen.

Stap 15: Finale

Daar heb je het! Er zijn verschillende verbeteringen die kunnen worden aangebracht, zoals het toevoegen van die drukknop, het kopen van een betere bidirectionele film en het repareren van die bug in de code, maar al met al klopt het werk: het ziet eruit als een spiegel, het herkent de vooraf bepaalde het gezicht van de gebruiker en het opent die schattige kleine la. Zoals altijd hoor ik graag uw gedachten, vragen en memoires in de opmerkingen hieronder.

Algemene beoordeling: 10/10

Opmerkingen: #WouldNotTryAgain… tenzij ik deze instructable zou kunnen volgen;)

Hoofdprijs in de uitdaging van het geheime compartiment