Raspberry Pi 4B - VLC player - Pir Sensor - Camera

Question

I'm starting to know Python, so you can say I'm a newby. For Halloween I'm working with a Python script for a Scare. The idea is to show a nice picture (a paused video) on a tv screen and when motion is detected the video is going to play the rest of the .mp4. In the meantime a camera is recording the faces of the people watching the video and plays that back to them when te video is ready. When the play back is done, it supposed to loopback to the 1st second of the paused video and waits for the next movement.

There's a python file for the scare and one for the pir sensor. The only thing is that this "old" script involves omxplayer. That isn't supported anymore, so I want to use VLC player.

The old script:

#!/usr/bin/python
import subprocess as sp
import time
import os
import datetime
from pirDetect import *
import sys
import random
"""
This script will play any of the videos listed in a random order.
Usage: python ./scareRandom.py [VideoName] [Minutes]

[VideoName] is any of video prefixes in the video_prefix list.
[Minutes] is the time value in minutes of how often you want to rotate to a different video.

Example usage would be : python ./scareRandom.py Male 5.

After each trigger of the on_motion event the script will check and determine if the time elapsed is greater than the 
value you provided in argument 2 and if the elapsed time is longer than your time setting it will randomly pick a new
video prefix and will recursively attempt to choose one that is NOT the current video prefix so it doesn't play the same 
video more than one time in sequence.

To add more or different videos just add to or modify the video_prefix list below.
If adding more videos or changing the defaults you will have to create a start image for each additional video.
The naming structure for the start images and videos are as follows.

[Prefix]ScareV.m4v (MaleScareV.m4v) or [Prefix]ScareV.mp4 (MaleScareV.mp4)
[Prefix]Start.png (MaleStart.png) 
"""


#  initialize variables

video_prefix = ["Male", "Female", "Child"] # This is the list of videos prefixes, you can add additional video
# prefixes here.
video = ["omxplayer", "filename", "-o", "both", "--win", "0 0 1280 720", "--aspect-mode", "fill", "--no-osd",
         "--orientation", "180", "--vol", "-600"]
record = ["raspivid", "-o", "filename", "-n", "-t", "5000", "-rot", "180"]
scare_file = ""
current_prefix = ""
new_prefix = ""
image_name = ""
start_time = time.time()


def change_video():
    global start_time
    global scare_file
    global current_prefix
    global new_prefix
    elapsed_time = time.time() - start_time
    print(str("\nTime since last rotation: {0}".format(datetime.timedelta(seconds=elapsed_time))))
    if elapsed_time > (int(sys.argv[2]) * 60):
        while new_prefix == current_prefix:  # make sure we don't choose the same video
            new_prefix = video_prefix[random.randrange(len(video_prefix))]
        current_prefix = new_prefix
        scare_file = "/home/pi/Projects/Halloween/ScareMedia/{0}ScareV.m4v".format(current_prefix)
        start_time = time.time()
        show_image(current_prefix)
        print("\nUpdating Video to: {0}\n".format(current_prefix))


def getfilename():
    return "/home/pi/Projects/Halloween/Recordings/" + datetime.datetime.now().strftime("%Y-%m-%d_%H.%M.%S.h264")


def sub_proc_wait(params):
    sub = sp.Popen(params)
    while sub.poll() is None:
        time.sleep(.1)


def on_motion(curr_state):
    if curr_state:
        auto_file_name = getfilename()  # Get a time stamped file name
        record[2] = auto_file_name
        sub_record = sp.Popen(record)  # Start recording to capture their fright
        video[1] = scare_file
        sub_proc_wait(video)  # Play the video to scare them
        video[1] = auto_file_name
        sub_proc_wait(video)  # Play back the video we just recorded
        change_video()


def show_image(_image_name):
    os.system("sudo fbi -T 1 -d /dev/fb0 -noverbose -once /home/pi/Projects/Halloween/ScareMedia/{0}Start.png".format(
        _image_name))


def start_up():
    global scare_file
    global image_name
    image_name = arg1
    scare_file = "/home/pi/Projects/Halloween/ScareMedia/{0}ScareV.m4v".format(image_name)
    show_image(image_name)
    obj_detect = detector(7)
    obj_detect.subscribe(on_motion)
    obj_detect.start()
    os.system("sudo killall -9 fbi")


if __name__ == "__main__":

    try:

        arg1 = sys.argv[1]
        if arg1 not in video_prefix:
            raise ValueError('first argument must be Male,Female or Child')
        if sys.argv[2].isdigit():
            arg2 = int(sys.argv[2])
        else:
            raise ValueError('Second argument must be a number')
    except IndexError:
        print("Usage: python ./scareRandom.py [VideoName] [Minutes]")
        sys.exit(1)
    except ValueError as x:
        print(x.message + "\nUsage: python ./scareRandom.py [VideoName] [Minutes]")
        sys.exit(1)

start_up()

And The PirDetect file:

#!/usr/bin/python
import RPi.GPIO as GPIO
import time
import os

class 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)

                except (KeyboardInterrupt, SystemExit):
    #Since fbi doesn't restore the console correctly when the application is exited we do a little clean up.
                        os.system('stty sane')

I tried to replace the omxpler and the fbi but had no luck. I hope someone can help me. Thank you in advance.

I combined several scripts but without any luck.

Answer 1

I've got it working. I saw a script on the internet and placed some code from PiCamera in it. This file does not have the variables like switching the video file, but still it's fun.

What is does: it plays the Scare movie 1 time. Then it pauses. When motion is detected the Scaremovie is beeing played and at the same time the camera is filming the front of the painting. The recorded video is saved within the filename date and time.

from gpiozero import MotionSensor
from time import sleep
from picamera import PiCamera
import vlc
import datetime
playing = set([1,2,3,4])  

# Creating Instance class object
vlc_instance = vlc.Instance()
player = vlc_instance.media_player_new()
player.set_fullscreen(True)
  
# Define Motion Sensor
pir = MotionSensor(4)

# Camera
camera = PiCamera()
camera.rotation = 180


print("Sensor loading")
pir.wait_for_no_motion()
sleep(.1)
player.set_mrl("/path/to/your/video/file.mp4")
player.play()
sleep(.1)

while True:
    print("Ready")
    pir.wait_for_motion()
    sleep(.1)
    print("Motion detected")
    sleep(.1)
    player.set_mrl("/path/to/your/video/file.mp4")
    player.play()
    sleep(.1)
    camera.resolution = (640, 480)
    camera.start_recording('/path/to/your/folder/Recordings/' + datetime.datetime.now().strftime('%Y-%m-%d_%H.%M.%S.h264'))
    camera.wait_recording(10)
    camera.stop_recording()
    while player.get_state() in playing:
        sleep(.1)
        continue        
    print("Finished")
    sleep(.1)
    continue

Have fun with it!