Python wiringpi2.pwmWrite函数代码示例

def callback(data):
	rospy.loginfo(rospy.get_caller_id() + "I heard %s", data.data)
	
	if data.data == 'a' :
		print "Left"
		wiringpi.digitalWrite(pin_dir[0], 1)
		wiringpi.digitalWrite(pin_dir[1], 0)
	elif data.data == 'w':
		print "Forward"
		wiringpi.digitalWrite(pin_dir[0], 1)
		wiringpi.digitalWrite(pin_dir[1], 1)
	elif data.data == 'd':
		print "Right"
		wiringpi.digitalWrite(pin_dir[0], 0)
		wiringpi.digitalWrite(pin_dir[1], 1)
	elif data.data == 's':
		print "Stop"
		wiringpi.digitalWrite(pin_dir[0], 0)
		wiringpi.digitalWrite(pin_dir[1], 0)

	global dt

	dt = dt + 100
	if dt > dtMax:
		dt = dtMin

	print(dt)
	wiringpi.pwmWrite(pin, dt)

def speed(left, right):
	left_a = GPIO.LOW
	left_b = GPIO.LOW
	left_pwm = abs(left)

	right_a = GPIO.LOW
	right_b = GPIO.LOW
	right_pwm =abs(right)

	if left < 0:
		left_a = GPIO.HIGH
	elif left > 0:
		left_b = GPIO.HIGH
	
	if right < 0:
		right_a = GPIO.HIGH
	elif right > 0:
		right_b = GPIO.HIGH

	if(left_pwm > 1):
		left_pwm = MAX_SPEED
	else:
		left_pwm = int(left_pwm*MAX_SPEED)
	if right_pwm > 1:
		right_pwm = MAX_SPEED
	else:
		right_pwm = int(right_pwm*MAX_SPEED)
	
	GPIO.output(LEFT_MOTOR_A, left_a)
	GPIO.output(LEFT_MOTOR_B, left_b)
	GPIO.output(RIGHT_MOTOR_A, right_a)
	GPIO.output(RIGHT_MOTOR_B, right_b)
	wiringpi.pwmWrite(LEFT_MOTOR_PWM, left_pwm)
	wiringpi.pwmWrite(RIGHT_MOTOR_PWM, right_pwm)

    def _playLoop(self, freq, music):
        divisor = (19.2*(10**3))/freq
        Music = import_module(music)

        wiringpi2.pwmSetClock(int(divisor))

        for note, beat in Music.melody:
            if note == ' ':
                wiringpi2.pwmWrite(self.SPEAKER, 0)
            else:
                period, dutyCycle = self._calcParams(note)
                wiringpi2.pwmSetRange(period)
                wiringpi2.pwmWrite(self.SPEAKER, dutyCycle)

            wiringpi2.delay(Music.tempo*beat)

            if note[len(note)-1:] == ':':
                wiringpi2.pwmWrite(self.SPEAKER, 0)
                wiringpi2.delay(Music.tempo)
            elif note[len(note)-1:] == ';':
                wiringpi2.pwmWrite(self.SPEAKER, 0)
                wiringpi2.delay(int(Music.tempo/2))

        # Make sure that music stop
        wiringpi2.pwmWrite(self.SPEAKER, 0)

    def setFanSpeed(self):
        START = 650      #  this value is minimal pwm value that can start the fan, depends on the fan and transistors used
        LO_TEMP = 45.0   #  minimal temperature that turns on the fan 
        HI_TEMP = 55.0   #  when core temperature is higher than this the fan operates at full speed
        tempDiff = HI_TEMP - LO_TEMP
        
        temp = self.readtemp()

        if self.PWMmode:                                
          if temp < LO_TEMP:
              pwm = 0
          elif temp > HI_TEMP:
              pwm = 1023
          else:        
              pwm = (1023-START)/tempDiff * temp - ((1023-START)/tempDiff)*LO_TEMP + START
              pwm = int(pwm)
          wiringpi2.pwmWrite(1, pwm)
          return pwm
        
        elif not self.PWMmode:
          if self.fanRunning:
            if temp <= LO_TEMP:
              wiringpi2.digitalWrite(1, 0)
              self.fanRunning = False
              return(0)
            else: return(1023)
          elif not self.fanRunning:
            if temp > HI_TEMP:
              wiringpi2.digitalWrite(1, 1)
              self.fanRunning = True
              return(1023)
            else: return(0)

	def __init__(self):
		Pi_rev = wiringpi2.piBoardRev()	#@TODO: use this?
		self.GPIOS = {
			'internal_buzzer': 11,
			'latch': 7,
			'unlock_LED': 15,
			'deny_LED': 13,
			'buzzer': 12, 
			'doorStatus1': 19,
			'doorStatus2': 21,
		}
		
		#set up I/O pins
		wiringpi2.wiringPiSetupPhys()
		wiringpi2.pinMode(self.GPIOS['unlock_LED'], 1)
		wiringpi2.pinMode(self.GPIOS['deny_LED'], 1)
		wiringpi2.pinMode(self.GPIOS['latch'], 1)
		wiringpi2.pinMode(self.GPIOS['internal_buzzer'], 1)
		wiringpi2.pinMode(self.GPIOS['doorStatus1'], 0)
		wiringpi2.pinMode(self.GPIOS['doorStatus2'], 0)
		
		GPIO.setup(9, GPIO.IN)  
		GPIO.setup(10, GPIO.IN)  
		#GPIO.add_event_detect(9, GPIO.FALLING, callback=self.arm_security, bouncetime=300)
		#Set up Hardware PWM - Only works on GPIO 18 (Phys 12)
		wiringpi2.pwmSetMode(0)				# set PWM to markspace mode
		wiringpi2.pinMode(self.GPIOS['buzzer'], 2)      # set pin to PWM mode
		wiringpi2.pwmSetClock(750)   			# set HW PWM clock division (frequency)
		wiringpi2.pwmWrite(self.GPIOS['buzzer'], 0)
		
		proc = subprocess.Popen(['nfc-list'], stderr=subprocess.PIPE)
		result = proc.stderr.read()
		self.PN532 = False if 'Timeout' in result else True
		if not self.PN532:
			self.nfc = NFC.MFRC522()

