Synkroniserad video tryptic med hallon pajer och laptop skärmar (9 / 10 steg)

Steg 9: kod

Här är koden. Du kommer att behöva installera pyomxplayer, pexpect och pyOSC. Också, beroende på omxplayer version, kan du behöva ändra pyomxplayer på det sätt det försök att parsa omxplayer's utdata. Detta skript fungerar för både master och slav baserat på värdnamnet. Här är den grundläggande processen:

• När alla maskiner startar upp, de kopiera den relevanta median till ram-enheten, och starta den i omxplayer i pausläge
• Slavarna sedan gå in i en start loop skicka en "färdig" adress till master tills de höra tillbaka.
• Master går in i en slinga för att kontrollera om båda slavar är redo, lyssnar efter en "färdig" adress från var och en.
• När befälhavaren bestämmer som både slavar är redo, skickar den en "lyssna" adress till slavar och slavar kommit ur deras start loop.
• Från och med nu ut, befälhavaren styr slavar genom OSC att återaktivera/paus/spola tillbaka filmerna på obestämd tid.
• Maskiner antingen starta om eller stänga när specifika GPIO stiftet blir inställd på master.

< p > #! / usr/bin/python < br >
importera OSC
importera threading, socket, shutil
importera OMXPlayer från pyomxplayer
från att importera sömn

'''
Thomas Hollier, 2015.

'''

värd = {"master": "192.168.11.45", "slave1": "192.168.11.46", "slave2": "192.168.11.47"}
filmer = {'master':'/home/pi/media/movie_lf.mov', 'slave1':'/home/pi/media/movie_cn.mov', 'slave2':'/home/pi/media/movie_rt.mov'}
movieLength = 60 * 5

hostname = socket.gethostname()

Print "kopiera %s till/var/ramdisk" % filmer [värdnamn]
shutil.Copy (filmer [värdnamn], "/ var/ramdisk /")
filmer [värdnamn] = filmer [värdnamn] .replace ("/ home/pi/media", "/ var/ramdisk")

Tryck "spela filmen från %s" % filmer [värdnamn]
OMX = OMXPlayer(movies[hostname])
Sleep(5)
OMX.toggle_pause()
Sleep(1)
OMX.Rewind()
Sleep(1)

def reboot():
kommandot = "/ usr/bin/sudo/sbin/shutdown - r nu"
importera underprocess
processen = underprocess. Popen(Command.Split(), stdout = underprocess. PIPE)
output = process.communicate() [0]
skriver ut

def poweroff():
kommandot = "/ usr/bin/sudo/sbin/shutdown -h nu"
importera underprocess
processen = underprocess. Popen(Command.Split(), stdout = underprocess. PIPE)
output = process.communicate() [0]
skriver ut

om hostname == "master":
def gpio_check():
importera RPi.GPIO som GPIO
GPIO.setmode (GPIO. BCM)

GPIO.setup (23, GPIO. IN, pull_up_down = GPIO. PUD_UP)
GPIO.setup (24, GPIO. IN, pull_up_down = GPIO. PUD_UP)
samtidigt sant:
input_state = GPIO.input(23)
om input_state == False:
skriva ut ("upptäckt en omstart begäran: knappen 23 nedtryckt")
send_reboot(Slaves['slave1'][2])
send_reboot(Slaves['slave2'][2])
Sleep(.3)
reboot()

input_state = GPIO.input(24)
om input_state == False:
skriva ut ("upptäckt en poweroff begäran: knappen 24 nedtryckt")
send_poweroff(Slaves['slave1'][2])
send_poweroff(Slaves['slave2'][2])
skriva ut ("knappen 24 pressad")
Sleep(.3)
Poweroff()
Sleep(.1)

gpio_thread = threading. Thread(Target=gpio_check)
gpio_thread.start()

# Skicka lyssna
def send_listen(slaveServer):
skriva ut "uppstod slav", slaveServer
MSG = OSC. OSCMessage()
msg.setAddress("/listen") # set OSC adress
MSG.append ("master. \nThe master pausa för 20 sekunder.") # int
slaveServer.send(msg) # skicka den!

# Skicka play kommando
def send_play(slaveServer):
Print "skickar spela till", slaveServer
MSG = OSC. OSCMessage()
msg.setAddress("/play") # set OSC adress
MSG.append ("master") # int
slaveServer.send(msg) # skicka den!

# Skicka toggle_pause kommando
def send_toggle_pause(slaveServer):
Print "skickar toggle_pause till", slaveServer
MSG = OSC. OSCMessage()
msg.setAddress("/toggle_pause") # set OSC adress
MSG.append ("master") # int
slaveServer.send(msg) # skicka den!

# Skicka rewind kommando
def send_rewind(slaveServer):
Print "Skicka spola tillbaka till", slaveServer
MSG = OSC. OSCMessage()
msg.setAddress("/rewind") # set OSC adress
MSG.append ("master") # int
slaveServer.send(msg) # skicka den!

# Skicka omstart kommando
def send_reboot(slaveServer):
Print "sändande omstart till", slaveServer
MSG = OSC. OSCMessage()
msg.setAddress("/reboot") # set OSC adress
MSG.append ("master") # int
slaveServer.send(msg) # skicka den!

# Skicka poweroff kommando
def send_poweroff(slaveServer):
Print "Skicka poweroff till", slaveServer
MSG = OSC. OSCMessage()
msg.setAddress("/poweroff") # set OSC adress
MSG.append ("master") # int
slaveServer.send(msg) # skicka den!

