def start_camera(start_mode='camera'):
cad = pifacecad.PiFaceCAD()
switchlistener = pifacecad.SwitchEventListener(chip=cad)
switchlistener.register(0, pifacecad.IODIR_ON, next_mode)
switchlistener.register(1, pifacecad.IODIR_ON, option1)
switchlistener.register(2, pifacecad.IODIR_ON, option2)
switchlistener.register(3, pifacecad.IODIR_ON, option3)
# switchlistener.register(4, pifacecad.IODIR_ON, exit)
switchlistener.register(5, pifacecad.IODIR_ON, take_picture)
switchlistener.register(6, pifacecad.IODIR_ON, previous_option)
switchlistener.register(7, pifacecad.IODIR_ON, next_option)
cad.lcd.display_off()
cad.lcd.blink_off()
cad.lcd.cursor_off()
cad.lcd.clear()
cad.lcd.backlight_on()
splash_screen(cad)
global camera
camera = Camera(cad, start_mode)
camera.current_mode['option'].enter()
camera.update_display()
cad.lcd.display_on()
global should_i_exit
should_i_exit = threading.Barrier(2)
switchlistener.activate()
should_i_exit.wait()
switchlistener.deactivate()
cad.lcd.clear()
cad.lcd.backlight_off()
print("Good-bye!")
def initPiFace():
global cad
global listener
global actionHandler
global gEndBarrier
if gEndBarrier != None:
gEndBarrier.wait()
listener.deactivate()
del gEndBarrier
del listener
gEndBarrier = None
listener = None
if cad != None:
del cad
cad = None
gEndBarrier = threading.Barrier(2)
cad = pifacecad.PiFaceCAD()
cad.lcd.backlight_on()
printToLCD('starter v.1.0', 'select file')
time.sleep(2)
updateDisplayFiles()
listener = pifacecad.SwitchEventListener(chip=cad)
for i in range(8):
h = actionHandler.get(i, printEvent)
listener.register(i, pifacecad.IODIR_FALLING_EDGE, h)
listener.activate()
def init_player():
# Don't autospawn because we want to setup the args later
player = AsyncPlayer(autospawn=False)
# Setup additional args
player.args = ['-really-quiet', '-msglevel', 'global=6']
# hook a subscriber to MPlayer's stdout
player.stdout.hook(handle_data)
# Manually spawn the MPlayer process
player.spawn()
# play a file
player.loadfile('/home/pi/y.mp3')
metadata = player.metadata or {}
cad = init_cad()
cad.lcd.write('P: {name}'.format(name=metadata.get('Title', '')))
listener = pifacecad.SwitchEventListener(chip=cad)
def play_next(event):
print(str(event.pin_num))
player.loadfile('/home/pi/c.mp3')
# for i in range(8):
listener.register(0, pifacecad.IODIR_FALLING_EDGE, play_next)
listener.activate()
# run the asyncore event loop
asyncore.loop()
def scan(self):
#self.cad.lcd.clear()
self.cad.lcd.write(str(self.display_string))
# set the cursor to a sensible position
try:
first_value_select_index = \
self.display_string.instanceindex(ValueSelect)
except TypeError:
# nothing to select, show the string and return
self.cad.lcd.display_on()
return self.display_string.selected_values
else:
col = first_value_select_index + self.start_offset[0]
row = self.start_offset[1]
self.cad.lcd.set_cursor(col, row)
self.cad.lcd.display_on()
# wait for user input
listener = pifacecad.SwitchEventListener(self.cad)
listener.register(7, pifacecad.IODIR_ON, self.right_event)
listener.register(6, pifacecad.IODIR_ON, self.left_event)
listener.register(5, pifacecad.IODIR_ON, self.change_mode_event)
listener.register(4, pifacecad.IODIR_ON, self.return_string_event)
self.wait_for_return_string = threading.Barrier(2)
listener.activate()
self.wait_for_return_string.wait()
listener.deactivate()
return self.display_string.selected_values
def start_routine():
global listener
listener = pifacecad.SwitchEventListener(chip=cad)
for i in range(8):
listener.register(i, pifacecad.IODIR_FALLING_EDGE, button_press)
listener.activate()
def __init__(self):
"""Initialises the ``InputDevice`` object and starts ``pifacecad.SwitchEventListener``. Also, registers callbacks to ``press_key`` method. """
self.cad = pifacecad.PiFaceCAD()
self.listener = pifacecad.SwitchEventListener(chip=self.cad)
for i in range(8):
self.listener.register(i, pifacecad.IODIR_FALLING_EDGE,
self.press_key)
self.listener.activate()
atexit.register(self.atexit)
def button_event_listener(self):
if self.authMode == 1:
self.authCode = self.lockCode
self.listener = pifacecad.SwitchEventListener(chip=self.cad)
for i in range(5):
self.listener.register(i, pifacecad.IODIR_FALLING_EDGE,
self.control_lock)
self.listener.activate()
self.end_barrier.wait()
self.listener.deactivate()
def __init__(self, server):
self.events = server
self.cad = pifacecad.PiFaceCAD()
self.cad.lcd.set_cursor(3, 0)
self.cad.lcd.write("started")
self.cad.lcd.blink_off()
self.cad.lcd.backlight_on()
self.switchlistener = pifacecad.SwitchEventListener(chip=self.cad)
for x in range(8):
self.switchlistener.register(x, pifacecad.IODIR_ON, self.test)
self.switchlistener.activate()
def __init__(self, mycall):
self.listener = pifacecad.SwitchEventListener()
self.listener.register(0, pifacecad.IODIR_ON, self.grab_and_transmit)
self.listener.activate()
self.cad = pifacecad.PiFaceCAD()
self.mycall = mycall
self.active = False
self.cad.lcd.clear()
self.theircall = "PA0NUL"
self.cad.lcd.write("SSTVCam " + self.mycall)
self.cad.lcd.backlight_on()
self.cad.lcd.cursor_off()
self.cad.lcd.blink_off()
def mainFunc():
global volume
listener = pifacecad.SwitchEventListener(chip=cad)
for i in range(8):
listener.register(i, pifacecad.IODIR_FALLING_EDGE, update_pin_text)
listener.activate()
remote_listener = pifacecad.IREventListener(prog='myprogram')
for i in range(8):
remote_listener.register(str(i), print_ir_code)
remote_listener.activate()
#musicMain = threading.Thread(target=musicMainfunc)
radioMain = threading.Thread(target=radioMainFunc)
while True:
musicMainfunc()
radioMain = threading.Thread(target=radioMainFunc)
os.remove(path)
os.mkfifo(path)
radioMain.start()
os.system('mplayer -slave -input file=' + path + ' ' + channelLink[0])
radioMain.join()
def ir2(event):
print("ir 2 pressed")
def ir3(event):
print("ir 3 pressed")
def ir4(event):
print("ir 4 pressed")
pifacecad.init()
sl = pifacecad.SwitchEventListener()
sl.register(0, pifacecad.IODIR_ON, input0)
sl.register(1, pifacecad.IODIR_ON, input1)
sl.register(2, pifacecad.IODIR_ON, input2)
sl.register(3, pifacecad.IODIR_ON, input3)
irl = pifacecad.IREventListener(prog="pifacecadtest",
lircrc="./tests/testlircrc")
irl.register('1', ir1)
irl.register('2', ir2)
irl.register('3', ir3)
irl.register('4', ir4)
sl.activate()
irl.activate()
def setUp(self):
self.barrier = threading.Barrier(2, timeout=5)
self.test_passed = False
self.direction = pifacecad.IODIR_ON
self.listener = pifacecad.SwitchEventListener()
self.listener.register(0, self.direction, self.interrupts_test_helper)
def saveCommand(event):
f = open('previousCommands', 'a')
f.write(command + "\n")
f.close()
# def exit(event):
# global listener
# print("Quiting")
# listener.deactivate()
# sys.exit()
cad.lcd.backlight_on()
listener = pifacecad.SwitchEventListener(cad)
listener.register(6, pifacecad.IODIR_FALLING_EDGE, backward)
listener.register(7, pifacecad.IODIR_FALLING_EDGE, forward)
listener.register(4, pifacecad.IODIR_FALLING_EDGE, exit)
listener.register(0, pifacecad.IODIR_FALLING_EDGE, scrollLeft)
listener.register(1, pifacecad.IODIR_FALLING_EDGE, scrollRight)
listener.register(2, pifacecad.IODIR_FALLING_EDGE, saveCommand)
listener.register(3, pifacecad.IODIR_FALLING_EDGE, enter)
listener.activate()
class _Getch:
# Gets a single character from standard input. Does not echo to the screen.
def __init__(self):
def __init__(self):
self.client = vision.ImageAnnotatorClient()
self.cad = pifacecad.PiFaceCAD()
self.listener = pifacecad.SwitchEventListener(chip=self.cad)
self.camera = picamera.PiCamera()
def start_listener(self):
listener = pifacecad.SwitchEventListener(chip=self.cad)
for i in range(self.num_of_pins):
listener.register(i, pifacecad.IODIR_FALLING_EDGE, self.handlePin)
listener.activate()
cad.lcd.set_cursor(4, 1)
cad.lcd.write_custom_bitmap(3)
cad.lcd.write(playlist)
# Retrieve volume level from mpc and display
def display_volume():
playerstatus = client.status()
volume = (playerstatus['volume'])
cad.lcd.set_cursor(12, 1)
cad.lcd.write(volume)
cad = pifacecad.PiFaceCAD() # creating Pifacecad object
cad.lcd.backlight_on() # put the lcd backlight on
client = MPDClient() # create MPD client object
client.timeout = 1000 # setting network timeout in seconds
client.idletimeout = None # setting timeout timeout for fetching results
client.connect("localhost", 6600) # connect to localhost:6600
client.play() # starts playing
custom_bitmaps() # defines simple char bitmaps to be shown on the display
init_display() # initialise the display
display_channel() # shows current radio station on display
listener = pifacecad.SwitchEventListener(chip=cad) # listens to button pressed
for i in range(8):
listener.register(i, pifacecad.IODIR_FALLING_EDGE, update_pin_text)
listener.activate()
