def getKey(self): for j in range(len(self.COLUMN)): RPIO.setup(self.COLUMN[j], RPIO.OUT) RPIO.output(self.COLUMN[j], RPIO.LOW) RPIO.setup(self.ROW, RPIO.IN, pull_up_down=RPIO.PUD_UP) rowVal = -1 tmpRead = RPIO.input(self.ROW) if tmpRead == 0: rowVal = i if rowVal < 0 or rowVal > 3: self.exit() return for j in range(len(self.COLUMN)): RPIO.setup(self.COLUMN[j], RPIO.IN, pull_up_down=RPIO.PUD_DOWN) RPIO.setup(self.ROW, RPIO.OUT) RPIO.output(self.ROW, RPIO.HIGH) colVal = -1 for j in range(len(self.COLUMN)): tmpRead = RPIO.input(self.COLUMN[j]) if tmpRead == 1: colVal=j if colVal < 0 or colVal > 3: self.exit() return self.exit() return self.KEYPAD[colVal]
def read_gpio(self, dt): self.ready_timer -= dt if int(self.ready_timer) > 0: return self.win_text = '' p1 = RPIO.input(PIN_P1) p2 = RPIO.input(PIN_P2) if p1 and self.p1_state == 0: self.p1_state = 1 self.p1 += 1 elif not p1 and self.p1_state == 1: self.p1_state = 0 if p2 and self.p2_state == 0: self.p2_state = 1 self.p2 += 1 elif not p2 and self.p2_state == 1: self.p2_state = 0 if self.p1 >= self.score: self.win_text = 'Player 1 win !' self.ready_timer = 5. self.p1 = self.p2 = 0 elif self.p2 >= self.score: self.win_text = 'Player 2 win !' self.ready_timer = 5. self.p1 = self.p2 = 0
def getKey(self): for j in range(len(self.COLUMN)): RPIO.setup(self.COLUMN[j], RPIO.OUT) RPIO.output(self.COLUMN[j], RPIO.LOW) RPIO.setup(self.ROW, RPIO.IN, pull_up_down=RPIO.PUD_UP) rowVal = -1 tmpRead = RPIO.input(self.ROW) if tmpRead == 0: rowVal = i if rowVal < 0 or rowVal > 3: self.exit() return for j in range(len(self.COLUMN)): RPIO.setup(self.COLUMN[j], RPIO.IN, pull_up_down=RPIO.PUD_DOWN) RPIO.setup(self.ROW, RPIO.OUT) RPIO.output(self.ROW, RPIO.HIGH) colVal = -1 for j in range(len(self.COLUMN)): tmpRead = RPIO.input(self.COLUMN[j]) if tmpRead == 1: colVal = j if colVal < 0 or colVal > 3: self.exit() return self.exit() return self.KEYPAD[colVal]
def measure(): """Get a measurement.""" # Set trigger to False (Low) RPIO.output(_RPIO_TRIGGER, False) # Allow module to settle time.sleep(0.5) # Send 10us pulse to trigger RPIO.output(_RPIO_TRIGGER, True) time.sleep(0.00001) RPIO.output(_RPIO_TRIGGER, False) start = time.time() while RPIO.input(_RPIO_ECHO)==0: start = time.time() while RPIO.input(_RPIO_ECHO)==1: stop = time.time() # Calculate pulse length elapsed = stop-start # Distance pulse travelled in that time is time # multiplied by the speed of sound (cm/s) # That was the distance there and back so halve the value distance = (elapsed * 34300) / 2 return distance
def reading(): # found that the sensor can crash if there isn't a delay here # no idea why. If you have odd crashing issues, increase delay time.sleep(START_DELAY) RPIO.output(TRIG, True) time.sleep(PING_DELAY) RPIO.output(TRIG, False) before_signal = None after_signal = None while not RPIO.input(ECHO): before_signal = time.time() while RPIO.input(ECHO): after_signal = time.time() if not before_signal or not after_signal: return None time_passed = after_signal - before_signal distance = time_passed * SOUND_SPEED_Q return distance
def test3_input(self): logging.info(" ") logging.info(" ") logging.info("=== INPUT TESTS ===") with self.assertRaises(RPIO._GPIO.InvalidChannelException): RPIO.setup(5, RPIO.IN) with self.assertRaises(RPIO._GPIO.InvalidChannelException): RPIO.setup(0, RPIO.IN) with self.assertRaises(RPIO._GPIO.InvalidChannelException): RPIO.setup(32, RPIO.IN) RPIO.setup(GPIO_IN, RPIO.IN) logging.info(" ") logging.info("--------------------------------------") logging.info("Input from GPIO-%s w/ PULLOFF: %s", \ GPIO_IN, RPIO.input(GPIO_IN)) RPIO.set_pullupdn(GPIO_IN, RPIO.PUD_UP) logging.info("Input from GPIO-%s w/ PULLUP: %s", \ GPIO_IN, RPIO.input(GPIO_IN)) RPIO.set_pullupdn(GPIO_IN, RPIO.PUD_DOWN) logging.info("Input from GPIO-%s w/ PULLDOWN: %s", \ GPIO_IN, RPIO.input(GPIO_IN)) logging.info("--------------------------------------") logging.info(" ") RPIO.set_pullupdn(GPIO_IN, RPIO.PUD_OFF)
def front_reject(): """ Reject routine that diverts the paper path so that the ballot comes out front in accordance with the STAR-Vote specifications. """ # Move the servo divert_servo() time.sleep(0.015) # Rotate the motor t0 = int(round(time.time() * 1000)) t = t0 while (t - t0 < fullFeed): # read digital input from either of the sensors t = int(round(time.time() * 1000)) opt1 = RPIO.input(OptInt1) opt2 = RPIO.input(OptInt2) if (opt1 or opt2): # if paper is still on the way, keep running the loop t0 = int(round(time.time() * 1000)) RPIO.output(MotorOut, True) # fully fed -> stop the motor RPIO.output(MotorOut, False) time.sleep(1.5) # sleep to ignore spurious input # straighten servo before jumping into main loop again straighten_servo()
def accept_ballot(): """ Accept routine that runs the motor until the paper is completely put into the box """ # move servo straighten_servo() time.sleep(0.015) # run motor for fullFeed seconds t0 = int(round(time.time() * 1000)) t = t0 while (t - t0 < fullFeed): # read digital input from either of the sensors t = int(round(time.time() * 1000)) opt1 = RPIO.input(OptInt1) opt2 = RPIO.input(OptInt2) if (opt1 or opt2): # if paper is still on the way, keep running the loop t0 = int(round(time.time() * 1000)) RPIO.output(MotorOut, True) # fully fed -> stop the motor RPIO.output(MotorOut, False) time.sleep(2) # sleep to ignore spurious input
def reset_state(self): """ Determines the proper state when the motor is stopped""" if GPIO.input(inputs['upper']): self.state = OPEN elif GPIO.input(inputs['lower']): self.state = CLOSED else: self.state = STOPPED
def check_distance(self): RPIO.output(TRIG, 1) time.sleep(0.00001) RPIO.output(TRIG, 0) while RPIO.input(ECHO) == 0: start = time.time() while RPIO.input(ECHO) == 1: stop = time.time() # Print distance to object in santimeters. Sound speed = 340 m/s return (stop - start) * 17000
def on_collision(self, gpio_id, value): """""" result = value if gpio_id == self.SW1_PIN and RPIO.input(self.SW2_PIN): result +=2 elif gpio_id == self.SW2_PIN: result *= 2 if RPIO.input(self.SW1_PIN): result +=1 self.send(encode(common.ID_BUMPER, result))
def main(): RPIO.setup(6, RPIO.IN) RPIO.setup(13, RPIO.IN) RPIO.setup(26, RPIO.IN) while True: if RPIO.input(6): ResetPins() if RPIO.input(13): QuickPins() if RPIO.input(26): break
def receiveBit(pin): GPIO.setup(pin, GPIO.IN); assert GPIO.input(pin) == False, "Sensor did not pull line low before bit transmission"; time.sleep(0.000077); if GPIO.input(pin): time.sleep(0.000041); return "1"; else: return "0";
def selftest(): RPIO.output(outPin, False) r1 = RPIO.input(inPin) RPIO.output(outPin, True) r2 = RPIO.input(inPin) if r1 != False or r2 != True: raise Exception("Selftest failed. Readout should have been (False, True), but was (", r1, ", ", r2, ").") else: print("Selftest ok.")
def __init__(self,pinC): self.c = pinC #write pin print encoders.a,encoders.b RPIO.setup(encoders.a, RPIO.IN, pull_up_down=RPIO.PUD_DOWN) RPIO.setup(encoders.b, RPIO.IN, pull_up_down=RPIO.PUD_DOWN) self.S1 = RPIO.input(encoders.a) self.S2 = RPIO.input(encoders.b) self.state = self.S1 + 2*self.S2 self.start_time = time.clock() self.steps_for_speed = 0 self.distance = 0 encoders.connected_encoders.append(self)
def is_button_up(self): """Return True when the box button has transitioned from down to up (i.e. the button was pressed).""" old_state = self.button_state self.button_state = RPIO.input(config.BUTTON_PIN) # Check if transition from down to up if old_state == config.BUTTON_DOWN and self.button_state == config.BUTTON_UP: # Wait 20 milliseconds and measure again to debounce switch. time.sleep(20.0 / 1000.0) self.button_state = RPIO.input(config.BUTTON_PIN) if self.button_state == config.BUTTON_UP: return True return False
def selftest(): RPIO.output(outPin, False) r1 = RPIO.input(inPin) RPIO.output(outPin, True) r2 = RPIO.input(inPin) if r1 != False or r2 != True: msg = "Selftest failed. Readout should have been (False, True), but was (", r1, ", ", r2, ")." logging.error(msg) raise Exception(msg) else: logging.info("Selftest ok.")
def init(pin): GPIO.setup(pin, GPIO.OUT); GPIO.output(pin, GPIO.LOW); time.sleep(0.002); GPIO.output(pin, GPIO.HIGH); time.sleep(0.000030); GPIO.setup(pin, GPIO.IN); time.sleep(0.000020); assert GPIO.input(pin) == True, "Sensor did not pull line low after host start signal"; time.sleep(0.000080); assert GPIO.input(pin) == False, "Sensor did not pull line high after host start signal"; time.sleep(0.000060); return;
def is_button_up(self): """Return True when the box button has transitioned from down to up (i.e. the button was pressed).""" old_state = self.button_state self.button_state = RPIO.input(config.BUTTON_PIN) # Check if transition from down to up if old_state == config.BUTTON_DOWN and self.button_state == config.BUTTON_UP: # Wait 20 milliseconds and measure again to debounce switch. time.sleep(20.0/1000.0) self.button_state = RPIO.input(config.BUTTON_PIN) if self.button_state == config.BUTTON_UP: return True return False
def read_gpio(self, dt): p1 = RPIO.input(PIN_P1) p2 = RPIO.input(PIN_P2) self.player1.update(dt, p1) self.player2.update(dt, p2) for bonus in self.bonus[:]: for player in self.players: if bonus.collide_player(player): bonus.use(player) self.bonus.remove(bonus) self.remove_widget(bonus) break
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 measure_distance(self): """Returns the distance (in meters) to the object being looked at. Probably should only happen in a thread due to all the sleeping """ if not self._rangefinder_settled: # let the sensor settle GPIO.output(self._gpios['echo_trigger'], False) time.sleep(2) self._rangefinder_settled = True # 10 us pulse GPIO.output(self._gpios['echo_trigger'], True) time.sleep(0.00001) GPIO.output(self._gpios['echo_trigger'], False) # interrupt might be better? pulse_start = time.time() cnt = 0 while not GPIO.input(self._gpios['echo']): pulse_start = time.time() # maybe pass would be better? might actually more cpu though... cnt += 1 if cnt > 20000: return 999999999 # we got a pulse, measure it's width by polling until it goes low # again. cnt = 0 pulse_end = time.time() while GPIO.input(self._gpios['echo']): pulse_end = time.time() cnt += 1 if cnt > 20000: return 999999999 pulse_duration = pulse_end - pulse_start sound_mps = 343.0 # speed of sound: 343 m/s distance = sound_mps * pulse_duration # and the pulse width is actually the time it takes to get to the # object *and back*, so we need to divide by two to get just the # distance: distance /= 2.0 # Because the datasheet says: # # we suggest to use over 60ms measurement cycle, in order to # prevent trigger signal to the echo signal. # # We'll use 80ms to be safe time.sleep(.08) return distance
def fn(pin, *args, **kwargs): dbg("ifhigh %s "% (pin)) if GPIO.input(pin): dbg("pin %s high, calling callback" %pin) return cb(pin, *args, **kwargs) dbg("pin %s low, not calling" %pin) self.notify_enrolled(self.status())
def get_noise(self): self.cnt += 1 self.noise = RPIO.input(self.PIN) print(self.noise, "noise dal sensore") if self.noise == False: self.cnt = 0 return self.noise
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 __init__(self): # Initialize lock servo and button. self.servo = PWM.Servo() RPIO.setup(config.BUTTON_PIN, RPIO.IN) # Set initial box state. self.button_state = RPIO.input(config.BUTTON_PIN) self.is_locked = None
def run(self): """ This is where the work happens. """ time_base = time.time() self.keep_running = True while self.keep_running: time.sleep(self.time_pause) time_now = time.time() if self.time_interval <= 0: # Off. RPIO.output(self.pin, False) elif time_now - time_base > self.time_interval: time_base = time_now # Reverse LED state. value = RPIO.input(self.pin) RPIO.output(self.pin, not value) # Repeat loop. print('Blinker exit: %d' % self.pin) RPIO.output(self.pin, False)
def gpio_callback_1(gpio_id, val): # global lastTime1, dMax1, dMin1, dSum1, dCount1, dFirst1 # now1 = datetime.datetime.now() # dstr1 = str(now1.strftime("%H:%M:%S.%f")) # nowTime1 = time.time() # if (dFirst1 == 1): # dFirst1 = 0; # lastTime1 = nowTime1; # else: # dTime1 = nowTime1 - lastTime1 # lastTime1 = nowTime1 # if (dTime1 > dMax1): # dMax1 = dTime1 # if (dTime1 < dMin1): # dMin1 = dTime1 # dCount1 += 1 # dSum1 += dTime1 #stampa ogni tic in uscita da (3) su 555 input_value_7 = RPIO.input(INTfirst) if input_value_7 == True: print "ALTO--->1" RPIO.output(LedColored, True) else: print "BASSO--->0" RPIO.output(LedColored, False) print( "INTfotores: ---------------> GPIO" ), gpio_id #: %s at %s delta: %08.6f" % (gpio_id, val, dstr1, dTime1))
def pulse_tdo(tck, tdo): if(DELAY): sleep(0.000005) RPIO.output(tck, 0) tdo_read = RPIO.input(tdo) RPIO.output(tck, 1) return tdo_read
def input_loop(): """ The main loop for checking the optical interrupters and controlling motors """ # read in the values while (True): opt1 = RPIO.input(OptInt1) opt2 = RPIO.input(OptInt2) exp = RPIO.input(ExpButton) if (opt1 or opt2): if (exp): front_reject() else: accept_ballot()
def gpio_callback_1(gpio_id, val): # global lastTime1, dMax1, dMin1, dSum1, dCount1, dFirst1 # now1 = datetime.datetime.now() # dstr1 = str(now1.strftime("%H:%M:%S.%f")) # nowTime1 = time.time() # if (dFirst1 == 1): # dFirst1 = 0; # lastTime1 = nowTime1; # else: # dTime1 = nowTime1 - lastTime1 # lastTime1 = nowTime1 # if (dTime1 > dMax1): # dMax1 = dTime1 # if (dTime1 < dMin1): # dMin1 = dTime1 # dCount1 += 1 # dSum1 += dTime1 #stampa ogni tic in uscita da (3) su 555 input_value_7 = RPIO.input(INTfirst) if input_value_7==True: print "ALTO--->1" RPIO.output(LedColored,True) else: print "BASSO--->0" RPIO.output(LedColored,False) print("INTfotores: ---------------> GPIO"), gpio_id#: %s at %s delta: %08.6f" % (gpio_id, val, dstr1, dTime1))
def readadc(adcnum, clockpin, mosipin, misopin, cspin): if ((adcnum > 7) or (adcnum < 0)): return -1 RPIO.output(cspin, True) RPIO.output(clockpin, False) # start clock low RPIO.output(cspin, False) # bring CS low commandout = adcnum commandout |= 0x18 # start bit + single-ended bit commandout <<= 3 # we only need to send 5 bits here for i in range(5): if (commandout & 0x80): RPIO.output(mosipin, True) else: RPIO.output(mosipin, False) commandout <<= 1 RPIO.output(clockpin, True) RPIO.output(clockpin, False) adcout = 0 # read in one empty bit, one null bit, and 10 ADC bits for i in range(12): RPIO.output(clockpin, True) RPIO.output(clockpin, False) adcout <<= 1 if (RPIO.input(misopin)): adcout |= 0x1 RPIO.output(cspin, True) adcout >>= 1 # first bit is 'null' and gets dropped return adcout
def collision(): global distance time.sleep(0.055) RPIO.output(7, True) time.sleep(0.0001) RPIO.output(7, False) start = time.time() while not RPIO.input(8): start = time.time() while RPIO.input(8): stop = time.time() distance = ((stop - start) * 34000) / 2 if distance >= 16: return False else: return True
def on_q7_both(gpio_id, value): # we get called here for both rise & fall # so figure out if we're falling and if so dish it off if (RPIO.input(gpio_id) == 0): # we're falling so call falling method on_q7_falling(gpio_id, value) else: on_q7_rising(gpio_id, value)
def charge_time(): GPIO.setup(b_pin, GPIO.IN) GPIO.setup(a_pin, GPIO.OUT) count = 0 GPIO.output(a_pin, True) while not GPIO.input(b_pin): count = count + 1 return count
def on_q7_rising(self, gpio_id, value): # we could get called after we're done counting, so ignore that data if (self.ctrRising < 1000): # we need to scan for the led data for e in self.indx: self.dataq7[e] = self.dataq7[e] + RPIO.input(e) if (e == 23): self.dataq7[e] = 0
def RCtime (RCpin): reading = 0 RPIO.setup(RCpin, RPIO.OUT) RPIO.output(RCpin, RPIO.LOW) time.sleep(0.1) RPIO.setup(RCpin, RPIO.IN) while (RPIO.input(RCpin) == RPIO.LOW): reading += 1 return reading
def get_range(self): mean = 10 distance = 0 for i in range(mean): RPIO.setup(self.TRIGGER_PIN, RPIO.OUT) RPIO.output(self.TRIGGER_PIN, True) time.sleep(0.0001) RPIO.output(self.TRIGGER_PIN, False) RPIO.setup(self.TRIGGER_PIN, RPIO.IN) timeout = 10000 while RPIO.input(self.TRIGGER_PIN) != True and timeout > 0: timeout = timeout - 1 start = time.time() timeout = 10000 while RPIO.input(self.TRIGGER_PIN) != False and timeout > 0: timeout = timeout - 1 pulse_len = time.time() - start distance += pulse_len / 0.000058 return distance/mean
def update(self): #correponding C pin to output #corresponding C pin to HIGH RPIO.setup(self.c, RPIO.OUT) RPIO.output(self.c, True) time.sleep(0.005) self.newS1 = RPIO.input(encoders.a) self.newS2 = RPIO.input(encoders.b) RPIO.setup(self.c, RPIO.IN) #after reading, go back to high impedance, should check if this is pull-down or at least floating self.new_state = self.newS1 + 2*self.newS2 self.rotation = self.fsm(self.state,self.new_state) #checks if the state is different from before self.distance+=self.rotation if time.clock()-encoder.DEL_TIME>self.start_time: self.speed = self.steps_for_speed/encoder.DEL_TIME self.steps_for_speed = 0 self.start_time = time.clock() else: self.steps_for_speed += self.rotation
def track_sensors(channels): activated = [] for channel in channels: old_time = datetime.now().microsecond GPIO.setup(channel, GPIO.IN) while GPIO.input(channel) == GPIO.HIGH: datetime.delay(0.001) new_time = datetime.now().microsecond elapsed = new_time - old_time if elapsed < upper_time and elapsed > lower_time: activated.append(channel) return activated
def encoderHandler_callback(self, port_channel, newChannelAValue): # handler routine of LOW to HIGH transition on channel A #global encoderCounter #global lastEncoded # read input from channel A newChannelAValue = RPIO.input(self.port_channelA) # read input from channel B newChannelBValue = RPIO.input(self.port_channelB) encoded = (newChannelAValue << 1) | newChannelBValue sumEncoded = (self.lastEncoded << 2) | encoded if sumEncoded == 0b1101 or sumEncoded == 0b0100 or sumEncoded == 0b0010 or sumEncoded == 0b1011: self.encoderCounter += 1 # increment the counter value of the encoder if sumEncoded == 0b1110 or sumEncoded == 0b0111 or sumEncoded == 0b0001 or sumEncoded == 0b1000: self.encoderCounter -= 1 # decrement the counter value of the encoder self.lastEncoded = encoded return True
def __gpio_callback(self, gpio_id, val): a = RPIO.input(self.channel_a) b = RPIO.input(self.channel_b) current = (a << 1) + b val = ((self.last_val << 2) + current) & 0b1111 delta = RotaryEncoder.lut[val] if delta: s_time = time.time() if not self.last: self.last = s_time self.step(delta) elif (s_time - self.last) * 1000 > self.debounce: # print "\nA: %d B: %d\tState: %s\t%s\tDelta: %d\t%5f" % ( # a, b, "{0:b}".format(val), val, delta, (s_time - self.last) * 1000) self.last = s_time self.step(delta) self.last_val = current
def json_data(self): ret = {'version': PIO_VERSION} j = [] for i in range(0, len(RELAYS)): j.append(1) if GPIO.input(RELAYS[i]): j[i] = 0 else: j[i] = 1 if len(RELAYS): ret['relays'] = j ret['pwm'] = channels self.request.send(json.dumps(ret) + "\n")
def medir(self): #disparar GPIO.output(self.TRIG_PIN, 1) time.sleep(0.00001) GPIO.output(self.TRIG_PIN, 0) #medir el tiempo pulse_start = time.time() while GPIO.input(self.ECHO_PIN) == 1: pulse_end = time.time() #duracion pulse_duration = pulse_end - pulse_start distance = round(pulse_duration * 17150, 2) return distance
def _wscb_sample(self, port, message): """ Request a single sample :param channel: The websocket channel containing the port to sample (io0-3) :type channel: str :param message: The message received over the wire :type message: dict -- should be empty """ port = port.split('.')[2] logging.debug("sample request in port %s" % port) boolval = RPIO.input(self.PORTS[port]['bcm']) self.send_event(port + ".sample", { 'value' : boolval, 'raw_value': int(boolval) } )
def run(self): CloudLog.log(self._component, "Running.") while self.state == "READY": try: previous_doorOpen = self._doorOpen import RPIO RPIO.setup(23, RPIO.IN, pull_up_down=RPIO.PUD_UP) self._doorOpen = RPIO.input(23) if previous_doorOpen != self._doorOpen: if self._doorOpen is True: self._announce("OPEN") else: self._announce("CLOSED") interval = 0.2 except Exception, e: CloudLog.error(self._component, "Error in run loop", e) if interval < 10: interval += interval time.sleep(interval)
def getgpio(pin): if (str(pin) in callbacks): return False if (pin < 32 and pin in goodgpios): if (pin not in gpiostate): GPIO.setup(pin, GPIO.IN, pull_up_down=GPIO.PUD_UP) try: state = GPIO.input(pin) except Exception as e: state = gpiostate[pin] elif (pin >= 32): mcpi = int(pin / 32) - 1 pin = pin % 16 if(mcpi in mcps and type(mcps[mcpi][3]).__name__=="MCP23017" and mcps[mcpi][3].connected == 1): state = mcps[mcpi][3].input(pin) else: return -1 else: return -1 gpiostate[pin] = state return state
def _runLoop(self, params): CloudLog.log(self._component, "Running.") while self.running: try: previous_doorOpen = self._doorOpen import RPIO RPIO.setup(23, RPIO.IN, pull_up_down=RPIO.PUD_UP) self._doorOpen = RPIO.input(23) if previous_doorOpen != self._doorOpen: if self._doorOpen is True: self.state = "OPEN" if self._controller.state == "AWAY": self._controller.executeCommandByName("HOME") else: self.state = "CLOSED" CloudLog.track("FRONT_DOOR", self.state) # self._component.status(key="door", value=self.state) interval = 0.5 except Exception, e: CloudLog.error(self._component, "Error in run loop", e) if interval < 10: interval += interval time.sleep(interval)
def get(self): return RPIO.input(self.pin)
dFirst1 = 1 dMax2 = 0 dMin2 = 2 dSum2 = 0 dCount2 = 0 dAvg2 = 0 dFirst2 = 1 # set up input channel with pull-up control. Can be # PUD_UP, PUD_DOWN or PUD_OFF (default) RPIO.setup(INT11, RPIO.IN, pull_up_down=RPIO.PUD_UP) RPIO.setup(INT9, RPIO.IN, pull_up_down=RPIO.PUD_UP) # read input from gpio input_value_11 = RPIO.input(INT11) input_value_4 = RPIO.input(INT9) #Definizione della callback per impulsi in uscita da pin 3 su 555 (collegato a GPIO 11) def gpio_callback_1(gpio_id, val): global lastTime1, dMax1, dMin1, dSum1, dCount1, dFirst1 now1 = datetime.datetime.now() dstr1 = str(now1.strftime("%H:%M:%S.%f")) nowTime1 = time.time() if (dFirst1 == 1): dFirst1 = 0 lastTime1 = nowTime1 else: dTime1 = nowTime1 - lastTime1 lastTime1 = nowTime1