def capacity(): res = [] def times(gpio_id, val): if len(res) < 6: res.append(int((datetime.datetime.utcnow() - datetime.datetime(1970, 1, 1)).total_seconds() * 10000)) print("Pridano") else: G.stop_waiting_for_interrupts() G.add_interrupt_callback(7, times, edge="rising") G.wait_for_interrupts() diff_list = [] for i in range(3): diff_list.append(res[i + 1] - res[i]) diff = reduce(lambda x, y: x + y, diff_list) / len(diff_list) tl = diff * 0.33 number = (tl / 10000) / 693 prefixes = { "0" : 10**3, "1" : 10**6, "2" :10**9 } for key, value in prefixes.iteritems(): if number * value > 1 and number * value < 1000: return (number * value, key)
def register_gpio(pins): RPIO.setmode(RPIO.BCM) for pin in pins: print 'Adding interrupt callback for pin ' + str(pin) + ' publish to ' + pins[pin] RPIO.setup(pin, RPIO.IN, pull_up_down=RPIO.PUD_DOWN) RPIO.add_interrupt_callback(pin, channel_high, edge='rising', debounce_timeout_ms=1000)
def main_loop(): global count, motor_on import RPIO as GPIO GPIO.add_interrupt_callback(BUTTON_GPIO, button_trigger, edge='both', threaded_callback=True) GPIO.wait_for_interrupts(threaded=True) # , epoll_timeout=.25) try: while True: GPIO.output(LED_GPIO, not GPIO.input(LED_GPIO)) time.sleep(.5) count += 1 # log.debug("button val: {}".format(GPIO.input(BUTTON_GPIO))) if not motor_on: if runtime.runtime.is_feed_time(set_next_run=True): # this WILL bump the next feed time log.debug("feed time and not motor") count = 1 motor_on = True GPIO.output(RELAY_GPIO, True) except Exception as e: log.exception("Exception during run loop? {}".format(e))
def start(self): gpio.setwarnings(False) if self.interface: # configure the MCP23017 self.interface.write((self.addr, GPIOInterface.IODIR+self.bank), self.inOut) # I/O direction self.interface.write((self.addr, GPIOInterface.GPINTEN+self.bank), self.inOut) # enable interrupts for inputs self.interface.write((self.addr, GPIOInterface.GPPU+self.bank), self.inOut) # pull up resistors on inputs self.interface.write((self.addr, GPIOInterface.IOCON), 0x04) # interrupt pins are open drain # additional configuration for config in self.config: reg = config[0]+self.bank # offset register with bank debug('debugGPIO', self.name, "start", "addr: 0x%02x"%self.addr, "reg: 0x%02x"%reg, "value: 0x%02x"%config[1]) self.interface.write((self.addr, reg), config[1]) # get the current state self.readState() # set up the interrupt handling gpio.add_interrupt_callback(self.interruptPin, interruptCallback, edge="falling", pull_up_down=gpio.PUD_UP) gpio.wait_for_interrupts(threaded=True) else: # direct only supports output - FIXME gpio.setmode(gpio.BOARD) for pin in GPIOInterface.gpioPins: debug('debugGPIO', self.name, "setup", pin, gpio.OUT) gpio.setup(pin, gpio.OUT) debug('debugGPIO', self.name, "write", pin, 0) gpio.output(pin, 0)
def sendBtnPush(self): # reset ctr so we get a full count self.ctrRising2 = 0 # create callbacks that will get called to register counts # when we get to a count of 2000 these callbacks will call sendBtnPushDone() RPIO.add_interrupt_callback(4, self.on_q8_rising_btn, edge='rising', threaded_callback=False) RPIO.add_interrupt_callback(25, self.on_q7_rising_btn, edge='rising', threaded_callback=False) self.log.info("Inside sendBtnPush(). Added callback for buttons to read square wave for pin %s" % 4) self.log.info("Inside sendBtnPush(). Added callback for buttons to read square wave for pin %s" % 25) RPIO.wait_for_interrupts() self.log.info("Inside sendBtnPush(). We just got passed RPIO.wait_for_interrupts() which is awesome cuz thought blocking here never ended.") # now remove the callbacks because we're done sending and no need # to keep the load on our script of handling callcacks RPIO.del_interrupt_callback(4) RPIO.del_interrupt_callback(25) self.log.info("Removed interrupt callbacks for GPIO 4 and 25 for button pushing.") # Make sure to send high to opto-coupler to ensure # espresso side is back to low RPIO.output(9, True) RPIO.output(10, True) '''
def setupRPIO(self): # Button event detection on release RPIO.setmode(RPIO.BCM) RPIO.setup(17, RPIO.IN, pull_up_down=RPIO.PUD_UP) RPIO.add_interrupt_callback(17, self.gpio_callback, edge='rising', debounce_timeout_ms=1000) # wait 1 second between to event RPIO.wait_for_interrupts(threaded=True)
def start_run(self): if args.verbose: print "[%s] thread : start_run called" % (self.name) #Tell function which globals to look for (need time values as globals so that callback #function sned_triggers can also see them) global bor_time_s global old_bof_time_s global old_eof_time_s global old_gpio_trig_time_s #Check not already running if self.running==False: if args.verbose: print "[%s] thread : Run started" % (self.name) print 'Starting run : Set t = 0 s : Waiting for triggers' #Init time values bor_time_s = time.time() #Record BOR time old_bof_time_s = 0 #Init 'old' times old_eof_time_s = 0 old_gpio_trig_time_s = 0 #If in real triggers mode, setup RPIO listen if args.which == 'real': #Clean RPIO system before creating a new callback process #This removes any existing wait_for_interrupts threads, which otherwise lead to multiple #simultaneous BOF signals being send for a single pin signal #Note: Must call this at start of evey run (otherwise get issues with first pin interrupt #when there is a long (a few seconds)wait between the socket connection forming and BOR) RPIO.cleanup() #Define callback function for pin interrupts (e.g. function that is called when a #pin interrupts). The callback function sends the BOF/EOF triggers to the socket. #Note: Must call this at start of evey run (otherwise get issues with first pin interrupt #when there is a long (a few seconds)wait between the socket connection forming and BOR) RPIO.add_interrupt_callback(args.input_pin, send_fill, edge='both', pull_up_down=RPIO.PUD_UP, \ threaded_callback=False, debounce_timeout_ms=args.debounce_timeout_ms) #Start thread listening for input signal on pins if args.verbose: print "[%s] thread : Starting GPIO wait_for_interrupts thread" % (self.name) RPIO.wait_for_interrupts(threaded=True) #If in fake triggers mode, start fake trigger generation thread elif args.which == 'fake': #Create fake trigger thread and start it if args.verbose: print "[%s] thread : Starting fake triggers thread" % (self.name) self.fake_trigger_thread = FakeTriggerThread("FakeTriggers") self.fake_trigger_thread.start() #Update state self.running = True #Can't start run if one already underway else: if args.verbose: print "[%s] thread : Could not start run, there is already a run underway" % (self.name)
def __init__(self, player): self.player = player RPIO.setup(PIN_ROTARY_B, RPIO.IN, pull_up_down=RPIO.PUD_UP, initial=RPIO.HIGH) RPIO.add_interrupt_callback(PIN_ROTARY_A, self.process_movement, edge='falling', pull_up_down=RPIO.PUD_UP, debounce_timeout_ms=15) RPIO.add_interrupt_callback(PIN_ROTARY_BTN, self.button_pressed, edge='falling', pull_up_down=RPIO.PUD_UP, debounce_timeout_ms=15)
def watch_start(self, start_callback): self.flag_ignore_start = False RPIO.setup(self.gpio_heads_start, RPIO.IN, pull_up_down=RPIO.PUD_DOWN) RPIO.wait_for_interrupts(threaded=True) RPIO.add_interrupt_callback(self.gpio_heads_start, start_callback, edge='rising', debounce_timeout_ms=self.timeout, pull_up_down=RPIO.PUD_DOWN)
def registerReader(self, edge = 'falling', pull_up_down=RPIO.PUD_UP): RPIO.setup(self.GPIO_0, RPIO.IN) RPIO.setup(self.GPIO_1, RPIO.IN) RPIO.add_interrupt_callback(self.GPIO_0, self.addBitToTag, edge = edge, pull_up_down = pull_up_down) RPIO.add_interrupt_callback(self.GPIO_1, self.addBitToTag, edge = edge, pull_up_down = pull_up_down) #Initializing timer self.t = threading.Timer(0.1, self.processTag) self.t.start()
def initializeInterrupt(self): log.info("Initializing interrupt for pin (RPIO.BCM) #" + str(self.gpio_pin)) try: RPIO.setmode(RPIO.BCM) RPIO.setup(int(self.gpio_pin),RPIO.IN, pull_up_down=RPIO.PUD_UP) RPIO.add_interrupt_callback(int(self.gpio_pin), self.gpio_callback, edge='rising') RPIO.wait_for_interrupts(threaded=True) except: log.error("RPIO library is missing")
def enableTrack(self,tag_id): if self.rfid_enable==True: print "tagid %s enabled track %s"%(tag_id,self.track_id) self.rfid_enable=False self.tag_id=tag_id self.track_clk.start(20000) self.rfid_label.setText("%s"%tag_id) self.timer_enable=True RPIO.add_interrupt_callback(self.gpio_b,self.startClk,edge='rising',pull_up_down=RPIO.PUD_UP,debounce_timeout_ms=None)
def init(callback): RPIO.setup(IRQ, RPIO.IN) #IRQ RPIO.setup(CSN, RPIO.OUT) #CSN RPIO.setup(CE, RPIO.OUT) #CE RPIO.output(CSN, True) RPIO.output(CE, False) spi.open(0,0) # wybieramy wolny CE na RPi, nie bedziemy z niego korzystac RPIO.add_interrupt_callback(IRQ, callback, edge='falling', pull_up_down=RPIO.PUD_OFF) RPIO.wait_for_interrupts(threaded=True)
def initHardware(): global sensor sensor = SensorCom("/dev/ttyAMA0", 9600) display.init_tft() display.printok(READY_FOR_ACTION) # set up GPIO output channel RPIO.setup(23, RPIO.OUT, initial=RPIO.LOW) RPIO.add_interrupt_callback(24, gpioCapSensor_callback, edge='falling', debounce_timeout_ms=200) RPIO.wait_for_interrupts(threaded = True)
def startReadingState(self): # start reading state from leds for 2 seconds # that should give us enough time to get a decent sample in case # the Raspi is busy and thus our callbacks aren't accurate in their reading self.log.info("Starting to read state off LEDs for 2 sec") # Reset global ctr self.ctrRising = 0 # Reset data for e in self.indx: self.dataq7[e] = 0 self.dataq8[e] = 0 RPIO.add_interrupt_callback(4, self.on_q8_rising, edge='rising', threaded_callback=False) RPIO.add_interrupt_callback(25, self.on_q7_rising, edge='rising', threaded_callback=False) self.log.info("Inside startReadingState(). Added callback for pin %s" % 4) self.log.info("Inside startReadingState(). Added callback for pin %s" % 25) #pdb.set_trace() RPIO.wait_for_interrupts() self.log.info("Inside startReadingState(). We just got passed RPIO.wait_for_interrupts() which is awesome cuz thought blocking here never ended.") # if we've gottent this far, that's awesome cuz we were finding we never # got here. so now we can remove callbacks. we know we only get here once # so this is clean. RPIO.del_interrupt_callback(4) RPIO.del_interrupt_callback(25) self.log.info("Inside startReadingState(). Removed interrupt callbacks for GPIO 4 and 25.") # let's make sure the doneReadingState() method is finished # this is because it does a sleep() and we don't want # to return from here until that sleep is finished ''' # make sure our ctrRising hasn't changed in a second or so start_time = time.time() elapsed_time = 0 loc_ctr = self.ctrRising self.log.info("Going to do yield loop for 1 second. Seems to ensure all callbacks are completed before I return.") loopCtr = 0 while (elapsed_time < 1): loopCtr += 1 # if we are having a moving ctrRising, reset our start time. i want 1 full second # of no movement on ctrRising if (loc_ctr != self.ctrRising): self.log.info("ctrRising was still changing. resetting start_time to now to extend our wait.") start_time = time.time() sleep(0.001) #self.log.info("In yield loop to make sure all our interrupt callbacks came back. self.ctrRising: %s, elapsed_time: %s" % (self.ctrRising, elapsed_time)) elapsed_time = time.time() - start_time self.log.info("Returning from startReadingState(). Done with yield loop. Looped: %s" % loopCtr) ''' self.log.info("Done with startReadingState(). Only here should main zwtextspressod continue on.")
def startClk(self,gpio,val): if self.timer_enable==True: print "tagid %s started run on track %s"%(self.tag_id,self.track_id) self.timer_enable=False RPIO.del_interrupt_callback(self.gpio_b) self.t_0=datetime.datetime.now() self.timer_clk.start(5) self.track_clk.stop() self.timer_running=True self.gui_data.update() RPIO.add_interrupt_callback(self.gpio_e,self.stopClk,edge='rising',pull_up_down=RPIO.PUD_UP,debounce_timeout_ms=None)
def init_button_led(config): config['comms'] = 0 if config['button']: RPIO.setup(config['button'], RPIO.IN) RPIO.add_interrupt_callback(config['button'], key_hit, threaded_callback=True, debounce_timeout_ms=100) RPIO.wait_for_interrupts(threaded=True) if config['led']: t = threading.Thread(target=blink_lights, args=(config,)) t.daemon = True t.start()
def __init__( self, firstPin, secondPin ): self.firstPin = firstPin self.secondPin = secondPin RPIO.setup( self.firstPin, RPIO.IN ) RPIO.setup( self.secondPin, RPIO.IN ) self.firstPinState = RPIO.input( self.firstPin ) self.secondPinState = RPIO.input( self.secondPin ) RPIO.add_interrupt_callback( self.firstPin, self.encoderCallback ) RPIO.add_interrupt_callback( self.secondPin, self.encoderCallback ) self.tickCount = 0 self.edgeMissed = False
def __init__(self): super(Button, self).__init__() self.name = self.__class__.__name__ self._logger = AsyncLogger() self._button_press_time = None self._run = True RPIO.setup(BUTTON_GPIO_PIN, RPIO.IN, RPIO.PUD_DOWN) RPIO.add_interrupt_callback( BUTTON_GPIO_PIN, self.gpio_callback, debounce_timeout_ms=50 ) self._command = CommandProducer()
def setup(self): GPIO.setmode(GPIO.BCM) for pin in outputs.values(): GPIO.setup(pin, GPIO.OUT) self._power(False) self._direction(False) for (name, pin) in inputs.items(): GPIO.setup(pin, GPIO.IN, pull_up_down=GPIO.PUD_UP) GPIO.add_interrupt_callback(pin, self._delay(0.05, self._ifhigh(getattr(self,name))), edge='both', debounce_timeout_ms=100) if self.port: GPIO.add_tcp_callback(self.port, self.command_dispatch)
def _set_when_changed(self, value): if self._when_changed is None and value is not None: self._when_changed = value RPIO.add_interrupt_callback( self._number, lambda channel, value: self._when_changed(), self._edges, self.GPIO_PULL_UPS[self._pull], self._bounce) elif self._when_changed is not None and value is None: try: RPIO.del_interrupt_callback(self._number) except KeyError: # Ignore this exception which occurs during shutdown; this # simply means RPIO's built-in cleanup has already run and # removed the handler pass self._when_changed = None else: self._when_changed = value
def __init__(self): """""" RPIO.setmode(RPIO.BCM) RPIO.setwarnings(False) RPIO.setup(self.LEFT_GO_PIN, RPIO.OUT) RPIO.setup(self.LEFT_DIR_PIN, RPIO.OUT) RPIO.setup(self.RIGHT_GO_PIN, RPIO.OUT) RPIO.setup(self.RIGHT_DIR_PIN, RPIO.OUT) RPIO.setup(self.LED1_PIN, RPIO.OUT) RPIO.setup(self.LED2_PIN, RPIO.OUT) RPIO.setup(self.OC1_PIN, RPIO.OUT) RPIO.setup(self.OC2_PIN, RPIO.OUT) RPIO.setup(self.SW1_PIN, RPIO.IN) RPIO.setup(self.SW2_PIN, RPIO.IN) RPIO.setup(self.TRIGGER_PIN, RPIO.OUT) RPIO.setup(self.ECHO_PIN, RPIO.IN) RPIO.add_interrupt_callback(self.SW1_PIN, self.on_collision) RPIO.add_interrupt_callback(self.SW2_PIN, self.on_collision)
def __init__(self): """ Initialize GPIO subsystem and install websocket handlers """ Handler.__init__(self) # Install websocket & RPIO callbacks for port in GpioHandler.PORTS: pin = GpioHandler.PORTS[port]['bcm'] self.add_listener(port + ".sample") self.add_listener(port + ".profile") logging.debug("installing RPIO handlers for pin %s", pin) # For now, we just set everything to input with pull up # we'll fix that with profiles later RPIO.setup(pin, RPIO.IN, pull_up_down=RPIO.PUD_UP) RPIO.add_interrupt_callback(pin, self._edge, debounce_timeout_ms=50) self.start()
def __init__(self, channel_a=27, channel_b=4, debounce_ms=50, channel_sw=22): self.last_val = 0 self.last = None self.debounce = debounce_ms; self.click_count = 0 self.callback = None self.click_callback = None self.channel_a = channel_a self.channel_b = channel_b self.channel_sw = channel_sw # change to BCM numbering schema RPIO.setmode(RPIO.BCM) RPIO.setup(channel_a, RPIO.IN) RPIO.set_pullupdn(channel_a, RPIO.PUD_UP) RPIO.setup(channel_b, RPIO.IN) RPIO.set_pullupdn(channel_b, RPIO.PUD_UP) RPIO.setup(22, RPIO.IN) RPIO.set_pullupdn(channel_sw, RPIO.PUD_UP) # GPIO interrupt callbacks RPIO.add_interrupt_callback(channel_a, self.__gpio_callback, edge="both") RPIO.add_interrupt_callback(channel_b, self.__gpio_callback, edge="both") RPIO.add_interrupt_callback(channel_sw, self.__click_callback, edge="both", pull_up_down=RPIO.PUD_UP, debounce_timeout_ms=300)
def init(ptt_pin=27, ptt_on_level=1,radio_pin=17,radio_on_level=0,radio_on_cb=None,radio_off_cb=None): GPIO.ptt_pin = ptt_pin GPIO.ptt_on_level = ptt_on_level GPIO.radio_pin = radio_pin GPIO.radio_on_level = radio_on_level if radio_on_level==0: GPIO.radio_off_level = 1 else: GPIO.radio_off_level = 0 GPIO.radio_on_cb = radio_on_cb GPIO.radio_off_cb = radio_off_cb print "RPi Board rev %d" % (RPIO.RPI_REVISION) RPIO.setwarnings(False) #RPIO.setmode(RPIO.BOARD) if GPIO.ptt_on_level == 1: RPIO.setup(GPIO.ptt_pin, RPIO.OUT, initial=RPIO.LOW) else: RPIO.setup(GPIO.ptt_pin, RPIO.OUT, initial=RPIO.HIGH) #- Using interrupts - RPIO.setup(COR_PIN,RPIO.IN) RPIO.add_interrupt_callback(GPIO.radio_pin, GPIO.gpio_callback, threaded_callback=True) RPIO.wait_for_interrupts(threaded=True) pass
def __init__(self, encoderGPIO): #encoder GPIO self.encoderGPIO = encoderGPIO #setup the encoder pins - don't use internal pull-up/down #there is allready an external pull-down in place #from the 5v/3V conversion through 15k-gnd/10k-5v resistors # RPIO.setup(self.encoderGPIO, RPIO.IN) #append the encoder event to it's callback function # workaround new_gpio= RPIO.channel_to_gpio(self.encoderGPIO) RPIO.setmode(RPIO.BCM) RPIO.setup(new_gpio, RPIO.IN) RPIO.add_interrupt_callback(new_gpio, callback=self.encoder_callback, edge='both',pull_up_down=RPIO.PUD_OFF, debounce_timeout_ms=2,threaded_callback=True) RPIO.setmode(RPIO.BOARD) #counter variable self.encoder_count = 0 #which direction (-1=cw/1=ccw) self.direction = 1
def turn_on(self): print('Initialize GPIO pins') RPIO.setup(self.pin_led_red, RPIO.OUT) RPIO.setup(self.pin_led_yel, RPIO.OUT) RPIO.setup(self.pin_led_grn, RPIO.OUT) RPIO.setup(self.pin_butt_red, RPIO.IN) RPIO.setup(self.pin_butt_yel, RPIO.IN) RPIO.setup(self.pin_butt_grn, RPIO.IN) print('Configure GPIO callback event handlers') fn = self.callback_end_looping RPIO.add_interrupt_callback(self.pin_butt_red, fn, edge='falling', pull_up_down=RPIO.PUD_UP, threaded_callback=True, debounce_timeout_ms=100) fn = self.blink_led RPIO.add_interrupt_callback(self.pin_butt_red, fn, edge='falling', pull_up_down=RPIO.PUD_UP, threaded_callback=True, debounce_timeout_ms=100) RPIO.add_interrupt_callback(self.pin_butt_yel, fn, edge='falling', pull_up_down=RPIO.PUD_UP, threaded_callback=True, debounce_timeout_ms=100) RPIO.add_interrupt_callback(self.pin_butt_grn, fn, edge='falling', pull_up_down=RPIO.PUD_UP, threaded_callback=True, debounce_timeout_ms=100) RPIO.wait_for_interrupts(threaded=True) print('Instantiate controller objects') self.D_0 = damped_servo.DampedServo(self.channel_0, damped_servo.info_sg5010, self.scale_0) self.D_1 = damped_servo.DampedServo(self.channel_1, damped_servo.info_sg92r, self.scale_1, sign=-1) self.D_2 = damped_servo.DampedServo(self.channel_2, damped_servo.info_eflrs60, self.scale_2, sign=-1) self.D_3 = damped_servo.DampedServo(self.channel_3, damped_servo.info_eflrs60, self.scale_3, sign=-1) self.D_4 = damped_servo.DampedServo(self.channel_4, damped_servo.info_sg92r, self.scale_4, sign=-1, vmin=230) self.D_0.start() self.D_1.start() self.D_2.start() self.D_3.start() self.D_4.start() self.D_0.pulse(0) self.D_1.pulse(0) self.D_2.pulse(0) self.D_3.pulse(0) self.D_4.pulse(0)
def addInterrupt(self, pin, callback): self._checkPortIsType(pin, RPIO.IN) RPIO.add_interrupt_callback(pin, callback)
if direction: step_idx[axis] = (step_idx[axis] + 1) % len(STEPS) else: step_idx[axis] = (step_idx[axis] - 1) % len(STEPS) sleep(0.001) try: for gpio in MOTOR_X + MOTOR_Y: RPIO.setup(gpio, RPIO.OUT, initial=RPIO.LOW) for gpio in ENDSTOPS: RPIO.setup(gpio, RPIO.IN, pull_up_down=RPIO.PUD_DOWN) RPIO.add_interrupt_callback(gpio, endstop_hit, pull_up_down=RPIO.PUD_DOWN, debounce_timeout_ms=10, threaded_callback=True) RPIO.wait_for_interrupts(threaded=True) while(True): k = readchar.readkey() if k == '\x03': break elif k == readchar.key.UP: for i in range(0,8*100): step(Y,UP) elif k == readchar.key.DOWN: for i in range(0,8*100): step(Y,DOWN) elif k == readchar.key.LEFT: for i in range(0,8*100):
def __setupConnections(self): pin = self.getInternalPin() RPIO.add_interrupt_callback(pin, self.__callbackFunction) RPIO.wait_for_interrupts(threaded=True)
RPIO.add_interrupt_callback(8,call_C4,edge='falling',pull_up_down=RPIO.PUD_UP,debounce_timeout_ms=tb) def call_C4(gpio_id,val): print "C4-8" RPIO.del_interrupt_callback(8) RPIO.add_interrupt_callback(7,call_P4,edge='falling',pull_up_down=RPIO.PUD_UP,debounce_timeout_ms=tb) RPIO.add_interrupt_callback(4,call_P1,edge='falling',pull_up_down=RPIO.PUD_UP,debounce_timeout_ms=100) RPIO.add_interrupt_callback(17,call_P2,edge='falling',pull_up_down=RPIO.PUD_UP,debounce_timeout_ms=100) RPIO.add_interrupt_callback(21,call_P3,edge='falling',pull_up_down=RPIO.PUD_UP,debounce_timeout_ms=100) RPIO.add_interrupt_callback(7,call_P4,edge='falling',pull_up_down=RPIO.PUD_UP,debounce_timeout_ms=100) RPIO.wait_for_interrupts(threaded=True) print "Ready... Let's play the piano..." try:
def call_P2(gpio,val): print "P2-17" RPIO.del_interrupt_callback(17) RPIO.add_interrupt_callback(18,call_C2,edge='falling',pull_up_down=RPIO.PUD_UP,debounce_timeout_ms=tb)
def call_P3(gpio,val): print "P3-21" RPIO.del_interrupt_callback(21) RPIO.add_interrupt_callback(22,call_C3,edge='falling',pull_up_down=RPIO.PUD_UP,debounce_timeout_ms=tb)
mcp.configPinInterrupt(inpin, mcp.INTERRUPTON, mcp.INTERRUPTCOMPAREPREVIOUS) # use a builting GPIO pin from the Pi to detect any change on the mcp23017 # specify the callback function # edge must be set to rising - rising to high indicates the interrupt happened, # while falling is just the pin resetting # set the pin to pull down to act as a sink when the mcp23017 int pin goes high # do not thread - the mcp23017 int pin stays high until cleared even if multiple # interrupts occur. there is a risk that we'll miss an interrupt if they happen # very quickly together # set a very small debounce. 5ms seems good. higher and you could end up with # the int pin getting "stuck" GPIO.add_interrupt_callback(4, inthappened, edge='rising', pull_up_down=GPIO.PUD_DOWN, threaded_callback=False, debounce_timeout_ms=5) # regular GPIO wait for interrupts GPIO.wait_for_interrupts(threaded=True) while (True): mcp.output(ledpin, 1) time.sleep(.1) #mcp.output(ledpin, 0) time.sleep(2) # this is a failsafe for the instance when two interrupts happen before # the debounce timeout expires. it will check for interrupts on the pin # three times in a row, .5 seconds apart. if it gets to the end of 3 # iterations, we're probably stuck so it will reset mcp.clearInterrupts() except Exception as e:
# GPIO interrupt callbacks. Note this resets any previous config of pullup resistor # RPIO.add_interrupt_callback(INTPIN, gpio_callback2, edge='falling',pull_up_down=RPIO.PUD_UP, debounce_timeout_ms=100) # RPIO.add_interrupt_callback(INTPIN, gpio_callback2, edge='both', pull_up_down=RPIO.PUD_DOWN, debounce_timeout_ms=10) #Interrupt adatto ad avere un tic ogni 100 msec. #RPIO.add_interrupt_callback(INTPIN, gpio_callback1, edge='rising', pull_up_down=RPIO.PUD_OFF, debounce_timeout_ms=100) #Interrupt adatto ad avere un tic ogni 2,87 msec. il massimo che si ottiene con le resistenze scelte #RPIO.add_interrupt_callback(INT7, gpio_callback_INT7, edge='rising', pull_up_down=RPIO.PUD_UP)#, debounce_timeout_ms=100) #RPIO.add_interrupt_callback(INT8, gpio_callback_INT8, edge='rising', pull_up_down=RPIO.PUD_UP)#, debounce_timeout_ms=100) #RPIO.add_interrupt_callback(INT25, gpio_callback_INT25, edge='rising', pull_up_down=RPIO.PUD_UP)#, debounce_timeout_ms=100) #RPIO.add_interrupt_callback(INT24, gpio_callback_INT24, edge='rising', pull_up_down=RPIO.PUD_UP)#, debounce_timeout_ms=100) #RPIO.add_interrupt_callback(INT23, gpio_callback_INT23, edge='rising', pull_up_down=RPIO.PUD_UP)#, debounce_timeout_ms=100) #RPIO.add_interrupt_callback(INT18, gpio_callback_INT18, edge='rising', pull_up_down=RPIO.PUD_UP)#, debounce_timeout_ms=100) RPIO.add_interrupt_callback( INT11, gpio_callback_INT11, edge='rising', pull_up_down=RPIO.PUD_UP) #, debounce_timeout_ms=100) RPIO.add_interrupt_callback( INT9, gpio_callback_INT9, edge='rising', pull_up_down=RPIO.PUD_UP) #, debounce_timeout_ms=100) RPIO.add_interrupt_callback( INT10, gpio_callback_INT10, edge='rising', pull_up_down=RPIO.PUD_UP) #, debounce_timeout_ms=100) RPIO.add_interrupt_callback( INT22, gpio_callback_INT22, edge='rising', pull_up_down=RPIO.PUD_UP) #, debounce_timeout_ms=100) #RPIO.add_interrupt_callback(INT27, gpio_callback_INT27, edge='rising', pull_up_down=RPIO.PUD_UP)#, debounce_timeout_ms=100) #RPIO.add_interrupt_callback(INT17, gpio_callback_INT17, edge='rising', pull_up_down=RPIO.PUD_UP)#, debounce_timeout_ms=100) #RPIO.add_interrupt_callback(INT4, gpio_callback_INT4, edge='rising', pull_up_down=RPIO.PUD_UP)#, debounce_timeout_ms=100) #RPIO.add_interrupt_callback(INT3, gpio_callback_INT3, edge='rising', pull_up_down=RPIO.PUD_UP)#, debounce_timeout_ms=100) #RPIO.add_interrupt_callback(INT2, gpio_callback_INT2, edge='rising', pull_up_down=RPIO.PUD_UP)#, debounce_timeout_ms=100)
input_pins = (18,19,20,21,22,23,24,25,26,27) def writeDoorState(when, state): db = MySQLdb.connect(vars.mysqlHost,vars.mysqUser,vars.mysqlPassword,vars.mysqlDatabase) cursor = db.cursor() sql = "INSERT INTO door(bool, date, name) VALUES (0, '%s', '%s')" % (when , state) try: # Execute the SQL command cursor.execute(sql) # Commit your changes in the database db.commit() except: # Rollback in case there is any error db.rollback() db.close() for i in xrange(len(input_pins)): RPIO.setup(input_pins[i], RPIO.IN, pull_up_down=RPIO.PUD_DOWN) def write_door_state(gpio_id, val): if val==0: bot.send_message(telegram_id, "Openning") writeDoorState(time.strftime("%d.%m.%Y %H:%M:%S"), 'Open') else: bot.send_message(telegram_id, "Closing") writeDoorState(time.strftime("%d.%m.%Y %H:%M:%S"), 'Close') RPIO.add_interrupt_callback(24, write_door_state,pull_up_down=RPIO.PUD_DOWN,threaded_callback=True, debounce_timeout_ms=50) RPIO.wait_for_interrupts()
# cash = 0 # data = [ measTime.strftime("%d/%m %H:%M:%S:%f"), consumption, cash ] # data = [ prevTime.strftime("%d/%m %H"), kWh ] # logFile.write(json.dumps(data) + '\n') # print(data) #check & rotate file # logFile.close() #while True: # time.sleep(2) # counterTick(14,1) RPIO.add_interrupt_callback(PIN_CWU_HEATER, counterTick, edge='falling', pull_up_down=RPIO.PUD_OFF, threaded_callback=True, debounce_timeout_ms=None) RPIO.add_interrupt_callback(PIN_CO_HEATER, counterTick, edge='falling', pull_up_down=RPIO.PUD_OFF, threaded_callback=True, debounce_timeout_ms=None) RPIO.add_interrupt_callback(PIN_HEAT_PUMP, counterTick, edge='falling', pull_up_down=RPIO.PUD_OFF, threaded_callback=True, debounce_timeout_ms=None) RPIO.add_interrupt_callback(PIN_POWER_SUPPLY,
#!/usr/bin/python from __future__ import division import RPi.GPIO as GPIO import os, time import RPIO def Init(): RPIO.setmode(GPIO.BCM) RPIO.setup(17, RPIO.IN, pull_up_down=RPIO.PUD_UP) RPIO.setup(27, RPIO.OUT, initial=RPIO.LOW) print("[Info] Telling RaspiShield we are running on pin 27") def off(gpio, value): print("[Info] RaspiShield requesting shutdown on pin 17") RPIO.setup(27, RPIO.HIGH) os.system("sudo shutdown -h now") RPIO.cleanup() time.sleep(0.5) Init() RPIO.add_interrupt_callback(17, off, edge='falling') RPIO.wait_for_interrupts()
""" Example of how to use GPIO and TCP interrupts with RPIO. RPIO Documentation: http://pythonhosted.org/RPIO """ import RPIO def gpio_callback(gpio_id, val): print("gpio %s: %s" % (gpio_id, val)) def socket_callback(socket, val): print("socket %s: '%s'" % (socket.fileno(), val)) socket.send("echo: %s\n" % val) RPIO.close_tcp_client(socket.fileno()) # Two GPIO interrupt callbacks (second one with a debouce timeout of 100ms) RPIO.add_interrupt_callback(17, gpio_callback) RPIO.add_interrupt_callback(14, gpio_callback, edge='rising', \ debounce_timeout_ms=100) # One TCP interrupt callback (opens socket server at port 8080) RPIO.add_tcp_callback(8080, socket_callback) # Starts waiting for interrupts (exit with Ctrl+C) RPIO.wait_for_interrupts()
dCount += 1 dSum += dTime #stampa ogni tic # print("CB1: gpio %s: %s at %s delta: %08.6f" % (gpio_id, val, dstr, dTime)) # GPIO interrupt callbacks. Note this resets any previous config of pullup resistor # RPIO.add_interrupt_callback(INTPIN, gpio_callback2, edge='falling',pull_up_down=RPIO.PUD_UP, debounce_timeout_ms=100) # RPIO.add_interrupt_callback(INTPIN, gpio_callback2, edge='both', pull_up_down=RPIO.PUD_DOWN, debounce_timeout_ms=10) #Interrupt adatto ad avere un tic ogni 100 msec. #RPIO.add_interrupt_callback(INTPIN, gpio_callback1, edge='rising', pull_up_down=RPIO.PUD_OFF, debounce_timeout_ms=100) #Interrupt adatto ad avere un tic ogni 2,87 msec. il massimo che si ottiene con le resistenze scelte RPIO.add_interrupt_callback( INTtasto1, gpio_callback1, edge='rising', pull_up_down=RPIO.PUD_OFF) #, debounce_timeout_ms=100) RPIO.add_interrupt_callback( INTtasto2, gpio_callback2, edge='rising', pull_up_down=RPIO.PUD_OFF) #, debounce_timeout_ms=100) # Starts waiting for interrupts (exit with Ctrl+C) # RPIO.wait_for_interrupts() # blocks until interrupt, never proceeds beyond this point RPIO.wait_for_interrupts(threaded=True) # non-blocking, separate thread #Loop principale che non fa niente. Aspetta e basta. try: while (1): RPIO.output(led1, RPIO.HIGH)
def call_C3(gpio_id,val): print "C3-22" RPIO.del_interrupt_callback(22) RPIO.add_interrupt_callback(21,call_P3,edge='falling',pull_up_down=RPIO.PUD_UP,debounce_timeout_ms=tb)
def set_button_callback(self, callback): RPIO.add_interrupt_callback(self.button_pin, callback, edge='rising', debounce_timeout_ms=1000)
def call_C2(gpio_id,val): print "C2-18" RPIO.del_interrupt_callback(18) RPIO.add_interrupt_callback(17,call_P2,edge='falling',pull_up_down=RPIO.PUD_UP,debounce_timeout_ms=tb)
dCount2 += 1 dSum2 += dTime2 #stampa tic 4013 # print("CB-2: ---------------> gpio %s: %s at %s delta: %08.6f" % (gpio_id, val, dstr2, dTime2)) # GPIO interrupt callbacks. Note this resets any previous config of pullup resistor # RPIO.add_interrupt_callback(INTPIN, gpio_callback2, edge='falling',pull_up_down=RPIO.PUD_UP, debounce_timeout_ms=100) # RPIO.add_interrupt_callback(INTPIN, gpio_callback2, edge='both', pull_up_down=RPIO.PUD_DOWN, debounce_timeout_ms=10) #Interrupt adatto ad avere un tic ogni 100 msec. #RPIO.add_interrupt_callback(INTPIN, gpio_callback1, edge='rising', pull_up_down=RPIO.PUD_OFF, debounce_timeout_ms=100) #Interrupt adatto ad avere un tic ogni 2,87 msec. il massimo che si ottiene con le resistenze scelte RPIO.add_interrupt_callback( INT555, gpio_callback_1, edge='rising', pull_up_down=RPIO.PUD_UP) #, debounce_timeout_ms=100) RPIO.add_interrupt_callback( INT4013, gpio_callback_2, edge='rising', pull_up_down=RPIO.PUD_UP) #, debounce_timeout_ms=100) # Starts waiting for interrupts (exit with Ctrl+C) # RPIO.wait_for_interrupts() # blocks until interrupt, never proceeds beyond this point RPIO.wait_for_interrupts(threaded=True) # non-blocking, separate thread try: while (1): now1 = datetime.datetime.now() dstr1 = str(now1.strftime("%Y-%m-%d_%H:%M:%S")) if (dCount1 > 0):
def call_C1(gpio_id,val): print "C1-25" RPIO.del_interrupt_callback(25) RPIO.add_interrupt_callback(4,call_P1,edge='falling',pull_up_down=RPIO.PUD_UP,debounce_timeout_ms=tb)
SPIMOSI = 24 SPICS = 25 # set up the pins RPIO.setup(SPIMOSI, RPIO.OUT) RPIO.setup(SPIMISO, RPIO.IN) RPIO.setup(SPICLK, RPIO.OUT) RPIO.setup(SPICS, RPIO.OUT) RPIO.setup(19, RPIO.OUT) RPIO.setup(26, RPIO.OUT) RPIO.setup(16, RPIO.OUT) RPIO.setup(20, RPIO.OUT) RPIO.setup(4, RPIO.IN, pull_up_down=RPIO.PUD_UP) RPIO.add_interrupt_callback(4, PWR_func, edge="falling", debounce_timeout_ms=50) servo = PWM.Servo() servo_pos = 1300 # joystick ADC channels joy_x_adc = 0 joy_y_adc = 1 while True: try: # get joystick position from ADC joy_x = readadc(joy_x_adc, SPICLK, SPIMOSI, SPIMISO, SPICS) joy_y = readadc(joy_y_adc, SPICLK, SPIMOSI, SPIMISO, SPICS)
def call_P1(gpio,val): print "P1-4" RPIO.del_interrupt_callback(4) RPIO.add_interrupt_callback(25,call_C1,edge='falling',pull_up_down=RPIO.PUD_UP,debounce_timeout_ms=tb)
def call_C4(gpio_id,val): print "C4-8" RPIO.del_interrupt_callback(8) RPIO.add_interrupt_callback(7,call_P4,edge='falling',pull_up_down=RPIO.PUD_UP,debounce_timeout_ms=tb)
RPIO.setmode(RPIO.BOARD) log.basicConfig(filename='/var/log/garage.log', level=log.DEBUG, format="%(asctime)s %(levelname)s: %(message)s") SENSORS = {15: 'Dan', 11: 'Victoria'} def sensor_event(chan, msg): name = SENSORS[chan] position = 'open' if RPIO.input(chan) else 'closed' if chan not in last_status or last_status['chan'] != position: last_status[chan] = position log.info("%s's door is %s: %s", name, position, msg) if __name__ == '__main__': last_status = {} log.info('script started, setting up handlers') for chan, name in SENSORS.iteritems(): RPIO.add_interrupt_callback(chan, sensor_event, debounce_timeout_ms=100) log.info("set up handler for %s's door", name) sensor_event(chan) log.info('setup complete') RPIO.wait_for_interrupts()
def test6_interrupts(self): logging.info(" ") logging.info(" ") logging.info("=== INTERRUPT TESTS ==") def test_callback(*args): logging.info("- interrupt callback received: %s", (args)) def stop_interrupts(timeout=3): time.sleep(timeout) RPIO.stop_waiting_for_interrupts() logging.info("- called `stop_waiting_for_interrupts()`") PORT = 8080 def socket_callback(socket, msg): logging.info("Socket [%s] msg received: %s", socket.fileno(), msg) def socket_client(timeout=3): logging.info("Socket client connecting in 3 seconds...") time.sleep(timeout) s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect(("localhost", PORT)) s.sendall("Hello, world".encode('utf-8')) s.close() logging.info("Socket client done...") # # Interrupt test with socket comm # logging.info(" ") logging.info("Testing interrupts on GPIO-%s and socket comm", GPIO_IN) RPIO.add_tcp_callback(PORT, socket_callback) with self.assertRaises(AttributeError): RPIO.add_tcp_callback(8081, None) RPIO.add_interrupt_callback(GPIO_IN, test_callback, edge='both', \ pull_up_down=RPIO.PUD_DOWN) RPIO.add_interrupt_callback(GPIO_IN, test_callback, edge='both', \ pull_up_down=RPIO.PUD_DOWN, threaded_callback=True) # Add a number of TCP clients Thread(target=socket_client).start() Thread(target=socket_client, args=(4, )).start() Thread(target=socket_client, args=(4, )).start() Thread(target=socket_client, args=(4, )).start() Thread(target=socket_client, args=(4, )).start() # One stop interrupts thread Thread(target=stop_interrupts, args=(10, )).start() logging.info("- waiting 10s for interrupts on GPIO-%s...", GPIO_IN) RPIO.wait_for_interrupts() logging.info("-") RPIO.cleanup() # # Auto interrupt shutdown with thread and stop_waiting_for_interrupts # logging.info("start second ") RPIO.add_interrupt_callback(GPIO_IN, test_callback, edge='both', \ pull_up_down=RPIO.PUD_OFF) RPIO.add_interrupt_callback(GPIO_OUT, test_callback, edge='falling', \ pull_up_down=RPIO.PUD_UP, debounce_timeout_ms=100) logging.info("- waiting 3s for interrupts on gpio %s and %s...", \ GPIO_IN, GPIO_OUT) Thread(target=stop_interrupts, args=(3, )).start() RPIO.wait_for_interrupts() logging.info("-") RPIO.cleanup() logging.info("ALL DONE :)")
def gpio_callback(channel, val): if(val == 0): return action = keymap[channel] print 'Edge detected on channel {0}, mapped to action "{1}".'.format(channel, action) tries = 0 while tries < 3: if trySendAction(action): break else: tries += 1 connect() # Setup gpio mapping for gpio_id in keymap: RPIO.setup(gpio_id, RPIO.IN) RPIO.add_interrupt_callback(gpio_id, gpio_callback, edge='rising', debounce_timeout_ms=200) # RPIO.wait_for_interrupts(threaded=True) RPIO.wait_for_interrupts() RPIO.cleanup() disconnect()
mcpa = mcps[mcpi] mcpp = setupMCP(i2cs[mcpi], mcpa[1]) mcps[mcpi][3] = mcpp[0] mcps[mcpi][4] = mcpp[1] for pin in gpios: if (type(pin).__name__!="int" or pin == 0): continue if (verbose == 1): print("Setting up %s" % pin) GPIO.setup(pin, GPIO.IN, pull_up_down=GPIO.PUD_UP) if (verbose == 1): print("%s %s" % (pin, GPIO.input(pin))) if (mode == 1): GPIO.add_interrupt_callback(pin, btncall, edge='both', pull_up_down=GPIO.PUD_UP) if (mode == 2): setup() else: # regular GPIO wait for interrupts if (verbose == 2): for pin in gpios: gpiostate[pin] = getgpio(pin) showbtnstate(); if(len(mcps)>0): thread=True else: thread=False GPIO.wait_for_interrupts(threaded=thread)
BUT3 = 12 BUT4 = 13 BUT5 = 16 BUT6 = 19 #debounce delay in ms DEBOUNCE = 5 client = OSCClient() client.connect(("127.0.0.1", 57122)) def gpio_callback(gpio_id, val): print("gpio %s: %s" % (gpio_id, val)) if (val == 1): obj = OSCMessage("/b/r %s" % gpio_id) else: obj = OSCMessage("/b/p %s" % gpio_id) client.send(obj) RPIO.add_interrupt_callback(BUT1, gpio_callback, debounce_timeout_ms=DEBOUNCE) RPIO.add_interrupt_callback(BUT2, gpio_callback, debounce_timeout_ms=DEBOUNCE) RPIO.add_interrupt_callback(BUT3, gpio_callback, debounce_timeout_ms=DEBOUNCE) RPIO.add_interrupt_callback(BUT4, gpio_callback, debounce_timeout_ms=DEBOUNCE) RPIO.add_interrupt_callback(BUT5, gpio_callback, debounce_timeout_ms=DEBOUNCE) RPIO.add_interrupt_callback(BUT6, gpio_callback, debounce_timeout_ms=DEBOUNCE) RPIO.wait_for_interrupts()
def call_P4(gpio,val): print "P4-7" RPIO.del_interrupt_callback(7) RPIO.add_interrupt_callback(8,call_C4,edge='falling',pull_up_down=RPIO.PUD_UP,debounce_timeout_ms=tb)
RPIO.setmode(RPIO.BCM) """ ngpio=17 GPIO.setup(ngpio, GPIO.OUT) #конфигурируем GPIO 7 как выход GPIO.output(ngpio, True) #выводим на GPIO 7 логическую "1" (3.3 V) sleep(1) GPIO.output(ngpio, False) #выводим на GPIO 7 логический "0" sleep(2) GPIO.output(ngpio, True) #выводим на GPIO 7 логическую "1" (3.3 V) """ def gpio_callback(gpio_id, val): print("gpio %s: %s" % (gpio_id, val)) ngpio=14 RPIO.setup(ngpio, RPIO.IN, pull_up_down=RPIO.PUD_DOWN) RPIO.add_interrupt_callback(ngpio, gpio_callback, edge='rising', debounce_timeout_ms=2000, pull_up_down=RPIO.PUD_DOWN) # , threaded_callback=True) RPIO.wait_for_interrupts(threaded=True) n = 0 while True: sleep(1) n += 1 print n RPIO.cleanup()
def _enable_event_detect(self): RPIO.add_interrupt_callback(self.number, self._call_when_changed, self._edges, self.GPIO_PULL_UPS[self._pull], self._bounce)