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)
