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)
