我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用RPi.GPIO.add_event_detect()。
def __initCBs(self): """ Initialises the Callback functions for each Input IO pin """ # Sound Button Callbacks: for i in range(6): bnt = self.__soundBNTs[i] smp = self.__samples[i] GPIO.add_event_detect(bnt, GPIO.RISING, callback=lambda x,y=smp: self.__soundCB(x, y), bouncetime=200) # Step Button Callbacks: for bnt in self.__stepBNTs: GPIO.add_event_detect(bnt, GPIO.RISING, callback=lambda x: self.__stepCB(x), bouncetime=200) # Play Button Callback: GPIO.add_event_detect(self.__playBNT, GPIO.RISING, callback=lambda x: self.__playCB(x), bouncetime=200) # Record Button Callback: GPIO.add_event_detect(self.__recBNT, GPIO.RISING, callback=lambda x: self.__recCB(x), bouncetime=200)
def on_press(self, callback): """Calls the callback whenever the button is pressed. Args: callback: a function to call whenever the button is pressed. It should take a single channel number. If the callback is None, the previously registered callback, if any, is canceled. Example: def MyButtonPressHandler(channel): print "button pressed: channel = %d" % channel my_button.on_press(MyButtonPressHandler) """ GPIO.remove_event_detect(self.channel) if callback is not None: self.callback = callback GPIO.add_event_detect( self.channel, self.polarity, callback=self._debounce_and_callback)
def init_gpio(self, rpi_settings): """ Initialize GPIO pin to a default value. Leds are off by default Mute button is set as an input :param rpi_settings: RpiSettings object """ # All led are off by default if self.rpi_settings.pin_led_muted: GPIO.setup(rpi_settings.pin_led_muted, GPIO.OUT, initial=GPIO.LOW) if self.rpi_settings.pin_led_started: GPIO.setup(rpi_settings.pin_led_started, GPIO.OUT, initial=GPIO.LOW) if self.rpi_settings.pin_led_listening: GPIO.setup(rpi_settings.pin_led_listening, GPIO.OUT, initial=GPIO.LOW) if self.rpi_settings.pin_led_talking: GPIO.setup(rpi_settings.pin_led_talking, GPIO.OUT, initial=GPIO.LOW) # MUTE button if self.rpi_settings.pin_mute_button: GPIO.setup(rpi_settings.pin_mute_button, GPIO.IN, pull_up_down=GPIO.PUD_UP) GPIO.add_event_detect(rpi_settings.pin_mute_button, GPIO.FALLING, callback=self.switch_kalliope_mute_led, bouncetime=500)
def event_loop(self): count =0 keys_per_rev=5 key_press_delay=0.05 inter_key_delay=0.1 last_time=0 current_time=0 GPIO.add_event_detect(DeskCycle.PIN, GPIO.FALLING, callback=self.pin_event,bouncetime=100) while True: if(self.hitCount >0): count+=1 print "Hit ",count self.hitCount-=1 time.sleep(0.01)
def button_press_switch(channel): global button_status GPIO.remove_event_detect(channel) logging.info('Button pressed') pressed_time = datetime.datetime.now() while not GPIO.input(channel): time.sleep(.5) dif = datetime.datetime.now() - pressed_time pressed_time = dif.seconds if pressed_time > 6: shutdown() button_status = BUTTON_SHUTDOWN elif pressed_time > 2: button_status = BUTTON_MONITOR_SWITCH else: button_status = BUTTON_SENSOR_SWITCH logging.info("Button status = %s", button_status) GPIO.add_event_detect(channel, GPIO.FALLING, callback=button_press_switch, bouncetime=200) # Run cleanup routines
def shutdown(channel): """ Calls system shutdown after a button press of more than 2 seconds """ GPIO.remove_event_detect(channel) pressed_timestamp = datetime.datetime.now() while not GPIO.input(channel): time.sleep(.5) dif = datetime.datetime.now() - pressed_timestamp pressed_time = dif.seconds logging.debug('Pressed time = %s', pressed_time) if pressed_time > 2: logging.info('Button initiated shutdown') os.system("sudo shutdown -h now") GPIO.add_event_detect(channel, GPIO.FALLING, callback=shutdown, bouncetime=200) # Add button pressed event detects
def shutdown(channel): # Change to lowercase function name # Modify function to require the shutdown button to be pressed and held # for at least 2 seconds before shutting down. GPIO.remove_event_detect(channel) pressed_time = datetime.datetime.now() while not GPIO.input(channel): time.sleep(.5) dif = datetime.datetime.now() - pressed_time pressed_time = dif.seconds logging.debug('Pressed time = %s', pressed_time) if pressed_time > 2: pass #os.system("sudo shutdown -h now") GPIO.add_event_detect(channel, GPIO.FALLING, callback=shutdown, bouncetime=200) ## ##
def button_press_switch(channel): GPIO. remove_event_detect(channel) print('Button pressed') pressed_time = datetime.datetime.now() while not GPIO.input(channel): time.sleep(.5) dif = datetime.datetime.now() - pressed_time pressed_time = dif.seconds if pressed_time < 2: button_status = 1 elif pressed_time < 6: button_status = 2 else: button_status = 4 print(button_status) GPIO.add_event_detect(channel, GPIO.FALLING, callback=button_press_switch, bouncetime=200) ## ##
def __init__(self,pinA,pinB,callback): self.pinA = pinA self.pinB = pinB #self.button = button self.callback = callback GPIO.setmode(GPIO.BCM) # The following lines enable the internal pull-up resistors # on version 2 (latest) boards GPIO.setwarnings(False) GPIO.setup(self.pinA, GPIO.IN, pull_up_down=GPIO.PUD_UP) GPIO.setup(self.pinB, GPIO.IN, pull_up_down=GPIO.PUD_UP) #GPIO.setup(self.button, GPIO.IN, pull_up_down=GPIO.PUD_UP) # For version 1 (old) boards comment out the above four lines # and un-comment the following 3 lines #GPIO.setup(self.pinA, GPIO.IN) #GPIO.setup(self.pinB, GPIO.IN) #GPIO.setup(self.button, GPIO.IN) # Add event detection to the GPIO inputs GPIO.add_event_detect(self.pinA, GPIO.FALLING, callback=self.switch_event) GPIO.add_event_detect(self.pinB, GPIO.FALLING, callback=self.switch_event) #GPIO.add_event_detect(self.button, GPIO.BOTH, callback=self.button_event, bouncetime=200) return # Call back routine called by switch events
def __init__(self, button_pins, bounce_time): # Set bounce time self.bounce_time = bounce_time # Set buttons self.buttons = button_pins # Initialize display client self.display = False # We don't need warnings from GPIO GPIO.setwarnings(False) # Set button GPIO pins as inputs and enable interrupts for button in button_pins: if (button_pins[button] != False): GPIO.setup(button_pins[button], GPIO.IN, pull_up_down = GPIO.PUD_UP) GPIO.add_event_detect(button_pins[button], GPIO.FALLING, callback=self.button_pressed, bouncetime=self.bounce_time) # Initalize MPD self.mpd = False # Register MPD client to send it commands
def lowBattery(channel): #Checking for LED bounce for the duration of the battery Timeout for bounceSample in range(1, int(round(batteryTimeout / sampleRate))): time.sleep(sampleRate) if GPIO.input(batteryGPIO) is 1: break global playerFlag while playerFlag is 1: time.sleep(1) #If the LED is a solid for more than 10% of the timeout, we know that the battery is getting low. Launch the Low Battery alert. if bounceSample > int(round(batteryTimeout / sampleRate * 0.1)): playerFlag = 1 os.system("/usr/bin/omxplayer --no-osd --layer 999999 " + lowalertVideo + " --alpha 160;"); playerFlag = 0 #Discovered a bug with the Python GPIO library and threaded events. Need to unbind and rebind after a System Call or the program will crash GPIO.remove_event_detect(batteryGPIO) GPIO.add_event_detect(batteryGPIO, GPIO.FALLING, callback=lowBattery, bouncetime=300)
def main(): #if the Low Battery LED is active when the program launches, handle it if GPIO.input(batteryGPIO) is 0: lowBattery(batteryGPIO) #if the Power Switch is active when the program launches, handle it if GPIO.input(powerGPIO) is 1: powerSwitch(powerGPIO) #Add threaded event listeners for the Low Battery and Power Switch try: GPIO.remove_event_detect(batteryGPIO) GPIO.add_event_detect(batteryGPIO, GPIO.FALLING, callback=lowBattery, bouncetime=300) GPIO.remove_event_detect(powerGPIO) GPIO.add_event_detect(powerGPIO, GPIO.RISING, callback=powerSwitch, bouncetime=300) except KeyboardInterrupt: GPIO.cleanup()
def __initGPIOs(self): #setup GPIO using Board numbering (pins, not GPIOs) GPIO.setwarnings(False) GPIO.cleanup() GPIO.setmode(GPIO.BOARD) #setup defined pins and event_detectors or outputs and initial states (initial is always 0, low) for pin in pins_in_use: if pins_in_use[pin][0] == GPIO.IN: if pin == 5: GPIO.setup(pin, pins_in_use[pin][0], pull_up_down=GPIO.PUD_UP) else: GPIO.setup(pin, pins_in_use[pin][0]) GPIO.add_event_detect(pin, pins_in_use[pin][1], callback=self.shoutItOut, bouncetime=100) self.gpio_states.update({pin: 1}) elif pins_in_use[pin][0] == GPIO.OUT: GPIO.setup(pin, pins_in_use[pin][0], initial=0)
def __init__(self,pinA,pinB,button,callback, parent): self.pinA = pinA self.pinB = pinB self.button = button self.callback = callback self.parent = parent if self.pinA is not None and self.pinB is not None: GPIO.setmode(GPIO.BOARD) GPIO.setwarnings(False) GPIO.setup(self.pinA, GPIO.IN) GPIO.setup(self.pinB, GPIO.IN) GPIO.add_event_detect(self.pinA, GPIO.FALLING, callback=self.switch_event) GPIO.add_event_detect(self.pinB, GPIO.FALLING, callback=self.switch_event) if self.button is not None: GPIO.setup(self.button, GPIO.IN) GPIO.add_event_detect(self.button, GPIO.BOTH, callback=self.button_event, bouncetime=200) return # Call back routine called by switch events
def begin(irq): """ This function opens the SPI connection available on the Raspberry Pi using the chip select #0. Normally, spidev can auto enable chip select when necessary. However, in our case, the dw1000's chip select is connected to GPIO16 so we have to enable/disable it manually. It also sets up the interrupt detection event on the rising edge of the interrupt pin. Args: irq : The GPIO pin number managing interrupts. """ global _deviceMode # Wait 5 us to open spi connection to let the chip enter idle state, see 2.3.2 of the DW1000 user manual (INIT). time.sleep(C.INIT_DELAY) GPIO.setmode(GPIO.BCM) spi.open(0, 0) # spi.max_speed_hz = 4000000 _deviceMode = C.IDLE_MODE GPIO.setup(irq, GPIO.IN, pull_up_down=GPIO.PUD_UP) GPIO.add_event_detect(irq, GPIO.RISING, callback=handleInterrupt)
def setup(): global counter global Last_RoB_Status, Current_RoB_Status GPIO.setmode(GPIO.BCM) GPIO.setup(RoAPin, GPIO.IN) GPIO.setup(RoBPin, GPIO.IN) GPIO.setup(RoSPin,GPIO.IN, pull_up_down=GPIO.PUD_UP) # Set up a falling edge detect to callback clear GPIO.add_event_detect(RoSPin, GPIO.FALLING, callback=clear) # Set up a counter as a global variable counter = 0 Last_RoB_Status = 0 Current_RoB_Status = 0 # Define a function to deal with rotary encoder
def main(PIR_PIN=23, ACTION_PIN=21, DELTA=15): action=False action_time=datetime.now() queue = Queue() GPIO.setmode(GPIO.BCM) GPIO.setup(ACTION_PIN, GPIO.OUT) GPIO.output(ACTION_PIN, GPIO.HIGH) GPIO.setup(PIR_PIN, GPIO.IN) try: GPIO.add_event_detect(PIR_PIN, GPIO.RISING, callback=partial(interrupt_event, queue), bouncetime=100) while True: sleep(0.01) if not queue.empty(): pin, state, dt = queue.get() action = True action_time = dt GPIO.output(ACTION_PIN, GPIO.LOW) if action and (datetime.now() - action_time).seconds > DELTA: action = False GPIO.output(ACTION_PIN, GPIO.HIGH) except KeyboardInterrupt: print("Quit")
def main(): try: GPIO.setmode(GPIO.BCM) GPIO.setup(START_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP) root = tk.Tk() root.overrideredirect(True) width, height = root.winfo_screenwidth(), root.winfo_screenheight() root.geometry('{0}x{1}+0+0'.format(width, height)) root.wm_title('Stoppuhr') stopwatch = Stopwatch(LOG_FILENAME) GPIO.add_event_detect(START_PIN, GPIO.FALLING, stopwatch.start) stopwatch_ui = StopwatchUI(root, stopwatch) stopwatch_ui.pack() root.mainloop() finally: GPIO.cleanup()
def _configure_input(self, name, configuration): pin = configuration['pin'] self.log().debug('Pin %d -> %s' % (pin, name)) if configuration['pull_up_down'] == 'up': pull_up_or_down = GPIO.PUD_UP else: pull_up_or_down = GPIO.PUD_DOWN if 'debounce' in configuration: debounce = configuration['debounce'] else: debounce = 0 GPIO.setup(pin, GPIO.IN, pull_up_down = pull_up_or_down) GPIO.add_event_detect(pin, GPIO.BOTH, callback = self._channel_changed, bouncetime = debounce)
def __init__(self): self.__RESET = 26 GPIO.setmode(GPIO.BCM) GPIO.setwarnings(False) GPIO.setup(self.__RESET, GPIO.IN, pull_up_down=GPIO.PUD_UP) # Do not proceed unless the reset signal has turned off # attempt to prevent restart storm in systemd print "waiting for reset to complete." while GPIO.input(self.__RESET) != 1: time.sleep(0.100) pass GPIO.add_event_detect( self.__RESET, GPIO.FALLING, callback=onReset, bouncetime=100) print "GPIO initialized."
def main(): #if the Low Battery LED is active when the program launches, handle it if GPIO.input(batteryGPIO) is 0: lowBattery(batteryGPIO) #if the Power Switch is active when the program launches, handle it if GPIO.input(powerGPIO) is 0: powerSwitch(powerGPIO) #Add threaded event listeners for the Low Battery and Power Switch try: GPIO.remove_event_detect(batteryGPIO) GPIO.add_event_detect(batteryGPIO, GPIO.FALLING, callback=lowBattery, bouncetime=300) GPIO.remove_event_detect(powerGPIO) GPIO.add_event_detect(powerGPIO, GPIO.FALLING, callback=powerSwitch, bouncetime=300) except KeyboardInterrupt: GPIO.cleanup()
def loop(): GPIO.add_event_detect(ButtonPin, GPIO.FALLING, callback=buttonPress) while True: pass # When running directly, make sure to cleanup GPIO
def event_detect(self, io_number): if self.importlib is not None: self.logger.debug('event_detect') GPIO.add_event_detect(io_number, GPIO.RISING) while True: if GPIO.event_detected(io_number): print("Bouton appuye")
def callback(self, io_number): """ if self.importlib is not None: self.logger.debug('callback') def my_callback(io_number): self.logger.debug('Evenent') # ici on ajoute une tempo de 75 ms pour eviter l'effet rebond GPIO.add_event_detect(io_number, GPIO.BOTH, callback = my_callback, bouncetime = 75) # votre programme ici """ pass
def haltSystem(): print 'Halt...' os.system("sudo halt") # GPIO.add_event_detect(HALT_PIN, GPIO.FALLING, callback = haltSystem, bouncetime = 2000)
def set_voice_sensor(): GPIO.setup(GPIOConfig.VOICE_SENSOR, GPIO.IN, pull_up_down=GPIO.PUD_UP) GPIO.add_event_detect(GPIOConfig.VOICE_SENSOR, GPIO.FALLING)
def loop(): # ??? handler = BaseHandler() try: while True: # ????? if GPIO.event_detected(GPIOConfig.VOICE_SENSOR): GPIO.remove_event_detect(GPIOConfig.VOICE_SENSOR) handler.worker() GPIO.add_event_detect(GPIOConfig.VOICE_SENSOR, GPIO.FALLING) time.sleep(0.5) except KeyboardInterrupt: pass GPIO.cleanup()
def setup(): """ Function to setup raspberry pi GPIO mode and warnings. PIN 7 OUT and PIN 11 IN """ # Setup GPIO on raspberry pi GPIO.setmode(GPIO.BOARD) GPIO.setwarnings(False) GPIO.setup(7, GPIO.OUT, initial=GPIO.LOW) # Tell the program you want to use pin number 7 as output. Relay is ACTIVE LOW, so OFF is HIGH GPIO.setup(11, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) # Set GPIO 11 as a PULL DOWN switch GPIO.add_event_detect(11, GPIO.RISING, activate_goal_light, 5000)
def listen(self, callback): if not callback: callback = self.callback GPIO.add_event_detect(self.button_pin, GPIO.FALLING, callback=callback, bouncetime=500)
def start(self): if not self.event_detect_added: GPIO.add_event_detect(self.channel, self.polarity, callback=self.debounce) self.event_detect_added = True
def wait_for_press(self): """Waits for the button to be pressed. This method blocks until the button is pressed. """ GPIO.add_event_detect(self.channel, self.polarity) while True: if GPIO.event_detected(self.channel) and self._debounce(): GPIO.remove_event_detect(self.channel) return time.sleep(0.02)
def initialize_gpio(): GPIO.setmode(GPIO.BOARD) GPIO.setup(Gmail.PIN, GPIO.OUT) GPIO.setup(CHECK_NOW_PIN, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) GPIO.add_event_detect(CHECK_NOW_PIN, GPIO.RISING, callback=check_mail_now, bouncetime=1000)
def initialize_gpio(): GPIO.setmode(GPIO.BOARD) GPIO.setup([11, 32, 36], GPIO.OUT) # LEDs: Blue (metronome), Green (ok), Red (error) GPIO.setup(31, GPIO.IN) GPIO.output([32, 36], GPIO.LOW) GPIO.add_event_detect(31, GPIO.BOTH, callback=intercept_morse_code) # Blink a blue LED on/off (one full cycle per BASE_TIME_SECONDS)
def initialize_gpio(): GPIO.setmode(GPIO.BOARD) GPIO.setup([R,G], GPIO.OUT, initial=GPIO.LOW) GPIO.setup(BUTTON, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) GPIO.add_event_detect(BUTTON, GPIO.FALLING, fan_the_flame, 250)
def initialize_gpio(): GPIO.setmode(GPIO.BOARD) GPIO.setup(LIGHTS, GPIO.OUT, initial=GPIO.LOW) GPIO.setup(BUTTONS, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) for i in range(4): GPIO.add_event_detect(BUTTONS[i], GPIO.FALLING, verify_player_selection, 400 if use_sounds else 250)
def __init__(self, mm_per_tick=0.306096, pin=27, poll_delay=0.0166, debug=False): import RPi.GPIO as GPIO GPIO.setmode(GPIO.BCM) GPIO.setup(pin, GPIO.IN) GPIO.add_event_detect(pin, GPIO.RISING, callback=self.isr) # initialize the odometer values self.m_per_tick = mm_per_tick / 1000.0 self.poll_delay = poll_delay self.meters = 0 self.last_time = time.time() self.meters_per_second = 0 self.counter = 0 self.on = True self.debug = debug
def __init__(self): logging.getLogger('garage').info('Butler is starting...') logging.getLogger('garage').info('AWS: region=%s, topic=%s' % (REGION, TOPIC)) self.camera = Camera() self.notify = Notify(self) GPIO.add_event_detect(button_pin, GPIO.FALLING, callback=self.door_check, bouncetime=1000) scheduler.start() scheduler.add_job(self.status_check, 'interval', minutes=1) self.last_notification = datetime.datetime.strptime('Jun 1 2005 1:00PM', '%b %d %Y %I:%M%p') self.last_status = GPIO.input(button_pin)
def prepare_irq_pin(self, pin_id): pin = self.prepare_pin(pin_id, GPIO.IN) if pin: pin.set_handler_for_irq_on_rising_edge = \ lambda handler: GPIO.add_event_detect(pin.pin_id, GPIO.RISING, callback = handler) pin.detach_irq = lambda : GPIO.remove_event_detect(pin.pin_id) return pin
def event_loop(self): self.keyDown=False self.hitCount=0 keys_per_rev=5 key_press_delay=0.2 inter_key_delay=0.001 self.last_hit_time=0 self.current_hit_time=0 self.rev_time=0.5 GPIO.add_event_detect(DeskCycle.PIN, GPIO.FALLING, callback=self.pin_event,bouncetime=250) while True: if(self.hitCount >0): if(not self.keyDown): print "On" self.state[4]=DeskCycle.KEYCODE self.send_key_state() self.keyDown=True self.hitCount=0 else: if(self.keyDown): if(time.time()-self.last_hit_time > 1): print "Off" self.state[4]=0 self.send_key_state() self.keyDown=False time.sleep(0.001)
def __init__(self): print "setting up GPIO" GPIO.setmode(GPIO.BOARD) GPIO.setup(DeskCycle.PIN,GPIO.IN,pull_up_down=GPIO.PUD_UP) self.hitCount=0 pin2=38 GPIO.setup(pin2,GPIO.IN,pull_up_down=GPIO.PUD_DOWN) GPIO.add_event_detect(pin2, GPIO.FALLING, callback=self.pin_2_event,bouncetime=100)
def reset_radio(self): """ Reset the Si4707 chip """ # Ref https://github.com/AIWIndustries/Pi_4707/blob/master/firmware/NWRSAME_v2.py if self.gpio_started: gpio.cleanup() self.gpio_started = True gpio.setmode(gpio.BCM) # Use board pin numbering gpio.setup(17, gpio.OUT) # Setup the reset pin gpio.output(17, gpio.LOW) # Reset the Si4707. sleep(0.4) gpio.output(17, gpio.HIGH) gpio.setup(23, gpio.IN, pull_up_down=gpio.PUD_UP) gpio.add_event_detect(23, gpio.FALLING) # Initialize the onboard relays for pin in self.relay_gpio_pins: gpio.setup(pin, gpio.OUT) # setup gpio pin for relay gpio.output(pin, gpio.LOW) # boot to disabled state # set up the LED # https://www.reddit.com/r/raspberry_pi/comments/3641ug/blinking_an_onboard_led_on_the_pi_2_model_b/ # http://raspberrypi.stackexchange.com/questions/697/how-do-i-control-the-system-leds-using-my- # sudo echo none >/sys/class/leds/led0/trigger # GPIO 16 LOW is on, HIGH is off gpio.setup(16, gpio.OUT) gpio.output(16, gpio.HIGH) sleep(1.5)
def __init__(self): GPIO.setmode(GPIO.BCM) #Setup each hall effect pin for interrupts GPIO.setup(18, GPIO.IN, pull_up_down=GPIO.PUD_UP) GPIO.setup(24, GPIO.IN, pull_up_down=GPIO.PUD_UP) print ("Encoders Ready") GPIO.add_event_detect(18, GPIO.FALLING, callback=self.add_right_pulse) GPIO.add_event_detect(24, GPIO.FALLING, callback=self.add_left_pulse) while 1: pass # Callback function for Hall Sensor interrupts
def __init__(self): io.setmode(io.BCM) self.pir_pin = 4 io.setup(self.pir_pin, io.IN) self.pirStream = Subject() io.add_event_detect(self.pir_pin, io.RISING, callback=self.hit_callback)
def init(self): # open SPI and initialize RF95 self.spi.open(0,self.cs) self.spi.max_speed_hz = 488000 self.spi.close() # set interrupt pin GPIO.setmode(GPIO.BCM) GPIO.setup(self.int_pin, GPIO.IN) GPIO.add_event_detect(self.int_pin, GPIO.RISING, callback=self.handle_interrupt) # set reset pin if self.reset_pin != None: GPIO.setup(self.reset_pin, GPIO.OUT) GPIO.output(self.reset_pin, GPIO.HIGH) # wait for reset time.sleep(0.05) # set sleep mode and LoRa mode self.spi_write(REG_01_OP_MODE, MODE_SLEEP | LONG_RANGE_MODE) time.sleep(0.01) # check if we are set if self.spi_read(REG_01_OP_MODE) != (MODE_SLEEP | LONG_RANGE_MODE): return False # set up FIFO self.spi_write(REG_0E_FIFO_TX_BASE_ADDR, 0) self.spi_write(REG_0F_FIFO_RX_BASE_ADDR, 0) # default mode self.set_mode_idle() self.set_modem_config(Bw125Cr45Sf128) self.set_preamble_length(8) return True
def __init__(self): self.button_callback = None self.button_held_callback = None self.reset_callback = None self.pressed_at = None self.time_to_hold = 1 self.time_to_reset = 5 GPIO.setmode(GPIO.BCM) GPIO.setup(18, GPIO.IN, pull_up_down=GPIO.PUD_UP) GPIO.add_event_detect(18, GPIO.BOTH, callback=self.button_state_changed,bouncetime=200)
def eventBegin(self, callback, object=0, edge='BOTH'): # eventBegin(callback) # eventBegin(callback, object, edge) # ** callback: call function when Interrupt # ** object: set Interrupt pin: 1=Button, 2=Encoder >> default: 0(all) # ** edge: set edge detection: RISING, FALLING, BOTH >> default: BOTH self.Callback=callback if object==0 and ((self.__SWtype==1 and self.__eventStatus&0x03!=0x00) or (self.__SWtype==2 and self.__eventStatus&0x0F!=0x00)): self.eventEnd(0) elif object==1 and self.__eventStatus&0x03!=0x00: self.eventEnd(1) elif object==2 and (self.__SWtype==2 and self.__eventStatus&0x0C!=0x00): self.eventEnd(2) if object==0 or object==1: if edge.upper().find('RISING')>=0: GPIO.add_event_detect(self.__PinSW, GPIO.RISING, callback=self.eventButton, bouncetime=40) self.__eventStatus|=0x01 elif edge.upper().find('FALLING')>=0: GPIO.add_event_detect(self.__PinSW, GPIO.FALLING, callback=self.eventButton, bouncetime=40) self.__eventStatus|=0x02 elif edge.upper().find('BOTH')>=0: GPIO.add_event_detect(self.__PinSW, GPIO.BOTH, callback=self.eventButton, bouncetime=40) self.__eventStatus|=0x03 if (object==0 or object==2) and self.__SWtype==2: if edge.upper().find('RISING')>=0: GPIO.add_event_detect(self.__PinA , GPIO.RISING, callback=self.eventEncoder, bouncetime=20) self.__eventStatus|=0x04 elif edge.upper().find('FALLING')>=0: GPIO.add_event_detect(self.__PinA , GPIO.FALLING, callback=self.eventEncoder, bouncetime=20) self.__eventStatus|=0x08 elif edge.upper().find('BOTH')>=0: GPIO.add_event_detect(self.__PinA , GPIO.BOTH, callback=self.eventEncoder, bouncetime=20) self.__eventStatus|=0x0C
def start(self): GPIO.add_event_detect(self.clockPin, GPIO.FALLING, callback=self._clockCallback, bouncetime=50) GPIO.add_event_detect(self.buttonPin, GPIO.FALLING, callback=self._switchCallback, bouncetime=300)
def __init__(self, index, gpio_pin): self.pressed = False self._on_press_handler = None self._on_release_handler = None self._gpio_pin = gpio_pin self._index = index GPIO.setup(self._gpio_pin, GPIO.IN, pull_up_down=GPIO.PUD_UP) GPIO.add_event_detect(self._gpio_pin, GPIO.BOTH, bouncetime=1, callback=self._handle_button)
