def off(): pifacedigital = pifacedigitalio.PiFaceDigital() pifacedigital.leds[2].toggle() return 'Success!\n'
def activate_listeners(listeners): 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)
def __init__(self, arm_input=None, armed_output=None, active_output=None, buzzer_output=None, sounder_output=None, strobe_output=None, arm_delay=30, alarm_delay=30, alarm_duration=900, normally_closed_inputs=None, ignored_inputs=None): """ Initialize the alarm's internal state and hardware (PiFace Digital). The `arm_input` pin allows an external device to arm/disarm the alarm. It's normally-open by default and, like all other inputs, can be set to normally-closed by including it in the `normally_closed_inputs` list. In this latter case, care must be taken to ensure the external device initializes before the alarm does, or the alarm may be inadvertently triggered. The `armed_output` and `active_output` pins can be used to (optionally) notify external devices that the alarm has been (respectively armed) or is currently sounding. The `armed_output` pin becomes low at the start of the arming grace period and remains so until the alarm is disarmed. The `active_output` pin is guaranteed to never be low unless the `armed_output` pin is also low. The `buzzer_output`, `sounder_output`, and `strobe_output` pins control the panel buzzer (for user feedback), external siren, and strobe light, respectively. These outputs are all optional and assumed to be active-low. The `arm_delay` parameter sets the amount of seconds to wait before unsealed (violated) inputs trigger the alarm once it has been armed. This should give the user enough time to leave the premises safely. The `alarm_delay` parameter sets the amount of seconds to wait before activating the alarm once one or more inputs become unsealed (violated) while armed. This should give the user enough time to disarm the alarm. Once triggered, the alarm will sound for `alarm_duration` seconds (unless it's disarmed), after which it will rearm itself automatically. The `alarm_delay` will be honored even if there are unsealed (violated) inputs at the moment `alarm_duration` expires. The `normally_closed_inputs` parameter can (optionally) be set to a list of input pin numbers that should be taken as unsealed (violated) when they are in a logical-high state instead of the default logical-low state. The `ignored_inputs` parameter can (optionally) be set to a list of input pin numbers whose state can never trigger the alarm. This list can also be set when the alarm is armed, reverting to whatever is set here when the alarm is disarmed (thus this parameter can be seen as the default list of ignored inputs). """ log.debug("Alarm initialization starting...") self._state_lock = threading.Lock() self._armed = False self._sounding = False self._arm_input = arm_input self._armed_output = armed_output self._active_output = active_output self._buzzer_output = buzzer_output self._sounder_output = sounder_output self._strobe_output = strobe_output self._unsealed_inputs = set() self._ignored_inputs = set(ignored_inputs or []) self._default_ignored_inputs = self._ignored_inputs # ...fallback on disarm. self._normally_closed_inputs = set(normally_closed_inputs or []) self._arm_delay = arm_delay self._alarm_delay = alarm_delay self._alarm_duration = alarm_duration self._pf = piface.PiFaceDigital() # Use a single "PortEventListener" for all inputs, instead of an "InputEventListener" for each input... self._listener = pifacecommon.interrupts.PortEventListener( pifacecommon.mcp23s17.GPIOB, self._pf, daemon=True) # Inputs won't trigger an interrupt until they change, must poll their initial state... for pin in range(NUM_HARDWARE_PINS): self._listener.register(pin, piface.IODIR_BOTH, self._input_change_handler) if self._arm_input is not None and pin == self._arm_input: continue high_state = bool(self._pf.input_pins[pin].value) normally_closed = pin in self._normally_closed_inputs if not high_state and normally_closed or high_state and not normally_closed: self._unsealed_inputs.add(pin) if self._unsealed_inputs: unsealed_inputs_str = ", ".join( str(pin) for pin in sorted(self._unsealed_inputs)) log.info("These inputs are already unsealed on initialization: %s", unsealed_inputs_str) self._listener.activate() # Feedback beeps must be asynchronous, or they'd mess timings... if self._buzzer_output is not None: self._buzzer_enabled = True self._buzzer_queue = queue.SimpleQueue() self._buzzer_thread = threading.Thread( target=type(self)._buzzer_daemon, args=[self], daemon=True) self._buzzer_thread.start() if self._arm_input is not None: high_state = bool(self._pf.input_pins[self._arm_input].value) normally_closed = self._arm_input in self._normally_closed_inputs if high_state ^ normally_closed: log.warning( "AUTO-ARMING on initialization from arm input pin state..." ) self.arm() self.beep(**BEEP_SEQUENCES["init"]) log.info("Alarm initialized.")
# by David Art [aka] adcomp <*****@*****.**> import tornado.httpserver import tornado.websocket import tornado.ioloop import tornado.web import datetime import json import sys import os # PiFace module & init import pifacedigitalio as pfio pfio.init() pifacedigital = pfio.PiFaceDigital() class IndexHandler(tornado.web.RequestHandler): @tornado.web.asynchronous def get(self): self.render("index.html") class WebSocketHandler(tornado.websocket.WebSocketHandler): clients = [] last_data = None def open(self): self.connected = True
def __init__(self, highwayRelay=0, parkRelay=1): self.highwayRelay = highwayRelay self.parkRelay = parkRelay self.lightBoard = pifacedigitalio.PiFaceDigital()
if (last_sc['dateto']): res = requests.post( sc_url, data={ 'dateFrom': datetime.now().strftime("%Y-%m-%d %H:%M:%S"), 'patientId': 1 }) print(res) if (res.status_code == 200): print("Created new sleepcycle.") else: print(res.text) else: res = requests.put( sc_url + "/{}".format(last_sc['id']), data={'dateTo': datetime.now().strftime("%Y-%m-%d %H:%M:%S")}) if (res.status_code == 200): print("Updated sleepcycle.") else: print(res.text) pifacedigital = p.PiFaceDigital() listener = p.InputEventListener(chip=pifacedigital) listener.register(0, p.IODIR_FALLING_EDGE, toggle_input) listener.register(1, p.IODIR_FALLING_EDGE, toggle_input) listener.register(2, p.IODIR_FALLING_EDGE, toggle_input) listener.register(3, p.IODIR_FALLING_EDGE, toggle_input) listener.activate()
def main(): pfd = pifacedigitalio.PiFaceDigital() # Instruction sequence lst = [] rounds = 0 lost = False buttonPressed = False s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) s.settimeout(TIMEOUT) Print("Request server connection\n") for i in range(CONNECTION_ATTEMPTS + 1): if i == CONNECTION_ATTEMPTS: raise RuntimeError("Unable to connect to server") Print("Connection attempt " + str(i + 1)) # Send emotion control ID to server Print("Sending...") Print("Data:\t" + binascii.hexlify(SIMON_ID)) Print("IP:\t" + SERVER_IP) Print("Port:\t%d" % SERVER_PORT) s.sendto(SIMON_ID, (SERVER_IP, SERVER_PORT)) # Attempt to receive a response from the server try: data, address = s.recvfrom(BUFFER_SIZE) except socket.timeout: Print("Timed out\n") continue s.settimeout(None) Print("\nPacket received") Print("Data:\t" + binascii.hexlify(data)) Print("IP:\t" + address[0]) Print("Port:\t%d" % address[1]) # Check if message is actually from the server if data[0] == SERVER_ID: i = 6 else: #raise RuntimeError("Unknown response") Print("Unknown response") while True: lost = False # Receive on port into buf print ("Waiting to receive") data, address = s.recvfrom(BUFFER_SIZE) # Assert received from server if data[0] != SERVER_ID: Print("Invalid response") continue # New empty list for new game buf = [] for rounds in range(MAX_ROUNDS): if lost: break buf.append(random.randint(0, 3)) #print ("value in column %s" % (buf)) # Test the user's memory for i in range (len(buf)): pfd.output_pins[buf[i]].value = ON time.sleep(0.5) pfd.output_pins[buf[i]].value = OFF for k in range(len(buf)): # Wait until a button is pressed while not buttonPressed: buttonPressed = pfd.input_pins[0].value == ON or pfd.input_pins[1].value == ON or pfd.input_pins[2].value == ON or pfd.input_pins[3].value == ON buttonPressed = False # A button has been pressed # Check each button to find out which has been pressed # If the right one had been pressed then turn the light on briefly and continue if pfd.input_pins[(buf[k] + (-1) ** (buf[k] + 1)) % 4].value == 1: pfd.output_pins[buf[k]].value = 1; time.sleep(0.5) pfd.output_pins[buf[k]].value = 0; continue # If the wrong one has been pressed then flash the fail lights else: print ("Better luck next time") failLights() lost = True rounds = 0 break print ("Winner winner chicken dinner!") rounds = 0 winLights()
#!/usr/bin/env python """ memoryGame.py Simple memory game for use with pfio and the RaspberryPi interface (piface) Objective of the game: You must remember an ever increasing sequence of flashes and input them correctly* """ from __future__ import print_function from time import sleep # for delays import random # for random sequence generation import pifacedigitalio as pfio # piface library pfio.init() # initialise pfio (sets up the spi transfers) pfd = pfio.PiFaceDigital() # create pifacedigital object colours = ["Red", "Green", "Blue", "Yellow", "White"] # colour names for printing to screen def signifyTurn(turn): global screen_output sleep(0.4) pfd.output_port.value = 0xFF # signify it is their turn by turning all the LEDs on then off sleep(0.3) pfd.output_port.value = 0x0 if screen_output: if turn:
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 __init__(self): #Setup logging self.logger1 = log_handler.get_log_handler('door_controller_log.txt', 'info', 'door.IOHandler') self.logger1.info('Starting: InputOutputHandler') #Open config file self.logger1.debug('Getting config from: %s', CONFIG_FILE_NAME) config = get_config.get_config(CONFIG_FILE_NAME, True) #Parse inputs and outputs from config file self.inputs, self.outputs = parse_config(config) #Parse commands from config file in named tuple self.input_commands = InputCommands( toggle_door_cmd=config.get('Commands', 'toggle_door_cmd'), open_door_cmd=config.get('Commands', 'open_door_cmd'), close_door_cmd=config.get('Commands', 'close_door_cmd'), light_cmd=config.get('Commands', 'light_cmd'), control_wire=config.get('Commands', 'control_wire'), stop_cmd=config.get('Commands', 'stop_cmd')) #Lock status self.door_locked = False self.light_locked = False #Initialise PiFace and interrupts pifacedigitalio.init() self.pifacedigital = pifacedigitalio.PiFaceDigital() self.listener = pifacedigitalio.InputEventListener( chip=self.pifacedigital) #Output pins self.door_relay_pin = None self.led_status0_pin = None #Input pins self.door_status_pin = None #Queue to capture input events self.event_queue = pollable_queue.PollableQueue() #Queue to log events to self.logging_queue = pollable_queue.PollableQueue() #Instantiate logging module self.log_events = event_handler.EventHandler( self.logging_queue, self.input_commands.stop_cmd) #Log starting event self.logging_queue.put(self.__create_event_obj(INTERNAL, 'Starting')) #Dict to store interrupt functions about to be generated self.intrupt_funcs = {} #Generate dynamic functions to process interrupts for key in self.inputs: self.logger1.info('Processing Input: ' + key) piface_in = self.inputs[key] if piface_in.name == DOOR_STATUS_INPUT_NAME: self.logger1.info( 'Setting door status input to pin: {}'.format( piface_in.pin)) self.door_status_pin = piface_in.pin #Disable 10K pullup resistor on piface input pin if piface_in.disablepullup: self.logger1.info('Disabling pullup on input {}'.format( piface_in.name)) pifacedigitalio.digital_write_pullup(piface_in.pin, 0) #Create interrupt listener and associated function for falling edges if piface_in.falling: self.logger1.info( 'Creating Falling Edge Listener on input: {}'.format( piface_in.name)) #e_obj = self.__create_event_obj(piface_in.type, piface_in.name, 'Falling_Edge') self.intrupt_funcs[key + '_falling'] = getattr( InterruptHandler(piface_in.type, piface_in.name, 'Falling_Edge', self.event_queue), 'interrupt_function') self.listener.register(piface_in.pin, pifacedigitalio.IODIR_FALLING_EDGE, self.intrupt_funcs[key + '_falling']) #Create interrupt listener and associated function for rising edges if piface_in.rising: self.logger1.info( 'Creating Rising Edge Listener on input: {}'.format( piface_in.name)) #e_obj = self.__create_event_obj(piface_in.type, piface_in.name, 'Rising_Edge') self.intrupt_funcs[key + '_rising'] = getattr( InterruptHandler(piface_in.type, piface_in.name, 'Rising_Edge', self.event_queue), 'interrupt_function') self.listener.register(piface_in.pin, pifacedigitalio.IODIR_RISING_EDGE, self.intrupt_funcs[key + '_rising']) #Processing outputs for key in self.outputs: piface_out = self.outputs[key] #Set relay output pin on piface if piface_out.name == DOOR_RELAY_OUTPUT_NAME: self.logger1.info('Creating door relay on output: {}'.format( piface_out.pin)) self.door_relay_pin = piface_out.pin #Set status LED output pin on piface if piface_out.name == STATUS_LED_OUTPUT_NAME: self.logger1.info('Creating status LED on output: {}'.format( piface_out.pin)) self.led_status0_pin = piface_out.pin self.logger1.info('Starting worker threads') #Create threading events and clear them self.stop_event = threading.Event() self.operate_door = threading.Event() self.operate_light = threading.Event() self.stop_event.clear() self.operate_door.clear() self.operate_light.clear() #Start threads to process input events self.process_input_thread = threading.Thread( name='process_input_thread', target=self.__process_input) self.activate_door_thread = threading.Thread( name='act_door_thread', target=self.__door_activator) self.activate_light_thread = threading.Thread( name='act_light_thread', target=self.__light_activator) self.flash_led_thread = threading.Thread( name='flt', target=self.__flash_status_led) self.process_input_thread.start() self.activate_door_thread.start() self.activate_light_thread.start() self.flash_led_thread.start() self.check_relay_thread = None self.__check_relay_state() #Monitoring self.last_open_time = None self.last_closed_time = None self.last_status = None #Activate interrupts self.listener.activate() self.logger1.info('Initialisation of InputOutputHandler Complete')
#!/usr/bin/env python import pifacedigitalio as p #init the piface board #False means do not reinit the board again #But you have to init it once! pdf = p.PiFaceDigital(0, 0, 0, True)
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) door.open()
''' An example application to toggle the LED's on a PiFace Written by Tom Richardson 2013 To run, type 'python pifaceexample.py' It will run on the Pi's local IP on port 8090 ''' import pifacedigitalio as p from pimote import * # Initialize PiFace p.init() pfd = p.PiFaceDigital() class MyPhone(Phone): # Override to get messages sent from phone def buttonPressed(self, id, message, phoneId): global pfd global buttons j = 0 # Loop through buttons for j in range(0, 8): if buttons[j].getId() == id: # Change the LED self.changeLed(pfd, j, buttons[j]) #Used to turn an LED on or off depending on input def changeLed(self, pfd, led, b): if b.getValue(): pfd.leds[led].turn_on() else:
def lightsOn(): pifacedigital = pifacedigitalio.PiFaceDigital() pifacedigital.leds[1].toggle() pifacedigital.leds[0].toggle()
black = 0, 0, 0 screen = pygame.display.set_mode(size) #, pygame.FULLSCREEN) rasp = pygame.image.load("Raspi_Colour_R.png") raspberry = pygame.transform.scale(rasp, size) rect = raspberry.get_rect() font = pygame.font.Font(None, 60) font2 = pygame.font.Font(None, 80) text = font.render("Your score", 1, (200, 10, 10)) text = pygame.transform.rotate(text, -90) p.init() # initialise pfio (sets up the spi transfers) pfd = p.PiFaceDigital() pfd2 = p.PiFaceDigital(1) leds = [] for i in range(8): leds.append(pfd.leds[i]) for i in range(8): leds.append(pfd2.leds[i]) scanText = font2.render("Scan your card", 1, (200, 10, 10)) scanText = pygame.transform.rotate(scanText, -90) welcomeText = font2.render("Welcome", 1, (200, 10, 10)) welcomeText = pygame.transform.rotate(welcomeText, -90)
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")
parser.add_argument("-b0", "--board0", help="test PiFace Digital board 0 (default)", action="store_true") for i in range(1, 4): parser.add_argument("-b{}".format(i), "--board{}".format(i), help="test PiFace Digital board {}".format(i), action="store_true") args = parser.parse_args() global pifacedigitals pifacedigitals = list() if args.board0 or not (args.board1 or args.board2 or args.board3): pifacedigitals.append(pifacedigitalio.PiFaceDigital(0)) if args.board0: remove_arg("-b0", "--board0") if args.board1: pifacedigitals.append(pifacedigitalio.PiFaceDigital(1)) remove_arg("-b1", "--board1") if args.board2: pifacedigitals.append(pifacedigitalio.PiFaceDigital(2)) remove_arg("-b2", "--board2") if args.board3: pifacedigitals.append(pifacedigitalio.PiFaceDigital(3)) remove_arg("-b3", "--board3")
#!/usr/bin/env python import pifacedigitalio as p #init the piface board #False means do not reinit the board again #But you have to init it once! pdf = p.PiFaceDigital(0, 0, 0, False) pdf.output_pins[1].value = 1 #start engine
usb = 2 hdmi = 4 vga = 16 dvi = 32 cables = [0, vga, jack, hdmi, dvi, usb] arguments = cgi.FieldStorage() first = arguments['first'].value second = arguments['second'].value third = arguments['third'].value but = cables[int(first)] + cables[int(second)] + cables[int(third)] piface = p.PiFaceDigital() piface.leds[0].turn_off() piface.leds[1].turn_off() piface.leds[0].turn_on() piface.leds[1].turn_on() portValue = piface.input_port.value while but != portValue: portValue = piface.input_port.value time.sleep(0.25) piface.leds[0].turn_off() piface.leds[1].turn_off() r = requests.get('http://192.168.123.242/webdispatcher/step1.php')
#!/usr/bin/python3 # Head to head lockboard challenge script # Writen by: Graph-X import pifacedigitalio as pfd board_one = [0, 1, 2] board_two = [3, 4, 5] player_one = 0 player_two = 0 pf = pfd.PiFaceDigital() def reset(event): global board_one global board_two global player_one global player_two player_one = 0 player_two = 0 board_one = [0, 1, 2] board_two = [3, 4, 5] #turn off all the leds for i in range(0, 7): pfd.leds[i].turn_off() #when a player wins turn on the correct LED def player_win(player): if player == 1: #turn on led 6
def __init__(self): super().__init__() self._pifacedigital = pifacedigitalio.PiFaceDigital()
#!/usr/bin/python import time import pifacedigitalio as p pfio = p.PiFaceDigital() p.init() pfio.leds[7].turn_on() while True: print p.digital_read(0) time.sleep(1)
import socket, sys, time from time import sleep import pifacedigitalio as pfio import time pfd = pfio.PiFaceDigital() pfio.init() #Creating the socket to send the notification over. We will also receive a response from the server on this socket. headlessPiSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) port = 5050 server_address = ('10.0.0.52', port) headlessPiSocket.bind(server_address) #Socket is set to be non-blocking, this is because we want to continously send notifications to server until we get a response. #A response means the server received the packet. headlessPiSocket.setblocking(0) #Server information serverPi = ('10.0.0.51', port) #If input pins have this value it means they detected a fire flameFound = 1 debugging = True while (True): if (pfd.input_pins[6].value == flameFound or pfd.input_pins[7].value == flameFound): if (debugging): print("OMG FLAME DETECTED")
#!/usr/bin/python3 # #Script that checks the status of the manual override on the door lock #and updates slack if the door is manually unlocked # import time import pifacedigitalio from backports import configparser import logging from logging import config as logconfig import slacker if __name__ == '__main__': config = configparser.ConfigParser() config.read('bouncer.ini') logconfig.fileConfig('bouncer.ini') slack = slacker.Slacker(config['slack.com']['token']) pfd = pifacedigitalio.PiFaceDigital(init_board=False) if pfd.input_pins[3].value: slack.chat.post_message('#door', 'The forge door is manually held open at ' +time.strftime("%H:%M:%S") +' CST. This alert will repeat in 30 minutes') logging.info("Door is held open") else: logging.info("Door is normal") if pfd.input_pins[2].value: logging.info("Door is open") else: logging.info("Door is closed")
def get_my_ip(): """Returns this computers IP address as a string.""" ip = subprocess.check_output(GET_IP_CMD, shell=True).decode('utf-8')[:-1] return ip.strip() if __name__ == "__main__": # get the port if len(sys.argv) > 1: port = int(sys.argv[1]) else: port = DEFAULT_PORT # set up PiFace Digital PiFaceWebHandler.pifacedigital = pifacedigitalio.PiFaceDigital() print("Starting simple PiFace web control at:\n\n" "\thttp://{addr}:{port}\n\n" "Change the output_port with:\n\n" "\thttp://{addr}:{port}?output_port=0xAA\n".format(addr=get_my_ip(), port=port)) # run the server server_address = ('', port) try: httpd = http.server.HTTPServer(server_address, PiFaceWebHandler) httpd.serve_forever() except KeyboardInterrupt: print('^C received, shutting down server') httpd.socket.close()
try: 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:
import math import time from time import sleep import datetime import pifacedigitalio pfd = pifacedigitalio.PiFaceDigital() # creates a PiFace Digtal object debounce_time_delay = 0.1 # Over pressure auto switch, for relief valve over_p_auto_sw_state = 0 over_p_auto_sw_toggle = 0 over_p_auto_sw_filt = 0 over_p_auto_sw = 0 debounce_over_p_auto_falltimer = 0 debounce_over_p_auto_risetimer = 0 # Over pressure manual switch, for relief valve override over_p_man_sw_state = 0 over_p_man_sw_toggle = 0 over_p_man_sw_filt = 0 over_p_man_sw = 0 debounce_over_p_man_falltimer = 0 debounce_over_p_man_risetimer = 0 # Under pressure auto switch, for relief valve under_p_auto_sw_state = 0 under_p_auto_sw_toggle = 0 under_p_auto_sw_filt = 0
import pifacedigitalio as pfio from time import sleep pfio.init() piface = pfio.PiFaceDigital() piface.output_pins[1].turn_on() # this command does the same thing... sleep(7) piface.output_pins[1].turn_off() sleep(1)
#!/usr/bin/env python import pifacedigitalio pfd = pifacedigitalio.PiFaceDigital() pfd.relays[0].value = 1 # turn on/set high the first relay # pfd.relays[0].value = 0
# On va demander la valeur des compteurs avec un peu de retard expres timeCPT = time.time() + 11 NextRefresh = time.time() + 40 sendCPT = 0 if (nodep): SimpleSend('&NODEP=pifacedigitalio') log( 'Error', 'Dependances pifacedigitalio introuvables. Veuillez les (re)installer. - ' + str(errdep)) sys.exit('Dependances pifacedigitalio introuvables. - ' + str(errdep)) # set up PiFace Digital pifacedigital = pifacedigitalio.PiFaceDigital(int(boardId)) #listener = pifacedigitalio.InputEventListener(chip=pifacedigital) # Toutes les entrees en impulsion # Init du Compteur d'Impulsion CounterPinValue = {} PinNextSend = {} TempoPinHIGH = {} TempoPinLOW = {} Status_pins = {} Status_INPUTS = {} swtch = {} exit = 0 SetAllLOW = 0 SetAllHIGH = 0 SetAllSWITCH = 0