Possessed Portrait – Updated

DIY jump scare portret helemaal opnieuw met Raspberry Pi 3 B, Python en AtmosFX Video's onlevende portretten. Het is weer oktober en ik wilde een Halloween-project bedenken met een Raspberry Pi. Ik zag een paar spookachtige portretten hier en daar verspreid, maar geen van hen was echt schrikaanjagend, gewoon een simpele beweging.

Ik besloot dat idee verder uit te werken en ging op zoek naar goede video's van het type jump-scare die ik zou kunnen gebruiken. Dit leidde me naar AtmosFx, ze hebben een aantal echt coole Unliving Portrait-video's die elk slechts $ 7,99 kosten. Deze waren perfect voor wat ik in gedachten had en stelden me in staat om meer dan één jump scare-video te hebben die ik handmatig kon selecteren of die ik willekeurig kon laten lopen.

Hier is een video van het voltooide project.

Ik wilde de PIR-code niet helemaal opnieuw schrijven, dus ik zoek op internet naar voorbeelden van toegang tot de PIR met Python. Ik vond een oud artikel van Arc Software waarin een soortgelijk project werd gedemonstreerd.

De code die ik presenteer is grotendeels van hun voorbeeld, maar ik heb er verschillende wijzigingen in aangebracht om aan mijn behoeften te voldoen.

STAP 1:Bouw het LCD-frame

Na het demonteren van de LCD-monitor en het verwijderen van het LCD-paneel en de elektronica meet ik de exacte grootte van het scherm 17 X 11, in staande richting.

Ik heb deze online tool gebruikt om erachter te komen hoe mijn frame-cuts op mijn lcd-scherm passen.

Ik heb een houten frame gebouwd van 1″ x 2″ hout met een binnenafmeting van 17″ x 11″, waarin het LCD-scherm zou passen. Ik sneed 4 stukken die, wanneer ze samen zouden worden ingelijst, de exacte grootte van mijn LCD-scherm zouden hebben en monteerde de LCD in het frame en maakte de LCD gelijk met het LCD-frame. Het fotolijstje wordt aan het LCD-frame bevestigd en laat alle elektronica vanaf de achterkant toegankelijk.

Nadat ik de fotolijst had gekleurd en had laten drogen, gebruikte ik een spijkerhamer om de fotolijst aan het LCD-frame te bevestigen.

Gemonteerd LCD-frame

Vervolgens monteerde ik de Raspberry Pi met een mooie kleine houder van Thingiverse.com (Pi Side Mount) die ik met mijn 3D-printer heb geprint.

Ik heb spiegelhouders gebruikt om het LCD-scherm op zijn plaats te schroeven om te voorkomen dat het verschuift en het gelijk met de voorkant van het frame tegen de fotolijst te houden.

De laatste stap van de montage was om een ​​geheel voor de PIR-sensor te boren en deze aan de GPIO-header van de Pi te bevestigen. De PIR is vrij eenvoudig, hij heeft een hot-, ground- en sensorpin.

STAP 2:Afbeeldingen, video's en code

Ik heb drie van de Unliving Portrait-video's van AtmosFX in mijn project gebruikt.

De eerste hindernis was om de video af te spelen wanneer er beweging werd gedetecteerd, niet alleen constant op het scherm te herhalen. Ik zou de video kunnen laden en deze vervolgens op het eerste frame kunnen pauzeren en als er beweging is, laat het afspelen en wanneer het volledig is gereset en helemaal opnieuw beginnen.

Het zou eenvoudiger zijn om een ​​stilstaand beeld van het eerste frame weer te geven en vervolgens, wanneer beweging wordt gedetecteerd, OMXPlayer te starten om het juiste videobestand af te spelen. Het voordeel hiervan is dat wanneer OMXPlayer werd afgesloten, de geladen nog steeds in de framebuffer zou zijn en op het scherm zou staan.

Om de eerste afbeelding weer te geven heb ik de Linux FBI (framebuffer imageviewer) gebruikt.

