Python wiringpi.digitalWrite函数代码示例

 def lock(self):
     """
     Lock the lock back. Meant to be used when program is shut down
     so that lock is not left disengaged.
     """
     import wiringpi
     wiringpi.digitalWrite(self.lockPin, 0)

    def display(self):
#	if self.Pos < 0 | self.Pos > 5:
#	    return
	wiringpi.digitalWrite(22, 0)
	wiringpi.shiftOut(10, 9, 1, DIGIT_VALUES.get(str(self.Value).upper()))
	wiringpi.shiftOut(10, 9, 1, self.Pos)
	wiringpi.digitalWrite(22, 1)

  def __init__(self, pinNumber):

    self.pinNumber = pinNumber

    WiringPiSingleton().setup()

    wiringpi.digitalWrite(self.pinNumber, 0)

def display_char(char, font=FONT):
  try:
    wiringpi.digitalWrite(DC, ON)
    spi.writebytes(font[char]+[0])

  except KeyError:
    pass # Ignore undefined characters.

 def unlock(self):
     """Unlocks lock at configured pin by pulling it high.
     """
     import wiringpi
     wiringpi.digitalWrite(self.lockPin, 1)
     time.sleep(self.lockOpenedSecs)
     wiringpi.digitalWrite(self.lockPin, 0)

	def commandGpio(self, c):
		if c == 'w':
			if not self.isRun: 
				# Wakeup, if not run
				print 'Wakeup'
				self.isRun = True
				self.wakeup()
		elif not self.isRun:
			# nothing to do, if not run
			return
		elif c == 'q':
			# Qiut
			print 'Qiut'
			self.isRun = False
			self.quit()
		elif c == '0':
			# LED off
			print 'LED off'
			self.stopBlink()
			wiringpi.digitalWrite(self.pinLed, wiringpi.LOW) 
		elif c == '1':			
			# LED on
			print 'LED on'
			self.stopBlink()
			wiringpi.digitalWrite(self.pinLed, wiringpi.HIGH) 
		elif c == '2':
			# LED blink
			print 'LED blink'
			self.startBlink()

    def _switch(self, switch):
        self.bit = [142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 136, 128, 0, 0, 0]

        for t in range(5):
            if self.system_code[t]:
                self.bit[t] = 136
        x = 1
        for i in range(1, 6):
            if self.unit_code & x > 0:
                self.bit[4 + i] = 136
            x = x << 1

        if switch == wiringpi.HIGH:
            self.bit[10] = 136
            self.bit[11] = 142

        bangs = []
        for y in range(16):
            x = 128
            for i in range(1, 9):
                b = (self.bit[y] & x > 0) and wiringpi.HIGH or wiringpi.LOW
                bangs.append(b)
                x = x >> 1

        wiringpi.wiringPiSetupSys()
        wiringpi.pinMode(self.pin, wiringpi.OUTPUT)
        wiringpi.digitalWrite(self.pin, wiringpi.LOW)
        for z in range(self.repeat):
            for b in bangs:
                wiringpi.digitalWrite(self.pin, b)
                time.sleep(self.pulselength / 1000000.0)

	def scanQ(self):
		# steps (1) and (2) before reading GPIOs
		self.__preRead()
		
		# (3) scan rows for pushed key/button
		rowHi=1
		while rowHi==1:
			for i in range(len(self.row)):
				tmpRead=wiringpi.digitalRead(self.row[i])
				if tmpRead==0:
					rowHi=0
					rowVal=i

		# (4) after finding which key/button from the row scans, convert columns to input
		for j in range(len(self.col)):
				wiringpi.pinMode(self.col[j],INPUT)

		# (5) switch the i-th row found from scan to output
		wiringpi.pinMode(self.row[rowVal],OUTPUT)
		wiringpi.digitalWrite(self.row[rowVal],HIGH)

		# (6) scan columns for still-pushed key/button
		colLo=0
		while colLo==0:
				for j in range(len(self.col)):
						tmpRead=wiringpi.digitalRead(self.col[j])
						if tmpRead==1:
							colLo=1
							colVal=j

		# reinitialize used GPIOs
		self.__postRead()

		# (7) return the symbol of pressed key from keyPad mapping
		return self.keyPad[rowVal][colVal]