def setup_servo():
    wiringpi.wiringPiSetupGpio()
    wiringpi.pinMode(18,2)      # hardware pwm only works on GPIO port 18  
    wiringpi.pwmSetMode(0)
    wiringpi.pwmSetClock(375)
    wiringpi.pwmSetRange(1024)
    wiringpi.pwmWrite(18,0)

	def rotate(self, speed):
                if speed > 0:
                        wiringpi.pwmWrite(1self.in3, speed)
                        GPIO.output(self.in1,GPIO.HIGH)
                        GPIO.output(self.in2,GPIO.LOW)
                elif speed = 0:
                        wiringpi.pwmWrite(1self.in3, speed)
                        GPIO.output(self.in1,GPIO.LOW)
                        GPIO.output(self.in2,GPIO.LOW)

 def __init__(self, external_lights):
     super(Lights, self).__init__()
     self.external_lights = external_lights
     # hardware PWM led (and power off lights)
     wiringpi2.pinMode(self.LIGHTS_PIN, wiringpi2.GPIO.PWM_OUTPUT)
     wiringpi2.pwmWrite(self.LIGHTS_PIN, self.PWM_VAL_MAX)
     if self.external_lights:
         wiringpi2.pinMode(self.EXTERNAL_LIGHTS_PIN, wiringpi2.GPIO.OUTPUT)
         wiringpi2.digitalWrite(self.EXTERNAL_LIGHTS_PIN, 1)

    def __init__(self, freq = 100.0):
        self.freq = freq
        output_pins.append(12)
        wp.pinMode(12, PWM)
        wp.pwmSetRange(4000) #range can go up to 4096, 4000 is good because it's large and a multiple of 100
        clock = 19.2e6 / (4000.0 * freq) #set the divisor so the frequency comes out right
        wp.pwmSetClock(int(clock)) #this function needs an int
	wp.pwmSetMode(0) # necessary or else it's in a weird mode where nothing works
	wp.pwmWrite(12, 0) # stop for safety