De gebruikte speler is OMXPlayer en hoewel het pauzeren ondersteunt, is er geen opdrachtregelcommando dat ik in Python zou kunnen aanroepen om te pauzeren en af ​​te spelen zonder iets als DBuscontrol te implementeren, wat het project te ingewikkeld zou maken.

Mapstructuur:

De mappenstructuur hieronder komt overeen met de paden in het script om toegang te krijgen tot de afbeeldingen en video's. Het pad kan worden gewijzigd zolang de paden in de scripts worden bijgewerkt zodat ze overeenkomen.

Vereiste mapstructuur om met scriptpaden overeen te komen

Afbeeldingen:

Dus voor elke video laadde ik deze in VLC en maakte een schermkap van het eerste frame in dezelfde resolutie waarin de video zich bevond, zodat ze perfect op het scherm zouden overlappen met de video wanneer deze werd afgespeeld .

De drie video's waren van een man, vrouw en kind, dus ik nam van elk een schermkap en noemde ze MaleStart.png, FemaleStart.png en ChildStart.png. Ik heb een map gemaakt in mijn Halloween-project genaamd ScareMedia en de 3 foto's geüpload.

Video's:

Vervolgens noemde ik elke video MaleScare.mp4, FemaleScare.mp4 en ChildScare.mp4 en uploadde ik ze naar de ScareMedia-map.

Code:

Er zijn 2 scripts nodig om de video's over bewegingsdetectie te automatiseren.

pirDetect.py

#!/usr/bin/python
import RPi.GPIO als GPIO
import tijd
import os
klasse detector(object):
def __init__(self, sensor ):
self.callBacks =[]
self.sensor =sensor
self.currState =False
self.prevState =False
GPIO.setmode(GPIO.BOARD )
GPIO.setup(self.sensor, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
def read(self):
self.prevState =self.currState
self. currState =GPIO.input(self.sensor)
def printState(self):
print( “GPIO pin {0} is {1}”.format(self.sensor, “HIGH” if self. currState else “LOW”))
def subscribe(self, callBack):
self.callBacks.append(callBack)
def callBack(self, state):
for fn in self.callBacks:
fn(state)
def start(self):
try:
self.read()
self.printState()
while True:
self.read()
if self.currState !=self.prevState:
self.printState()
self.callBack(self.currState)
time.sleep(.1)
#Sinds fbi de console niet correct herstelt, wat nl de toepassing is afgesloten, we doen een beetje opschonen en behandelen de gebeurtenis KeyboardInterrupt.
behalve (KeyboardInterrupt, SystemExit):
os.system(‘stty sane’)

schrik.py

#!/usr/bin/python
importeer subproces als sp
importtijd
import os
van pirDetect import *
import sys
video =[“ omxplayer”, “bestandsnaam”, “-o”, “beide”, “–win”, “0 0 1280 720”, “–aspect-mode”, “fill”, “–no-osd”, “–orientation” ,“180”,“–vol”, “-600”]
scareFile =“/home/pi/Projects/Halloween/ScareMedia/{0}ScareV.mp4”.format(sys.argv[1])
print(scareFile)
def onMotion(currState):
if currState:
video[1] =scareFile
subVideo =sp.Popen(video)
terwijl subVideo.poll() Geen is:
time.sleep(.1)
def showImage():
os.system(“sudo fbi -T 1 -d /dev/fb0 -noverbose -once /home/pi/Projects/Halloween/ScareMedia/{0}Start.png”.format(
sys.argv[1]))
showImage()
objDetect =detector(7)
objDetect.subscribe(onMotion)
objDetect.start()
os.system(“sudo killall -9 fbi”)

Alles samenbrengen:

Het scare-script kan een enkele parameter worden doorgegeven met de videosequentie die je wilt afspelen. Later zal ik dit automatiseren om een ​​van de drie willekeurig af te spelen.

Er is ook een aanpassing om een ​​Pi-camera toe te voegen en een video van 5 seconden te maken van de persoon die de beweging activeert en deze op de Pi op te slaan telkens wanneer beweging wordt gedetecteerd. (Nog niet geïmplementeerd).

Lees meer details:portret in bezit – bijgewerkt