Python wiringpi.pwmWrite函数代码示例

def main():
    #all needs to run automatically
    port0 = '/dev/ttyUSB0'
    port1 = '/dev/ttyUSB1'
    port2 = '/dev/ttyUSB2'
    ##
    th_cl1 = TestThread(port1, './original_data/data1208.csv')
    th_cl1 = TestThread(port1, './original_data/data1208.csv')

    #th_cl1.start()
    #th_cl2.start()

    f = open('./original_data/data1209.csv', 'w')
    ##
    servo_pin = 18

    param = sys.argv
    set_degree = int(param[1])
    print(set_degree)

    wiringpi.wiringPiSetupGpio()

    wiringpi.pinMode(servo_pin, 2)

    wiringpi.pwmSetMode(0)
    wiringpi.pwmSetRange(1024)
    wiringpi.pwmSetClock(375)


    while True:
        try:
            ser = serial.Serial(port0, 38400, timeout=10)  # 10s-timeout baudrate=38400
            ser.write(b'<RM,>??\r\n')  # send command (CR+LF)
            line = ser.readline()
            line = str(datetime.datetime.now()) + str(",") + line.decode('utf-8')
            line = line.split(',')

            velocity = float(line[2])
            temp = float(line[5])

            print('CPU_temperature' + '/' + line[0] + ',' + line[2] + ','
                    + line[3] + ',' + line[4] + ',' + line[5])
            f.write(line[0] + ',' + line[2] + ','
                    + line[3] + ',' + line[4] + ',' + line[5] + "\n")

            if temp >= 35.0:
#                print('too hot')
                wiringpi.pwmWrite(servo_pin, set_degree + 5)
#                LED(11, True)
            else:
#                print('oh.. cool')
#                move_deg = int (81+41/90*set_degree)

                wiringpi.pwmWrite(servo_pin, set_degree)
#                LED(11, False)

            time.sleep(5)

        except IndexError:
            pass

def on_message(aioClient, feed_id, msg):
	payload = msg.partition(MESSAGE_DELIM)
	if type(payload[2]) is '':
		print '%s, missing timestamp in payload: %s' % (feed_id, msg)
		return None
	try:
		global last_ts		
		value = float(payload[0])
		ts = float(payload[2])
		if ((feed_id == aio_switch_feedid) 
		and (ts > last_ts)  
		and (feed_id == aio_switch_feedid)  
		):
	       	  if(value == 1):
			print "%s: switch is on, turn it off" % feed_id 
			rotate_arm(175)
			time.sleep(TICK_S)
			rotate_arm(ROTATE_NEUTRAL)
			time.sleep(TICK_S)
			wiringpi.pwmWrite(PWM_PIN, 0)
			last_ts = time.time()
		  else:
			print "%s switch is off" % feed_id
			last_ts = time.time()

		elif (
		(feed_id == aio_rotate_feedid) 
		and (ts > last_ts)):
			rotate_arm(value)
			time.sleep(TICK_S)
			wiringpi.pwmWrite(PWM_PIN, 0)
			last_ts = time.time()
	except ValueError:
		print "%s: bad switch message: %s" % (feed_id, msg)

def loop(start_pwm, stop_pwm, step, printchar):
    for x in range(start_pwm, stop_pwm, step):
        wiringpi.pwmWrite(18, x)
        # if x is an exact multiple of 19, i.e. x/19 has remainder 0
        if x % (19) == 0:
            display(printchar)  # print the + or - character
        sleep(rest)

    def __init__(self, dev=(0,0),speed=4000000, brightness=256, contrast=CONTRAST):
        self.spi = spidev.SpiDev()
        self.speed = speed
        self.dev = dev
        self.spi.open(self.dev[0],self.dev[1])
        self.spi.max_speed_hz=self.speed

        # Set pin directions.
        self.dc = DC
        self.rst = RST
        wiringpi.wiringPiSetup()
        for pin in [self.dc, self.rst]:
            wiringpi.pinMode(pin, 1)

        self.contrast=contrast
        self.brightness=brightness
        
        # Toggle RST low to reset.
        wiringpi.digitalWrite(self.rst, OFF)
        time.sleep(0.100)
        wiringpi.digitalWrite(self.rst, ON)
        # Extended mode, bias, vop, basic mode, non-inverted display.
        wiringpi.digitalWrite(self.dc, OFF)
        self.spi.writebytes([0x21, 0x14, self.contrast, 0x20, 0x0c])
        # cls()

        self.ledpin = LED
        if self.ledpin == 1:
            wiringpi.pinMode(self.ledpin, 2)
            wiringpi.pwmWrite(self.ledpin, self.brightness)
        else:
            wiringpi.pinMode(self.ledpin, 1)
            wiringpi.digitalWrite(self.ledpin, ON)

 def Update(self):
     if (time.time() - self.brightStart > 5):
         backLight = 500
         if (time.localtime().tm_hour > 22 or time.localtime().tm_hour < 5):
           backLight = 1
         wiringpi.pwmWrite(18, backLight)
         pygame.mouse.set_visible(False)

