def server(argv): global logger global running pfio.init(init_board=False) global pfd pfd = pfio.PiFaceDigital(init_board=False) global inputs_com global listener if len(argv) > 1: if argv[1] == "init": pfio.init(init_board=True) elif argv[1] == "inputs": listener = pfio.InputEventListener(chip=pfd) for pin in range(8): listener.register(pin, pfio.IODIR_BOTH, input_handle) listener.activate() inputs = list(map(int, sys.argv[2:])) for pin in inputs: inputs_com[pin].append(None) input("Press Enter to stop...") listener.deactivate() else: received = exec_command(argv) print(received) logger.info(received) logger.info("done")
def __init__(self, input_pins, output_pins, keyboard_name, bouncetime, polarity=0, pressed_on_key_down=True, *args, **kwargs): logger.debug( "__init__(input_pins = %s, output_pins = %s, polarity = %s)", input_pins, output_pins, polarity) self.keyboard_name = keyboard_name self._polarity = polarity self._InputPins = list(map(int, input_pins)) self._OutputPins = list(map(int, output_pins)) self._pressed_on_key_down = pressed_on_key_down p.init() self.__listener = p.InputEventListener() for input_pin in self._InputPins: self.__listener.register( pin_num=input_pin, direction=p.IODIR_BOTH, callback=self.event_detect, settle_time=bouncetime / 1000 # from milliseconds to seconds ) self._register_EVENTS_for_pin(input_pin, __name__) self.__listener.activate() # use set_output to register status @ dict self.__OutputStatus for output_pin in self._OutputPins: self.set_output(output_pin, 0, False) self.register_destroy_action()
def __init__(self, ips): self.ips = [] self.ips += ips # Open connections with the Minecraft sessions self.connections = {} for ip in self.ips: try: #self.connections[ip] = Minecraft.create(ip) self.connections[ip] = None except: print("ERROR: cannot connect to Minecraft on %s" % ip) sys.exit(1) # Store the number of connections and initialise the current # connection to be the first one self.connectionNumber = 0 self.numberOfConnection = len(ips) # Setup an input event listener, one per switch on the PiFace pifacedigital = pifacedigitalio.PiFaceDigital() self.listener = pifacedigitalio.InputEventListener(chip=pifacedigital) for i in range(4): self.listener.register(i, pifacedigitalio.IODIR_ON, self.switchPressed)
def initlistener(self): # output init self.inputlistener = pifacedigitalio.InputEventListener( chip=self.pifacedigital) for i in range(4): self.inputlistener.register(i, pifacedigitalio.IODIR_FALLING_EDGE, self.btn_press) self.inputlistener.activate()
def _setup_board(): # if Constant.MACHINE_TYPE_RASPBERRY or Constant.MACHINE_TYPE_ODROID: try: chip_range = [0, 1] board_range = [0, 1, 2, 3] if Constant.IS_MACHINE_ODROID: bus = 32766 else: # Constant.IS_MACHINE_RASPBERRYPI: bus = 0 last_err = '' # for chip in chip_range: # try: # L.l.info("Try piface init on spi spidev{}.{}".format(bus, chip)) # pfio.init(bus=bus, chip_select=chip) # P.chip_list.append(chip) # L.l.info("Initialised piface spi spidev{}.{} OK".format(bus, chip)) # except SPIInitError as ex1: # except Exception as ex1: # last_err += "{}".format(ex1) #if len(P.chip_list) == 0: # L.l.warning("Unable to init spi, probably not spi not enabled, last err={}".format(last_err)) #else: # L.l.info('Found {} piface chips {}'.format(len(P.chip_list), P.chip_list)) #last_err = '' # pftest = PiFaceDigitalMulti(hardware_addr=0, bus=bus, chip_select=0, init_board=True, gpio=24) for chip in chip_range: last_err = '' board_count = len(P.pfd) for board in board_range: try: L.l.info("Try piface pfio on board-hw {} spidev{}.{}".format(board, bus, chip)) pfd = pfio.PiFaceDigital(hardware_addr=board, bus=bus, chip_select=chip, init_board=True) # pfd = PiFaceDigitalMulti( # hardware_addr=board, bus=bus, chip_select=chip, init_board=True, gpio=P.gpio_ports[board]) gpio = pifacecommon.interrupts.GPIO_INTERRUPT_DEVICE_VALUE L.l.info('Default gpio on board {} is {}'.format(board, gpio)) # monkey patch # pifacecommon.interrupts.GPIO_INTERRUPT_DEVICE_VALUE = gpio.replace('25', str(P.gpio_ports[board])) P.listener[board] = pfio.InputEventListener(chip=pfd) P.pfd[board] = pfd P.input_pin_val[board] = [None] * 8 P.input_pin_dir[board] = [None] * 8 gpio = pifacecommon.interrupts.GPIO_INTERRUPT_DEVICE_VALUE L.l.info("Initialised piface pfio listener board-hw {} spidev{}.{} interrupt {}".format( board, bus, chip, gpio)) except Exception as ex2: last_err += "{}".format(ex2) # L.l.info('Piface detect returned exception {}'.format(ex2)) if board_count == len(P.pfd): L.l.info('No board at index {}, errs={}'.format(board, last_err)) if len(P.pfd) == 0: L.l.warning('Piface setup failed, no boards found') else: L.l.info('Initialised {} piface listeners'.format(len(P.pfd))) P.board_init = True except Exception as ex: L.l.critical('Piface setup board failed, err={}'.format(ex), exc_info=True)
def listening(): pifacedigital = pifacedigitalio.PiFaceDigital() listener = pifacedigitalio.InputEventListener(chip=pifacedigital) for i in range(4): listener.register(i, pifacedigitalio.IODIR_ON, PifaceControllerMain.switch_pressed) listener.register(i, pifacedigitalio.IODIR_OFF, PifaceControllerMain.switch_unpressed) listener.activate() print("Started listening")
def __init__(self, emu_window): super().__init__() self.emu_window = emu_window self.event_listeners = list() for i in range(NUM_PIFACE_DIGITALS): listener = pifacedigitalio.InputEventListener(i) for i in range(8): listener.register(i, pifacedigitalio.IODIR_BOTH, self.set_input) self.event_listeners.append(listener)
def __init__(self, bid, inputmode="switch", inputcount=8): threading.Thread.__init__(self, name="Boardmanager: " + str(bid)) # Call Base-class-constructor self.listenersactive = False self.events = Events( ('on_pinup', 'on_pindown', 'on_pintoggle' )) # declare Events (for handling in Main [or elsewhere]) self.boardid = bid # Defines the SPI-Bus Number of the PiFace-Board # Determine if Input is a button or a switch (default) if inputmode == "switch" or inputmode == "button": self.inputmode = inputmode else: self.inputmode = "switch" self.maxinput = inputcount - 1 # Set highest input-Nr. input numbers starting at index 0. therefore highest input-number ist -1 try: self.pfd = pifacedigitalio.PiFaceDigital( self.boardid) # Create a new PifaceDigital Object except: print( "Board with ID=" + bid + " not found. Please check your numbering and Jumpers on your board!" ) return # Initialize input-Event-Listener self.eventlistener = pifacedigitalio.InputEventListener( chip=self.pfd) # New Listenerobject # register Eventlistener for each input input = 0 # Current input number while input <= self.maxinput: # Iterate through all possible inputs try: if self.inputmode == "button": # Button-mode self.eventlistener.register( input, pifacedigitalio.IODIR_FALLING_EDGE, self.buttonpressed ) # Listen for Inputevents on button >>input<< else: # Switch-Mode self.eventlistener.register( input, pifacedigitalio.IODIR_ON, self.switchon ) # Listen for Inputevents for Switch Enable at >>input<< self.eventlistener.register( input, pifacedigitalio.IODIR_OFF, self.switchoff ) # Listen for Inputevents for Switch Disable at >>input<< except: print("Listener for input #" + input + " could not be registered!") input = input + 1 # got to next input
def __init__(self): self.should_stop = False self.pifacedigital = pifacedigitalio.PiFaceDigital() self.moles = [Mole(i, self.pifacedigital) for i in range(NUM_MOLES)] self._current_points = 0 self.max_points = 0 self.inputlistener = pifacedigitalio.InputEventListener() for i in range(4): self.inputlistener.register(i, pifacedigitalio.IODIR_ON, self.hit_mole) self.inputlistener.activate()
def listen(): #setup the listeners listener = pfd.InputEventListener(chip=pf) for i in [0, 1, 3, 4]: listener.register(i, pfd.IODIR_RISING_EDGE, lock_open) listener.register(i, pfd.IODIR_FALLING_EDGE, lock_closed) for i in [2, 5]: listener.register(i, pfd.IODIR_FALLING_EDGE, lock_open) #reset button listener listener.register(6, pfd.IODIR_FALLING_EDGE, reset) listener.activate()
def registerEventListeners(): piface = p.PiFaceDigital() listen8 = p.InputEventListener(chip=piface) listen8.register(7, p.IODIR_RISING_EDGE, eventh) listen8.register(7, p.IODIR_FALLING_EDGE, eventh) listen8.register(6, p.IODIR_RISING_EDGE, eventh) listen8.register(6, p.IODIR_FALLING_EDGE, eventh) listen8.register(5, p.IODIR_RISING_EDGE, eventh) listen8.register(5, p.IODIR_FALLING_EDGE, eventh) listen8.register(4, p.IODIR_RISING_EDGE, eventh) listen8.register(4, p.IODIR_FALLING_EDGE, eventh) listen8.activate()
def __init__(self, emu_window): super().__init__() self.emu_window = emu_window cap = emu_window.pifacedigital.intcapb.value # clear interrupt self.event_listeners = list() for i in range(NUM_PIFACE_DIGITALS): listener = pifacedigitalio.InputEventListener( emu_window.pifacedigital) for i in range(8): listener.register(i, pifacedigitalio.IODIR_BOTH, self.set_input) self.event_listeners.append(listener)
def setUp(self): pifacedigitalio.init() self.direction = pifacedigitalio.IODIR_ON self.barriers = dict() self.board_switch_pressed = list() self.listeners = list() global pifacedigitals for p in pifacedigitals: self.barriers[p.hardware_addr] = threading.Barrier(2, timeout=10) listener = pifacedigitalio.InputEventListener(p.hardware_addr) listener.register(0, self.direction, self.interrupts_test_helper) self.listeners.append(listener)
def __init__(self, parent=Frame): Frame.__init__(self, parent) self.config(bg='beige', padx=30) self.data = 42 self.NglState = False self.pfd = pifacedigitalio.PiFaceDigital() self.listener=pifacedigitalio.InputEventListener(chip=self.pfd) self.relay1Label = MyLabel(self, 'Option Board Relay 1') self.relay2Label = MyLabel(self, 'Option Board Relay 2') self.relay3Label = MyLabel(self, 'Main Board Relay') self.relay4Label = MyLabel(self, 'Unused') self.labelcallbacks = [self.relay1Label.changevalue, self.relay2Label.changevalue, self.relay3Label.changevalue, self.relay4Label.changevalue] for i in range(4): self.listener.register(i, pifacedigitalio.IODIR_ON, self.relay_closed) self.listener.register(i, pifacedigitalio.IODIR_OFF, self.relay_opened) self.listener.activate() self.labelfont = ('arial', 14, 'bold') self.bgColor = '#F6D153' self.fgColor = '#720C7e' self.titlebar = Label(self, text='--- Relay Monitor ---') self.titlebar.pack(side=TOP, anchor="nw", padx=0, pady=0) self.titlebar.config(font=self.labelfont) self.titlebar.config(bg=self.bgColor, fg=self.fgColor) self.inputstate = Label(self, text='RELAY STATE') self.inputstate.pack(side=TOP, anchor="nw", padx=0, pady=10) self.inputstate.config(font=self.labelfont, width=20) self.inputstate.config(bg='white', fg=self.fgColor) # self.QuitButton = Button(self, text='Quit', command=self.quit) # self.QuitButton.pack(side=TOP, anchor="nw") self.relay1Label.pack(side=TOP, anchor="nw") self.relay2Label.pack(side=TOP, anchor="nw") self.relay3Label.pack(side=TOP, anchor="nw") self.relay4Label.pack(side=TOP, anchor="nw") self.labelcallbacks[3]('not used')
def setup(opp, config): """Set up the Raspberry PI PFIO component.""" pifacedigital = PFIO.PiFaceDigital() opp.data[DATA_PFIO_LISTENER] = PFIO.InputEventListener(chip=pifacedigital) def cleanup_pfio(event): """Stuff to do before stopping.""" PFIO.deinit() def prepare_pfio(event): """Stuff to do when Open Peer Power starts.""" opp.bus.listen_once(EVENT_OPENPEERPOWER_STOP, cleanup_pfio) opp.bus.listen_once(EVENT_OPENPEERPOWER_START, prepare_pfio) PFIO.init() return True
def setup(hass, config): """Set up the Raspberry PI PFIO component.""" pifacedigital = PFIO.PiFaceDigital() hass.data[DATA_PFIO_LISTENER] = PFIO.InputEventListener(chip=pifacedigital) def cleanup_pfio(event): """Stuff to do before stopping.""" PFIO.deinit() def prepare_pfio(event): """Stuff to do when Home Assistant starts.""" hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, cleanup_pfio) hass.bus.listen_once(EVENT_HOMEASSISTANT_START, prepare_pfio) PFIO.init() return True
def __init__(self, buttonHandler): self.buttonHandler = buttonHandler self.buttonHandler.setPiFaceManager(self) if piFaceAvail: self.pifacedigital = pifacedigitalio.PiFaceDigital() self.buttonListener = pifacedigitalio.InputEventListener( chip=self.pifacedigital) self.buttonListener.register(0, pifacedigitalio.IODIR_FALLING_EDGE, self.buttonPressed) self.buttonListener.register(1, pifacedigitalio.IODIR_FALLING_EDGE, self.buttonPressed) self.buttonListener.register(2, pifacedigitalio.IODIR_FALLING_EDGE, self.buttonPressed) self.buttonListener.register(3, pifacedigitalio.IODIR_FALLING_EDGE, self.buttonPressed) self.buttonListener.register(4, pifacedigitalio.IODIR_FALLING_EDGE, self.buttonPressed) self.buttonListener.activate() return super(PiFaceManager, self).__init__()
def __init__(self, name: str) -> None: global INSTANTIATED if INSTANTIATED: raise RuntimeError("Only one PiFace keyboard may be instantiated") INSTANTIATED = True super().__init__(name) pifacedigitalio.init() self.__listener = pifacedigitalio.InputEventListener() for input_pin in self._inputs: self.__listener.register( pin_num=input_pin, direction=pifacedigitalio.IODIR_BOTH, callback=self.event_detect, settle_time=self._bouncetime / 1000, ) self.__listener.activate()
def _setup_board(): try: bus, chip = 0, 0 try: for chip in [0, 1]: pfio.init(bus=bus, chip_select=chip) L.l.info("Initialised piface spi spidev{}.{}".format(bus, chip)) except Exception as ex: pass for board in [0, 1, 2, 3]: try: pfd = pfio.PiFaceDigital(hardware_addr=board, init_board=True) P.pfd[board] = pfd P.listener[board] = pfio.InputEventListener(chip=P.pfd[board]) L.l.info("Initialised piface listener board {}".format(board)) except NoPiFaceDigitalDetectedError as ex: pass P.board_init = True except Exception as ex: L.l.critical('Piface setup board failed, err={}'.format(ex))
class mainView(): if __name__ == "__main__": listener = pifacedigitalio.InputEventListener(chip=pifacedigital) for i in range(4): listener.register(i, pifacedigitalio.IODIR_ON, switch_pressed) listener.register(i, pifacedigitalio.IODIR_OFF, switch_unpressed) listener.activate() print("running...") while (True): ret, frame = cap.read() cv2.imshow('My Do-Nothing Application', frame) if cv2.waitKey(20) & 0xFF == ord('q'): cap.release() cv2.destroyAllWindows() listener.deactivate() break
def main(): output_pins, input_pins, relay_number, ldap_match_attr, ldap_owner_attr, ldap_server, ldap_port, ldap_base_dn, ldap_use_ssl, ldap_user, ldap_user_secret = read_config( "config.yml") pifacedigital = pifacedigitalio.PiFaceDigital() door = Door(pifacedigital, output_pins, input_pins, relay_number) # To fix startup problems we toggle the lock door.close() sleep(0.5) door.open() sleep(0.5) door.close() listener = pifacedigitalio.InputEventListener(chip=pifacedigital) listener.register(1, pifacedigitalio.IODIR_ON, door.event_on_door_switch) logger.info("Activating listener") listener.activate() cardmonitor = CardMonitor() cardobserver = PrintObserver(door, ldap_base_dn, ldap_server, ldap_port, ldap_use_ssl, ldap_user, ldap_user_secret, ldap_match_attr, ldap_owner_attr) cardmonitor.addObserver(cardobserver) while True: sleep(60) cardmonitor.deleteObserver(cardobserver)
def setup(hass: HomeAssistant, config: ConfigType) -> bool: """Set up the Raspberry PI PFIO component.""" _LOGGER.warning( "The PiFace Digital I/O (PFIO) integration is deprecated and will be removed " "in Home Assistant Core 2022.4; this integration is removed under " "Architectural Decision Record 0019, more information can be found here: " "https://github.com/home-assistant/architecture/blob/master/adr/0019-GPIO.md" ) pifacedigital = PFIO.PiFaceDigital() hass.data[DATA_PFIO_LISTENER] = PFIO.InputEventListener(chip=pifacedigital) def cleanup_pfio(event): """Stuff to do before stopping.""" PFIO.deinit() def prepare_pfio(event): """Stuff to do when Home Assistant starts.""" hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, cleanup_pfio) hass.bus.listen_once(EVENT_HOMEASSISTANT_START, prepare_pfio) PFIO.init() return True
from time import sleep import pifacedigitalio def input_event(event): print('Piface switch event={}'.format(event)) pifacedigital = pifacedigitalio.PiFaceDigital() print 'Doorbell Server Started\r' listener = pifacedigitalio.InputEventListener(chip=pifacedigital) for i in range(8): listener.register(i, pifacedigitalio.IODIR_OFF, input_event) listener.register(i, pifacedigitalio.IODIR_ON, input_event) listener.activate() while True: sleep(3600) # or any very long time
def __init__(self, b): self.board = b self.listener = pifacedigitalio.InputEventListener(chip=self.board) self.inited = False
event.chip.output_pins[event.pin_num].turn_on( ) # turn on outputs, comment out if you do not want to switch anything with the onboard outputs elif i['rest'] == 0: log.info( 'Setting off / closed / no-motion state for device %s', i['description']) pz.set_off(i['domoticz_id']) event.chip.output_pins[event.pin_num].turn_off() else: log.error('invalid rest status detected, not 1 or 0') if noconfig == 0: log.warning( 'Disconnected event detected but no action performed, looks like there is no config for board / pin: {}/{} .' .format(boardno, event.pin_num)) if __name__ == "__main__": # listener.deactivate() pifacedigital0 = pifacedigitalio.PiFaceDigital(0) pifacedigital1 = pifacedigitalio.PiFaceDigital(1) listener0 = pifacedigitalio.InputEventListener(chip=pifacedigital0) listener1 = pifacedigitalio.InputEventListener(chip=pifacedigital1) for i in range(8): listener0.register(i, pifacedigitalio.IODIR_ON, connected0) listener1.register(i, pifacedigitalio.IODIR_ON, connected1) listener0.register(i, pifacedigitalio.IODIR_OFF, disconnected0) listener1.register(i, pifacedigitalio.IODIR_OFF, disconnected1) listener0.activate() listener1.activate()
def execute(): print('Startup') input_count = 8 output_count = 8 pfd = pifacedigitalio.PiFaceDigital() listener = pifacedigitalio.InputEventListener(chip=pfd) r = redis.Redis(host='192.168.0.1', port=6379, db=0, decode_responses=True) p = r.pubsub(ignore_subscribe_messages=True) p.psubscribe('pfd.input', 'pfd.output.?') input_on = [None] * input_count input_off = [None] * input_count r.publish('services', 'pfd.on') systemd.daemon.notify('READY=1') print('Startup complete') try: for i in range(0, input_count): input_on[i] = lambda e, i=i: r.publish("pfd.input." + str(i), "input." + str(i) + ".on") input_off[i] = lambda e, i=i: r.publish("pfd.input." + str(i), "input." + str(i) + ".off") # Invoke it for initial state (input_off[i])(None) listener.register(i, pifacedigitalio.IODIR_FALLING_EDGE, input_on[i]) listener.register(i, pifacedigitalio.IODIR_RISING_EDGE, input_off[i]) listener.activate() for i in range(0, output_count): pfd.output_pins[i].turn_off() r.publish('pfd.output.' + str(i) + '.status', 'output.' + str(i) + '.on') for message in p.listen(): if message['channel'] == 'pfd.input': if message['data'] == "*": tgt_range = range(0, input_count) else: try: rangespec = int(message['data']) if rangespec < 0 or rangespec > 7: tgt_range = None else: tgt_range = range(rangespec, rangespec + 1) except: # Do nothing if can't parse tgt_range = range(0, 0) for i in tgt_range: if pfd.input_pins[i].value > 0: (input_on[i])(None) else: (input_off[i])(None) elif message['channel'].startswith('pfd.output.'): output_id = int(message['channel'][-1]) if output_id >= output_count or output_id < 0: continue if message['data'] == 'on': pfd.output_pins[output_id].turn_on() r.publish('pfd.output.' + str(output_id) + '.status', 'output.' + str(output_id) + '.on') elif message['data'] == 'off': pfd.output_pins[output_id].turn_off() r.publish('pfd.output.' + str(output_id) + '.status', 'output.' + str(output_id) + '.off') elif message['data'] == '/': pfd.output_pins[output_id].toggle() if message['data'] == '?' or message['data'] == '/': pin_status = pfd.output_pins[output_id] if pin_status.value: r.publish('pfd.output.' + str(output_id) + '.status', 'output.' + str(output_id) + '.on') else: r.publish('pfd.output.' + str(output_id) + '.status', 'output.' + str(output_id) + '.off') except: p.close() listener.deactivate() pfd.deinit_board() r.publish('services', 'pfd.off') print("Goodbye")
direction = pf.relays[1] # forward is turned off, retract is turned on set_forward = direction.turn_off set_reverse = direction.turn_on def toggle_dir(event): direction.toggle() print 'changed direction' def toggle_power(event): power.toggle() print 'changed power' listener = pfd.InputEventListener(chip=pf) listener.register(0, pfd.IODIR_FALLING_EDGE, toggle_power) listener.register(1, pfd.IODIR_FALLING_EDGE, toggle_dir) listener.activate() set_forward() sleep(0.05) motor_on() sleep(3) motor_off() sleep(1) set_reverse() sleep(0.05) motor_on() sleep(3)
pfd.output_port.all_off() # air -- clear and area (coordinated are two corners of a cuboid) mc.setBlocks(-20, 0, -20, 20, 20, 20, mcpi.block.AIR.id) # ground mc.setBlocks(-20, -20, -20, 20, 0, 20, mcpi.block.DIRT.id) # build a BIG bookshelf! mc.setBlocks(0, 0, 0, 20, 20, 20, mcpi.block.BOOKSHELF.id) # TNT!!!!!!! mc.setBlocks(TNT_START_X, TNT_START_Y, TNT_START_Z, TNT_END_X, TNT_END_Y, TNT_END_Z, mcpi.block.TNT.id) global tnt_activated tnt_activated = False # start listening for the *activate* button press listener = pifacedigitalio.InputEventListener(pfd) listener.register(0, pifacedigitalio.IODIR_FALLING_EDGE, activate_tnt) listener.activate() mc.postToChat("Press button 0 to activate TNT") # check for tnt to not be tnt try: while True: if tnt_activated and not tnt_is_still_there(): time.sleep(TNT_FUSE) print "KA-BOOM!" pfd.relays[0].turn_on() # EXPLOSION! KA-POW! time.sleep(RELAY_ON_TIME) pfd.relays[0].turn_off() pfd.output_pins[7].turn_off() # turn off the button light break
t1 = thd.Thread(target=run_general) t2 = thd.Thread(target=run_spi) t3 = thd.Thread(target=run_flask_api) t4 = thd.Thread(target=run_motor) t1.setDaemon(True) t2.setDaemon(True) t3.setDaemon(True) t3.setDaemon(True) t1.start() t2.start() t3.start() t4.start() pdio.init() pfd = pdio.PiFaceDigital() listener = pdio.InputEventListener(chip=pfd) listener.register(0, pdio.IODIR_FALLING_EDGE, read_data) #listener.register(1, pdio.IODIR_FALLING_EDGE, motor_down) #listener.register(2, pdio.IODIR_FALLING_EDGE, motor_up) listener.register(1, pdio.IODIR_FALLING_EDGE, set_LED_bool1) listener.register(2, pdio.IODIR_FALLING_EDGE, set_LED_bool2) #listener.register(6, pdio.IODIR_ON, switch_pressed) #listener.register(7, pdio.IODIR_OFF, switch_unpressed) listener.activate() set_sun_time() if (sun_down == False): gate_state = True while True: time.sleep(1)
for listener in listeners: listener.activate() print('Listeners active.') def deactivate_listeners(listeners): for listener in listeners: listener.deactivate() print('Listeners deactivated.') if __name__ == '__main__': NUM_INPUTS = 4 board1 = pfio.PiFaceDigital(hardware_addr=0) # board2 = pfio.PiFaceDigital(hardware_addr=3) listeners = [] for i in range(NUM_INPUTS): listener = pfio.InputEventListener(chip=board1) listeners.append(listener) for i in range(NUM_INPUTS): listeners[i].register(i, pfio.IODIR_ON, print) activate_listeners(listeners) msg = input('Press any key to stop.\n') deactivate_listeners(listeners)