def set_brightness(led_value):
    if  LED == 1:
        if (0 <= led_value < 1023):
            wiringpi.pwmWrite(LED,led_value)
    else:
        if led_value == 0:
            wiringpi.digitalWrite(LED, OFF)
        else:
            wiringpi.digitalWrite(LED, ON)

    def __init__(self):
        wiringpi2.wiringPiSetupGpio()

        self.SPEAKER = 18
        self.MODE_PWM = 2

        wiringpi2.pinMode(self.SPEAKER, self.MODE_PWM)
        wiringpi2.pwmSetMode(wiringpi2.GPIO.PWM_MODE_MS)

        wiringpi2.pwmWrite(self.SPEAKER, 0)

 def __init__(self, base0 = 27, base90 = 73):
     wiringpi.wiringPiSetupGpio()
     wiringpi.pinMode(18,2)
     wiringpi.pwmSetMode(0)
     wiringpi.pwmSetClock(400)
     wiringpi.pwmSetRange(1024)
     wiringpi.pwmWrite(18, 0)
     self.base0 = base0
     self.base90 = base90
     self.setAngle(90)

	def setBuzzerOn(self, buzzerOn):
		'''
		Set buzzer state

		Args:
		  buzzerOn (bool): True to turn on buzzer, False to turn off
		'''
		if buzzerOn:
			wiringpi2.pwmWrite(self.GPIOS['buzzer'], 100)
		else:
			wiringpi2.pwmWrite(self.GPIOS['buzzer'], 0)

    def set(self, speed):
        if speed > 1.0:
            speed = 1.0
        if speed < -1.0:
            speed = -1.0
        # this results in speeds from 500 (fastest allowed forward)
        # to 700 (fastest allowed reverse)
        # the theoretical maxima are 400 forward and 800 reverse
        duty_cycle = 600 - (100 * speed)
	wp.pwmWrite(12, int(duty_cycle)) # this also wants an int
        return duty_cycle    

    def set_value(self, target, dt):
        # limit the target value to the range -1 .. 1
        if target > 1:
            target = 1
        if target < -1:
            target = -1
        
        # set direction
        if target > 0:
            # forward_value
            backward_value = wiringpi2.GPIO.LOW
            forward_value = wiringpi2.GPIO.HIGH
        elif target < 0:
            # backward_value
            backward_value = wiringpi2.GPIO.HIGH
            forward_value = wiringpi2.GPIO.LOW
        else:
            backward_value = wiringpi2.GPIO.LOW
            forward_value = wiringpi2.GPIO.LOW

        if self.backward_value != backward_value:
            wiringpi2.digitalWrite(self.backward_port, backward_value)
        if self.forward_value != forward_value:
            wiringpi2.digitalWrite(self.forward_port, forward_value)
        self.backward_value = backward_value
        self.forward_value = forward_value

        # set power
        if target < 0:
            target = -target
        
        # find interpolation range
        for idx, val in enumerate(self.mapping_u):
            print idx, val
            if val > target*100.0:
                # found
                break
        if idx <= 0:
            idx = 1
        if idx > len(self.mapping_u):
            idx = len(self.mapping_u)
        # interpolate
        u1 = float(self.mapping_u[idx - 1])
        u2 = float(self.mapping_u[idx])
        p1 = float(self.mapping_pwm[idx - 1])
        p2 = float(self.mapping_pwm[idx])
        power_percent = p1 + (target * 100.0 - u1) * (p2 - p1) / (u2 - u1)
        self.logger.debug("{}: target={} idx={} u1={:5.2f} u2={:1f} p1={:1f} p2={:4f}".format(self.name, idx, target, u1, u2, p1, p2))
        
        # scale to pwm_range
        power = int(self.pwm_range * power_percent / 100)
        wiringpi2.pwmWrite(self.pwm_port, power)

        self.logger.debug("{}: target={:5.3f} backward_value={:1d} forward_value={:1d} power={:2.0f} %={:4d}/{:4d}".format(self.name, target, backward_value, forward_value, power_percent, power, self.pwm_range))