def __init__(self, f, name="LED"): Thread.__init__(self, name=name) self.RED, self.GREEN, self.BLUE = 15,1,14 self.pw2 = PWM(0x60) #self.freq = f #self.pw2.setPWMFreq(self.freq) self.previous = led_attribute.state
def init(self): print "Initializing Balancing Robot Code" """ Calibrate the ADXL345 Accelerometer """ self.pwm = PWM(0x40, debug=True) self.pwm.setPWMFreq(200) GPIO.setmode(GPIO.BCM) GPIO.setup(18, GPIO.OUT) GPIO.setup(23, GPIO.OUT) GPIO.setup(24, GPIO.OUT) GPIO.setup(25, GPIO.OUT) self.pwm.setPWM(0, 0, 0) self.pwm.setPWM(1, 0, 0) proceed = raw_input("Is the robot level? (yes|no):") if not (proceed == "yes" or proceed == "Yes"): return calibrated_sum = 0.0 for i in range(0, 100): print "Calibration step: %d (avg=%0.2f)" % (i, calibrated_sum / (i + 1.0)) calibrated_sum = calibrated_sum + globals.ACCEL time.sleep(0.05) self.calibrated_accel = calibrated_sum / 100.0 # calibration complete print "Calibrated accelerometer value is %0.2f" % ( self.calibrated_accel)
def initialize(): # Initialise the PWM device using the default address pwm = PWM(0x40) pwm.setPWMFreq(60) # Set frequency to 60 Hz print "Hello, I'm Ruby the Rubik's Cube Robot!" print '\n' F_Open() B_Open() L_Open() R_Open() sleep(2) F_Close() B_Close() sleep(0.5) F_Default() B_Default() sleep(1) L_Close() R_Close() sleep(0.5) L_Default() R_Default() sleep(1) insert_cube()
def __init__(self, addr=0x60, freq=1600, i2c=None, i2c_bus=None): """ Initialize a Motor Hat :param addr: Motor Hat address :type addr: hex :param freq: pwm frequency :type freq: int :param i2c: the i2c device :param i2c_bus: the i2c bus to utilize """ self._frequency = freq self.motors = [AdafruitDCMotor(self, m) for m in range(4)] self.steppers = [ AdafruitStepperMotor(self, 1), AdafruitStepperMotor(self, 2) ] self._pwm = PWM(addr, debug=False, i2c=i2c, i2c_bus=i2c_bus) self._pwm.setPWMFreq(self._frequency)
def __init__(self, index=None): """ Initializes the Servo object @param index """ super(Servo, self).__init__(index) if (not self.blobExists()): self.jsonData = { 'name': '', 'channel': 0, 'ident': '', 'angle': 0, 'trim': 0, 'disabled': False, 'inverted': False, 'displayOrder': 0, 'servoMin': 150, 'servoMax': 600, 'boneName': '', 'boneArmature': '', 'boneAxis': '', 'partNo': '' } self.now = lambda: int(round(time.time() * 1000)) self.resetData() try: Servo.pwm except: debug = False if (Setting.get('servo_debug', False)): print("Setting Up PWM") debug = True Servo.pwm = PWM(0x40, debug=debug) Servo.pwm.setPWMFreq(60)
def __init__(self): # 四驱 self.PWMA = 18 self.AIN1 = 27 self.AIN2 = 22 self.PWMB = 23 self.BIN1 = 25 self.BIN2 = 24 # 超声波模块 self.Gpin = 5 self.Rpin = 6 self.TRIG = 20 self.ECHO = 21 # 红外线模块 self.SensorRight = 16 self.SensorLeft = 12 self.T_SensorLeft = 13 self.T_SensorRight = 26 # Initialise the PWM device using the default address # bmp = PWM(0x40, debug=True) self.pwm = PWM(0x40, debug=False) # Min pulse length out of 4096 self.servoMin = 150 # Max pulse length out of 4096 self.servoMax = 600 # PWM系数 self.DC2VC = 0.65 self.L_Motor = None self.R_Motor = None # 初始化 self.setup()
def ControlProps(status): logging.debug('ReadSensor, Thread ControlProps') pwm = PWM(0x40) pwm.setPWMFreq(50) # Set frequency to 60 Hz print "Starting Control of Props according Input" time.sleep(2) print "Starting Loop to Control Sleep" try: while status["start"]: if status["debug"]: print("Propeller 1:" + str(status["PropValue"][0]) + " Propeller 2:" + str(status["PropValue"][1]) + " Propeller 3:" + str(status["PropValue"][2]) + " Propeller 4:" + str(status["PropValue"][3])) time.sleep(0.1) else: time.sleep(0.002) #makes no sence to control prop more often with 50Hz pwm.setPWM(0, 0, int(status["PropValue"][0])) pwm.setPWM(1, 0, int(status["PropValue"][1])) pwm.setPWM(2, 0, int(status["PropValue"][2])) pwm.setPWM(3, 0, int(status["PropValue"][3])) print "Stopping Motors" pwm.setPWM(0, 0, 180) pwm.setPWM(1, 0, 180) pwm.setPWM(2, 0, 180) pwm.setPWM(3, 0, 180) except KeyboardInterrupt: pwm.setPWM(0, 0, 180) pwm.setPWM(1, 0, 180) pwm.setPWM(2, 0, 180) pwm.setPWM(3, 0, 180) print "Reset Servo!!" raise except: raise return
def __init__(self, addr = 0x60, freq = 1600): self._i2caddr = addr # default addr on HAT self._frequency = freq # default @1600Hz PWM freq self.motors = [ Adafruit_DCMotor(self, m) for m in range(4) ] self.steppers = [ Adafruit_StepperMotor(self, 1), Adafruit_StepperMotor(self, 2) ] self._pwm = PWM(addr, debug=False) self._pwm.setPWMFreq(self._frequency)
def __init__(self): print "qqqqqqqqqq" self.node_name = rospy.get_name() self.pwm = PWM(address=0x40, debug=False) self.pwm.setPWMFreq(60) self.pwm.setPWM(3, 0, 650) self.sub_joy_ = rospy.Subscriber("joy", Joy, self.cbJoy, queue_size=1)
class PanTiltDevice: """A class for controlling the PanTilt Device""" pwm = PWM(0x40) PAN_SERVO_CHANNEL = 0 TILT_SERVO_CHANNEL = 1 def __init__(self): self.pwm = PWM(0x40) self.pwm.setPWMFreq(10) # Set frequency to 60 Hz # self.panServo = Servo("pan", self.pwm, self.PAN_SERVO_CHANNEL, 280, 660, 0.2, 0.003) self.panServo = Servo("pan", self.pwm, self.PAN_SERVO_CHANNEL, 150, 700, 0.002, 0.00005) self.tiltServo = Servo("tilt", self.pwm, self.TILT_SERVO_CHANNEL, 500, 680, 0.002, 0.00005) def pan(self, percent): # print "panning to %d percent" % self.panTarget self.panServo.setTargetPosition(percent) def tilt(self, percent): # print "tilting to %d percent" % percent self.tiltServo.setTargetPosition(percent) def panAndTilt(self, panPercent, tiltPercent): self.pan(panPercent) self.tilt(tiltPercent)
def connect(self, address): if self.debug: print( "[connect:ServoDriver] connecting to the servo driver at i2c address ", address) self.pwm = PWM(address, debug=self.debug) self.pwm.setPWMFreq(self.freq)
def __init__(self): self.pwm = PWM(0x40) self.pwm.setPWMFreq(10) # Set frequency to 60 Hz # self.panServo = Servo("pan", self.pwm, self.PAN_SERVO_CHANNEL, 280, 660, 0.2, 0.003) self.panServo = Servo("pan", self.pwm, self.PAN_SERVO_CHANNEL, 150, 700, 0.002, 0.00005) self.tiltServo = Servo("tilt", self.pwm, self.TILT_SERVO_CHANNEL, 500, 680, 0.002, 0.00005)
def __init__(self, debug=False): self.pwm = PWM(address=0x40, debug=debug) for i in range(40): self.pwm.setPWM(i, 0, 4095) self.pwm.setPWM(0, 4095, 4095) sleep(100) self.pwm.setPWM(0, 4095, 4095) print "-----"
def initialise_led(): global pwm from Adafruit_PWM_Servo_Driver import PWM # Set LED parameters pwm = PWM(0x40) pwm.setPWMFreq(1000) print("LEDs are initialised")
def initializeServos(self): self.pwm = [] pwm = PWM(0x40) pwm.setPWMFreq(50) self.pwm.append(pwm) self.clearServos() pwm.setPWM(Dalek.SERVO_IRIS, 0, Dalek.SERVO_RATE_IRIS_DEFAULT) self.irisCurrentRate = Dalek.SERVO_RATE_IRIS_DEFAULT self.servoWait( Dalek.PWM_IRIS, Dalek.SERVO_IRIS, Dalek.SERVO_CRUISE_IRIS )
def __init__(self, servo_channel, motor_channel): self.servo_channel = servo_channel; self.motor_channel = motor_channel; self.servoMin = 275; # 1ms pulse self.servoMax = 550; # 2ms pulse self.speedMin = 275; # 1ms pulse self.speedMax = 550; # 2ms pulse self.pwm = PWM(0x40); self.pwm.setPWMFreq(60);
def __init__(self, addr=0x60, freq=1600, i2c=None, i2c_bus=None): self._frequency = freq self.motors = [Adafruit_DCMotor(self, m) for m in range(4)] self.steppers = [ Adafruit_StepperMotor(self, 1), Adafruit_StepperMotor(self, 2) ] self._pwm = PWM(addr, debug=False, i2c=i2c, i2c_bus=i2c_bus) self._pwm.setPWMFreq(self._frequency)
def begin(self, pwmFrequency = 60, block = 0, address = 0x40, busnum =1): """Call begin() before any other meArm calls. Optional parameters to select a different block of servo connectors or different I2C address.""" self.pwm = PWM(address, busnum) # Address of Adafruit PWM servo driver self.base = block * 4 self.shoulder = block * 4 + 1 self.elbow = block * 4 + 2 self.gripper = block * 4 + 3 self.pwm.setPWMFreq(pwmFrequency) self.closeGripper() self.home()
def init(): #-- initialization pwm = PWM(0x40) pwm.setPWMFreq(60) # Set frequency to 60 Hz setServoPulse(pwm, 1, 100) # print "delta=%d, oneDeg=%f" % (delta, oneDeg) for i in channels: curAngles[i] = 0 ready(pwm) return pwm
def begin(self, block = 0, address = 0x40, busnum =1): """Call begin() before any other meArm calls. Optional parameters to select a different block of servo connectors or different I2C address.""" self.pwm = PWM(address, busnum) # Address of Adafruit PWM servo driver self.base = block * 4 self.shoulder = block * 4 + 1 self.elbow = block * 4 + 2 self.gripper = block * 4 + 3 self.pwm.setPWMFreq(PWM_FREQUENCY) self.closeGripper() self.goDirectlyTo(HOME_X, HOME_Y, HOME_Z)
def begin(self, block = 0, address = 0x40): """Call begin() before any other meArm calls. Optional parameters to select a different block of servo connectors or different I2C address.""" self.pwm = PWM(address) # Address of Adafruit PWM servo driver self.base = block * 4 self.shoulder = block * 4 + 1 self.elbow = block * 4 + 2 self.gripper = block * 4 + 3 self.pwm.setPWMFreq(60) self.openGripper() self.goDirectlyTo(0, 100, 50)
def __init__(self, customaddress=0x40, panchannel=0, tiltchannel=3): self.Address = customaddress self.PanChannel = panchannel self.TiltChannel = tiltchannel self.PanMin = 104 self.PanMax = 560 self.TiltMin = 0 self.TiltMax = 0 self.PWM = PWM(self.Address) self.PWM.setPWMFreq(50)
def __init__(self, address=0x40, channel=0): self.data = [] self.server_channel = 0 self.freq = 60 self.pwm = PWM(0x40) self.servoMin = 150 self.servoMax = 600 self.pwm.setPWMFreq(self.freq) self.angle = 90 #centered in the beginning self.move_t_bin = 100 #milliseconds
def __init__(self): """ __init__ initializes class variables. """ global GPIO # running is used to control thread execution. self._running = True # Keep MuleBot parallel to the wall at this distance. self.distanceToWall = 0 self.pwmEnablePin = 23 # Broadcom pin 23 was 16 self.motor1DirectionPin = 24 # Broadcom pin 24 was 20 self.motor2DirectionPin = 25 # Broadcom pin 25 was 21 self.motorForward = GPIO.HIGH self.motorReverse = GPIO.LOW self.dcMotorLeftMotor = 0 self.dcMotorRightMotor = 1 self.laserDetectLeftPin = 6 self.laserDetectRightPin = 5 self.motorMaxRPM = 12.0 self.motorMaxRadiansPM = 2 * self.motorMaxRPM # Pin Setup: GPIO.setwarnings(False) GPIO.setmode(GPIO.BCM) # Broadcom pin-numbering scheme GPIO.setup(self.pwmEnablePin, GPIO.OUT) GPIO.setup(self.motor1DirectionPin, GPIO.OUT) GPIO.setup(self.motor2DirectionPin, GPIO.OUT) GPIO.output(self.pwmEnablePin, GPIO.LOW) # This is interupts setups. They get used with the # test() method. #GPIO.setup(laserDetectLeftPin, GPIO.IN, pull_up_down=GPIO.PUD_UP) #GPIO.setup(laserDetectRightPin, GPIO.IN, pull_up_down=GPIO.PUD_UP) #GPIO.add_event_detect(laserDetectLeftPin, GPIO.FALLING, callback=myInt) #GPIO.add_event_detect(laserDetectRightPin, GPIO.FALLING, callback=myInt) # Initialise the PWM device using the default address self.pwm = PWM(0x40) # Note if you'd like more debug output you can instead run: #pwm = PWM(0x40, debug=True) #count = 1 self.pwm.setPWMFreq(1000) # Set frequency to 1000 Hz self.tgt_min_range = 15
def __init__(self): self.ADDRESSE = 0x40 self.MIN_PULSE_LENGTH = 150 self.MAX_PULSE_LENGTH = 600 self.FREQUENCY = 60 self.CLAMP_VALUES = [[self.MIN_PULSE_LENGTH, self.MAX_PULSE_LENGTH] ] * 15 self.pwm = PWM(self.ADDRESSE) self.INDEX = 0 print(self.CLAMP_VALUES)
def __init__(self, channel, min, max, freq): self.pwm = PWM(0x40) self.pwm.setPWMFreq(freq) self.channel = channel self.min = min self.max = max self.range = max - min # get middle of the range self.current = 0 self.move_to(0.5)
def __init__(self, proto, serverIP, serverPORT): # Init class self.proto = proto self.serverIP = serverIP self.serverPORT = serverPORT self.serverAddr = self.proto + "://" + self.serverIP + ":" + self.serverPORT self.connect() # Init PWM Driver self.pwm = PWM(0x40, debug=config.get('control', 'pwm_debug')) self.pwm.setPWMFreq(config.get('control', 'pwm_freq'))
def __init__(self): # PWM settings FREQ = 60.0 # Set frequency to 60 Hz self.pwm = PWM(0x40, debug=False) self.pwm.setPWMFreq(FREQ) pulseLength = 1000000 # 1,000,000 us per second pulseLength /= FREQ # 60 Hz pulseLength /= 4096 # 12 bits of resolution self.pulseFactor = 1000 / pulseLength # millisecond multiplier # Tested Servo range self.pulsecenter = 1.6 self.pulserange = 0.8 #per adafruit 0.5 = 1.0...1.5...2.0
def __init__(self, name): self.name = name self.type = 'pca9685_pwm' self.channel_config = [] self.i2c_address = None self.dmx_channel_start = None self.dmx_channel_end = None self.handler = self.default_handler self.servo_min = 103 # Min pulse length out of 4096 = 20mS self.servo_max = 500 # Max pulse length out of 4096 self.pwm = PWM(0x40, debug=True) self.pwm.setPWMFreq(50) # Set frequency to 60 Hz
def __init__(self, addr=0x60, freq=1600): self._i2caddr = addr # default addr on HAT self._frequency = freq # default @1600Hz PWM freq # self.steppers = [ Adafruit_StepperMotor(self, 1), Adafruit_StepperMotor(self, 2) ] self._pwm = PWM(addr, debug=False) self._pwm.setPWMFreq(self._frequency) # Just gonna default to high for now GPIO.setmode(GPIO.BCM) GPIO.setwarnings(False) GPIO.setup(17, GPIO.OUT) GPIO.output(17, GPIO.HIGH) self.motors = [dw_DCMotor(self, m) for m in range(6)]