def updateLights():
    global tlConfig
    STEP_INTERVAL = 1 / PWM_FREQ # how often
    STEP_BRIGHTNESS = 1 / (tlConfig.lightsFadeTime * PWM_FREQ) # how much
    
    currentBrightness = 1.00

    while not shutdownFlag:
        changed = False
        if abs(currentBrightness - targetBrightness) > STEP_BRIGHTNESS / 2:
            if currentBrightness < targetBrightness:
                currentBrightness += STEP_BRIGHTNESS
                changed = True
            elif currentBrightness > targetBrightness:
                currentBrightness -= STEP_BRIGHTNESS
                changed = True

        if changed:
            if config.get('lights', 'pwm_mode') == 'HW':
                wiringpi.pwmWrite(TL_PWM, math.trunc(1024 * (1.00 - currentBrightness)))
            elif config.get('lights', 'pwm_mode') == 'SW':
                wiringpi.softPwmWrite(TL_PWM, math.trunc(100 * (1.00 - currentBrightness)))

            rootLogger.debug("{0:.2f} <- {1} <- {2:.2f}".format(currentBrightness, lastEvent, targetBrightness))
        time.sleep(STEP_INTERVAL)

    def __init__(self):

        wiringpi.wiringPiSetupGpio()
        wiringpi.pinMode(self.PIN_PWM, wiringpi.GPIO.PWM_OUTPUT)
        wiringpi.pwmSetMode(wiringpi.GPIO.PWM_MODE_MS)
        wiringpi.pwmSetClock(375)

        wiringpi.pwmWrite(self.PIN_PWM, self.FRONT)

 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)

def shutoffRobot():
    wp.pwmWrite(PWM_L, OFF)
    wp.pwmWrite(PWM_R, OFF)
    wp.digitalWrite(INPUT_2_LEFT, OFF)
    wp.digitalWrite(INPUT_1_LEFT, OFF)
    wp.digitalWrite(INPUT_1_RIGHT, OFF)
    wp.digitalWrite(INPUT_2_RIGHT, OFF)
    print 'turn off'

def shutoffRobot():
    wp.pwmWrite(PWM_L, 0)
    wp.pwmWrite(PWM_R, 0)
    wp.digitalWrite(INPUT_2_LEFT_MOTOR, 0)
    wp.digitalWrite(INPUT_1_LEFT_MOTOR, 0)
    wp.digitalWrite(INPUT_1_RIGHT_MOTOR, 0)
    wp.digitalWrite(INPUT_2_RIGHT_MOTOR, 0)
    print 'turn off'

def function PwmControl(self,turnForward):
    if turnForward:
        for i in range(255):
            wiringpi.pwmWrite(MotorEnable,i)
            sleep(.001)
    else:
        for i in range(255,0,-1):
            wiringpi.pwmWrite(MotorEnable,i)
            sleep(.001)

	def __del__(self):
		
		wp.pwmWrite(self.pwm, PWM_MIN)
		wp.digitalWrite(self.outA, LOW)
		wp.digitalWrite(self.outB, LOW)

		wp.pinMode(self.pwm, INPUT_MODE)
		wp.pinMode(self.outA, INPUT_MODE)
		wp.pinMode(self.outB, INPUT_MODE)

def on_connect(aioClient):
	global last_ts
    	rotate_arm(ROTATE_NEUTRAL)
	time.sleep(TICK_S)
	wiringpi.pwmWrite(PWM_PIN, 0)
    	# Once connected, hook into i/o events
    	aioClient.subscribe(aio_switch_feedid)
    	aioClient.subscribe(aio_rotate_feedid)
	print 'subscribing to feeds: %s, %s' % (aio_switch_feedid, aio_rotate_feedid)
	last_ts = time.time()

	def setSpeed(self, speed):

		# Constrain 
		if speed > PWM_MAX:
			speed = PWM_MAX
		elif speed < PWM_MIN:
			speed = PWM_MIN
		wp.pwmWrite(self.pwm, speed)

		self.speed = speed

def initOS():
	os.environ['SDL_FBDEV'] = '/dev/fb1'
	os.environ['SDL_MOUSEDEV'] = '/dev/input/touchscreen'
	os.environ['SDL_MOUSEDRV'] = 'TSLIB'
	os.environ['SDL_VIDEODRIVER'] = 'fbcon'

	wiringpi.wiringPiSetupGpio()
	wiringpi.pinMode(18, 2)
	wiringpi.pwmSetMode(wiringpi.PWM_MODE_MS)  # default balanced mode makes screen dark at about 853/1024
	wiringpi.pwmWrite(18, 1024)