def flash_LED(count=5, ontime=100, offtime=200):
	"""Flash the LED count times, one for ontime ms, off for offtime ms"""
	for i in xrange(count):
		wiringpi.digitalWrite(LED_PIN, 1)
		time.sleep(ontime/1000.)
		wiringpi.digitalWrite(LED_PIN, 0)
		time.sleep(offtime/1000.)

    def updateValue(self):
	if Globals.globSimulate:
	    val = (self.values[-1][1] if len(self.values) > 0 else 0) + random.randint(-10, 10)
	else:
	    # Send 10us pulse to trigger
	    wiringpi.digitalWrite(self.pinTrigger, 1)
	    time.sleep(0.00001)
	    wiringpi.digitalWrite(self.pinTrigger, 0)
	    start = time.time()
	    stop = 0

	    while wiringpi.digitalRead(self.pinEcho)==0:
	      start = time.time()

	    while wiringpi.digitalRead(self.pinEcho)==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)
	    distance = elapsed * 34300

	    # That was the distance there and back so halve the value
	    val = distance / 2


	if val < 0:
	    val = 0

	currtime = int(time.time() * 1000) # this is milliseconds so JavaScript doesn't have to do this
	self.values.append([currtime, val])
	self.values = self.values[-MAXVALUES:]
	self.emit("DistanceSensor", self)

	def set_state(self, state):

		self._On = state
		_state = 0
		if state:
			_state = 1
				
		if self.verbose:
			print str(self.ssr.name) + " digitalWrite: " + str(self.ssr.pin) + " " + str(_state)
		
		#save the state
		if self.ssr.state != _state:
			self.ssr.state = _state
			self.ssr.save()

		#reverse if needed
		if self.ssr.reverse_polarity and self.enabled:
			_state = not _state

		if wiringpi_available:
			wiringpi.digitalWrite(int(self.ssr.pin), _state)

		elif bbb_available:
			if _state:
				GPIO.output(self.ssr.pin, GPIO.HIGH)
			else:
				GPIO.output(self.ssr.pin, GPIO.LOW)

def led_drive(reps, multiple, direction):           # define function to drive
    for i in range(reps):                      # repetitions, single or multiple
        for port_num in direction:                  # and direction
            wiringpi.digitalWrite(port_num, 1)      # switch on an led
            sleep(0.11)                             # wait for ~0.11 seconds
            if not multiple:                        # if we're not leaving it on
                wiringpi.digitalWrite(port_num, 0)  # switch it off again

 def send(self, channel, button, state):
     bin_list = self.command_as_bin_list(channel, button, state)
     packet = self.encode_packet(bin_list)
     for _ in range(self.repeat):
         for bit in packet:
             wiringpi.digitalWrite(self.pin, bit)
             wiringpi.delayMicroseconds(self.PULSE_WIDTH)

def writeNo(number, latch_pin, data_pin, clock_pin):
	if number == 0:
		number = 63
	elif number == 1:
		number = 6
	elif number == 2:
		number = 91
	elif number == 3:
		number = 79
	elif number == 4:
		number = 102
	elif number == 5:
		number = 109
	elif number == 6:
		number = 125
	elif number == 7:
		number = 7
	elif number == 8:
		number = 127
	elif number == 9:
		number = 103
	elif number == 10:
		number = 0
	else:
		number = 63


	wiringpi.digitalWrite(latch_pin, 0)
	wiringpi.shiftOut(data_pin, clock_pin, MSBFIRST, number)
	wiringpi.digitalWrite(latch_pin, 1)

 def led(self, led_value):
     if self.ledpin == 1:
         wiringpi.pwmWrite(self.ledpin,led_value)
     else:
         if led_value == 0:
             wiringpi.digitalWrite(self.ledpin, OFF)
         else:
             wiringpi.digitalWrite(self.ledpin, ON)