# hanterare för redo adress
def ready_handler (addr, taggar, grejer, källa):
om inte slavar [grejer [0]] [0]:
slavar [grejer [0]] [0] = sant
skriva ut "ställa in %s till klar" % saker [0]

# setup klienter att skicka meddelanden till
slavesReady = False
C1 = OSC. OSCClient()
C2 = OSC. OSCClient()
slavar = {"slave1": [falsk, (värd ['slave1'], 9000), c1], "slave2": [falsk, (värd ['slave2'], 9000), c2]}

# Ställ in själv för att ta emot meddelanden
receive_address = värdar ["master"], 9000
s = OSC. OSCServer(receive_address) # basic
s.addDefaultHandlers()
s.addMsgHandler ("/ ready", ready_handler) # lägga vår funktion

# Starta OSCServer
skriva ut "\nStarting OSCServer. Använd ctrl-C för att sluta."
St = threading. Tråd (target = s.serve_forever)
St.start()

# Ställ in klienter att skicka meddelanden till
slavar ['slave1'] [2] .Anslut (slavar ['slave1'] [1]) # Ange adress för alla meddelanden som följande
slavar ['slave2'] [2] .Anslut (slavar ['slave2'] [1]) # Ange adress för alla meddelanden som följande

#########
# upprätta kommunikation

skriva ut "Master väntar på att höra från slavar."
# Befälhavaren väntar tills båda slavar är redo
samtidigt inte slavesReady:
Sleep(.01)
om slavar ['slave1'] [0] och slavar ['slave2'] [0]:
slavesReady = sant
skriva ut "master har hört från båda slavar"

# Befälhavaren berättar slavar att lyssna
send_listen(Slaves['slave1'][2])
send_listen(Slaves['slave2'][2])
skriva ut "master har sa slavar att lyssna"
skriva ut "Pausa i 20 sekunder"

# fånga andan
Sleep(20)

#########
# mediakontroll

# Vi går in i en oändlig loop där vi
# återaktivera, vänta på filmlängd
# paus, vänta, spola tillbaka, vänta, återaktivera
skriva ut "in huvudloop"
samtidigt sant:
send_toggle_pause(Slaves['slave1'][2])
send_toggle_pause(Slaves['slave2'][2])
OMX.toggle_pause()
Sleep(movieLength)
send_toggle_pause(Slaves['slave1'][2])
send_toggle_pause(Slaves['slave2'][2])
OMX.toggle_pause()
Sleep(2)
send_rewind(Slaves['slave1'][2])
send_rewind(Slaves['slave2'][2])
OMX.Rewind()
Sleep(2)

annat:
thisName = hostname
thisIP = värdar [värdnamn], 9000
masterStatus = {"vaken": [False], "play": [False]}
masterAddress = värdar ["master"], 9000

def send_ready(c):
MSG = OSC. OSCMessage()
msg.setAddress("/ready") # set OSC adress
MSG.append(thisName) # int
försök:
c.send(MSG)
utom:
passera

def listen_handler (lägga till, taggar, saker, källa):
skriva ut "Jag blev tillsagd att lyssna av %s" % grejer [0]
masterStatus ["vaken"] [0] = sant

def play_handler (lägga till, taggar, saker, källa):
skriva ut "Jag blev tillsagd att spela genom %s" % grejer [0]
masterStatus ['spela'] [0] = sant

def toggle_pause_handler (lägga till, taggar, saker, källa):
skriva ut "Jag blev tillsagd att toggle_pause av %s" % grejer [0]
OMX.toggle_pause()

def rewind_handler (lägga till, taggar, saker, källa):
skriva ut "Jag blev tillsagd att spola av %s" % grejer [0]
OMX.Rewind()
masterStatus ["vaken'] = False

def reboot_handler (lägga till, taggar, saker, källa):
skriva ut "Jag blev tillsagd att starta av %s" % grejer [0]
reboot()

def poweroff_handler (lägga till, taggar, saker, källa):
skriva ut "Jag blev tillsagd att avstängning av %s" % grejer [0]
Poweroff()

###########
# skapa en klient för att skicka meddelanden till master
c = OSC. OSCClient()
c.connect (masterAddress)

###########
# lyssna på meddelanden från master
receive_address = thisIP
s = OSC. OSCServer(receive_address) # basic

# definiera hanterare
s.addDefaultHandlers()
s.addMsgHandler ("/ lyssna", listen_handler)
s.addMsgHandler ("/ spela", play_handler)
s.addMsgHandler ("/ toggle_pause", toggle_pause_handler)
s.addMsgHandler ("/ spola tillbaka", rewind_handler)
s.addMsgHandler ("/ starta om", reboot_handler)
s.addMsgHandler ("/ avstängning", poweroff_handler)

# Starta OSCServer
skriva ut "\nStarting OSCServer. Använd ctrl-C för att sluta."
St = threading. Tråd (target = s.serve_forever)
St.start()

skriva ut "%s ansluter till befälhavaren." % hostname
samtidigt sant:
#########i##
# fortsätter att skicka redo signaler förrän herre skickar ett meddelande
# på adressen /listen som får oss ut denna loop
samtidigt inte masterStatus ["vaken"] [0]:
Sleep(.01)
send_ready(c)

##########
# När befälhavaren har tagit kontroll, vi gör ingenting
# och låt huvudenheten uppspelningen genom hanterare < /p >