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.servos= [ Adafruit_Servo(self,0),Adafruit_Servo(self,1),Adafruit_Servo(self,14),Adafruit_Servo(self,15)] self._pwm = PWM(addr, debug=False, i2c=i2c, i2c_bus=i2c_bus) self._pwm.setPWMFreq(self._frequency)
class Arm(): def __init__(self): self.x = 1000 self.y = 1000 self.pwm = PWM(address=0x40, debug=False, i2c=None, i2c_bus=1) self.pwm.setPWMFreq(50) def down(self): if self.y >= 300: self.y -= 50 self.pwm.setServoPulse(0,self.y) def up(self): if self.y <= 1500: self.y += 50 self.pwm.setServoPulse(0,self.y) def close(self): if self.x <= 1500: self.x += 50 self.pwm.setServoPulse(1,self.x) def open(self): if self.x >= 300: self.x -= 50 self.pwm.setServoPulse(1,self.x)
def setup(self): GPIO.setwarnings(False) GPIO.setmode(GPIO.BOARD) self.pwm = PWM(0x40, debug=False) self.pwm.setPWMFreq(50) # 50 full 'pulses' per second self.front() # calibration
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, addr=0x40, freq=1600, busnum=None): """Init """ self._i2caddr = addr # default addr self._frequency = freq # default @1600Hz PWM freq self._motors = None self._steppers = None self._leds = None self._pwm = PWM(address=addr, i2c_bus=busnum) self._pwm.setPWMFreq(self._frequency)
def __init__(self, servo_number, start_pos=300, used_i2c_addresses=[0x40]): self.servo_number = servo_number self.start_pos = start_pos self.servo_pin, self.servo_hat_address = self._get_servo_connection( servo_number) self.used_i2c_addresses = used_i2c_addresses if self.servo_hat_address in self.used_i2c_addresses: self.servo_obj = PWM(self.servo_hat_address) self.pwm_freq = 50 self.servo_obj.setPWMFreq( self.pwm_freq) # 60hz = 16.666ms, 50hz = 20ms, 40hz = 25ms
def __init__(self, addr = 0x40, freq = 1600, busnum=None): """Init """ self._i2caddr = addr # default addr self._frequency = freq # default @1600Hz PWM freq self._motors = None self._steppers = None self._leds = None self._pwm = PWM(address=addr, i2c_bus=busnum) self._pwm.setPWMFreq(self._frequency)
class Servo(object): def __init__(self, servo_number, start_pos=300, used_i2c_addresses=[0x40]): self.servo_number = servo_number self.start_pos = start_pos self.servo_pin, self.servo_hat_address = self._get_servo_connection( servo_number) self.used_i2c_addresses = used_i2c_addresses if self.servo_hat_address in self.used_i2c_addresses: self.servo_obj = PWM(self.servo_hat_address) self.pwm_freq = 50 self.servo_obj.setPWMFreq( self.pwm_freq) # 60hz = 16.666ms, 50hz = 20ms, 40hz = 25ms def turn_off(self): self.servo_obj.setPWM(self.servo_pin, 0, 4096) def set_pos(self, new_pos): logger.debug('Servo {}\tgoing to {}'.format(self.servo_pin, new_pos)) # new generation servos check only total length of duty cycle self.servo_obj.setPWM(channel=self.servo_pin, on=0, off=new_pos) sleep(1.0 / self.pwm_freq) @staticmethod def _get_servo_connection(servo_pin): """ Returns servo pins as int and servo hat board address as hex. """ hat_address = servo_pin / 16 servo_pin %= 16 hat_address = int(hex(64 + hat_address), 16) return servo_pin, hat_address
class RGB_LED: OFFSET_RED = 0 OFFSET_GREEN = 1 OFFSET_BLUE = 2 def __init__(self, debug=False): from Adafruit_MotorHAT.Adafruit_PWM_Servo_Driver import PWM # @UnresolvedImport self.pwm = PWM(address=0x40, debug=debug) for i in range(15): self.pwm.setPWM(i, 0, 4095) def setLEDBrightness(self, led, offset, brightness): self.pwm.setPWM(3 * led + offset, brightness << 4, 4095) def setRGBint24(self, led, color): r = color >> 16 & 0xFF g = color >> 8 & 0xFF b = color >> 0 & 0xFF self.setRGBvint8(led, [r, g, b]) def setRGBvint8(self, led, color): self.setLEDBrightness(led, self.OFFSET_RED, color[0]) self.setLEDBrightness(led, self.OFFSET_GREEN, color[1]) self.setLEDBrightness(led, self.OFFSET_BLUE, color[2]) def setRGB(self, led, color): assert len(color) == 3 assert min(color) >= 0 assert max(color) <= 1 self.setRGBvint8(led, [int(c * 255) for c in color]) def __del__(self): for i in range(15): self.pwm.setPWM(i, 0, 4095) del self.pwm
class Pca9685Manager(Adafruit_MotorHAT): """To share bus with the adafruit library. Maybe we must control the pin use (ie to not activate a led on the """ def __init__(self, addr=0x40, freq=1600, busnum=None): """Init """ self._i2caddr = addr # default addr self._frequency = freq # default @1600Hz PWM freq self._motors = None self._steppers = None self._leds = None self._pwm = PWM(address=addr, i2c_bus=busnum) self._pwm.setPWMFreq(self._frequency) @property def motors(self): """ """ if self._motors is None: self._motors = [Adafruit_DCMotor(self, m) for m in range(4)] return self._motors @property def steppers(self): """ """ if self._steppers is None: self._steppers = [ Adafruit_StepperMotor(self, 1), Adafruit_StepperMotor(self, 2) ] return self._steppers def software_reset(self): """ """ self._pwm.softwareReset()
class Pca9685Manager(Adafruit_MotorHAT): """To share bus with the adafruit library. Maybe we must control the pin use (ie to not activate a led on the """ def __init__(self, addr = 0x40, freq = 1600, busnum=None): """Init """ self._i2caddr = addr # default addr self._frequency = freq # default @1600Hz PWM freq self._motors = None self._steppers = None self._leds = None self._pwm = PWM(address=addr, i2c_bus=busnum) self._pwm.setPWMFreq(self._frequency) @property def motors(self): """ """ if self._motors is None: self._motors = [ Adafruit_DCMotor(self, m) for m in range(4) ] return self._motors @property def steppers(self): """ """ if self._steppers is None: self._steppers = [ Adafruit_StepperMotor(self, 1), Adafruit_StepperMotor(self, 2) ] return self._steppers def software_reset(self): """ """ self._pwm.softwareReset()
class Adafruit_MotorHAT: FORWARD = 1 BACKWARD = 2 BRAKE = 3 RELEASE = 4 SINGLE = 1 DOUBLE = 2 INTERLEAVE = 3 MICROSTEP = 4 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.servos= [ Adafruit_Servo(self,0),Adafruit_Servo(self,1),Adafruit_Servo(self,14),Adafruit_Servo(self,15)] self._pwm = PWM(addr, debug=False, i2c=i2c, i2c_bus=i2c_bus) self._pwm.setPWMFreq(self._frequency) def setPin(self, pin, value): if (pin < 0) or (pin > 15): raise NameError('PWM pin must be between 0 and 15 inclusive') if (value != 0) and (value != 1): raise NameError('Pin value must be 0 or 1!') if (value == 0): self._pwm.setPWM(pin, 0, 4096) if (value == 1): self._pwm.setPWM(pin, 4096, 0) def getStepper(self, steps, num): if (num < 1) or (num > 2): raise NameError('MotorHAT Stepper must be between 1 and 2 inclusive') return self.steppers[num-1] def getMotor(self, num): if (num < 1) or (num > 4): raise NameError('MotorHAT Motor must be between 1 and 4 inclusive') return self.motors[num-1] def getServo(self,num): if(num!=0) and (num!=1) and (num!=14) and (num!=15): raise NameError('MotorHAT Servo must be [0,1,14,15]') if(num == 14) or (num == 15): num=num-12 return self.servos[num]
class Adafruit_MotorHAT: FORWARD = 1 BACKWARD = 2 BRAKE = 3 RELEASE = 4 SINGLE = 1 DOUBLE = 2 INTERLEAVE = 3 MICROSTEP = 4 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 setPin(self, pin, value): if (pin < 0) or (pin > 15): raise NameError('PWM pin must be between 0 and 15 inclusive') if (value != 0) and (value != 1): raise NameError('Pin value must be 0 or 1!') if (value == 0): self._pwm.setPWM(pin, 0, 4096) if (value == 1): self._pwm.setPWM(pin, 4096, 0) def getStepper(self, steps, num): if (num < 1) or (num > 2): raise NameError( 'MotorHAT Stepper must be between 1 and 2 inclusive') return self.steppers[num - 1] def getMotor(self, num): if (num < 1) or (num > 4): raise NameError('MotorHAT Motor must be between 1 and 4 inclusive') return self.motors[num - 1]
#from Adafruit_MotorHAT from Adafruit_MotorHAT.Adafruit_PWM_Servo_Driver import PWM import atexit import time pow = 4000 iter = 20000 dt = 0.1 pwm = PWM(0x60) pwm.setPWMFreq(1000) def coil1(pow): if (pow < 0): pwm.setPWM(3, 0, 4096) pwm.setPWM(4, 4096, 0) pwm.setPWM(2, 0, -pow) print("cewka 1 -") if (pow > 0): pwm.setPWM(3, 4096, 0) pwm.setPWM(4, 0, 4096) pwm.setPWM(2, 0, pow) print("cewka 1 +") if (pow == 0): pwm.setPWM(3, 0, 0) pwm.setPWM(4, 0, 0) pwm.setPWM(2, 0, pow) print("cewka 1 null")
def __init__(self): self.x = 1000 self.y = 1000 self.pwm = PWM(address=0x40, debug=False, i2c=None, i2c_bus=1) self.pwm.setPWMFreq(50)
import os import robot_util from Adafruit_MotorHAT import Adafruit_MotorHAT, Adafruit_DCMotor from Adafruit_MotorHAT.Adafruit_PWM_Servo_Driver import PWM import time import atexit mh = Adafruit_MotorHAT(addr=0x6F) pwm = PWM(0x6F) #These are the on times that get sent to the pwm module to tell the servo how #far to rotate. Duty cycle is onTime/4095. Set these to limit the range of #motion to something sensible. Be sure the pan tilt doesn't bottom out or you #can damage the servo. panMinOnTime = 125 panMaxOnTime = 625 tiltMinOnTime = 125 tiltMaxOnTime = 575 #global variables to keep track of current percentage of tilt and pan panPercentage = 50.0 tiltPercentage = 50.0 #Sets how big of a step each button press gives in percentage. tiltIncrement = 5 panIncrement = 10.0 / 3.0 #Sets the duty cycle for the motors while moving. speed/255 is the duty cycle. straightSpeed = 255 turnSpeed = 255
def __init__(self, debug=False): from Adafruit_MotorHAT.Adafruit_PWM_Servo_Driver import PWM # @UnresolvedImport self.pwm = PWM(address=0x40, debug=debug) for i in range(15): self.pwm.setPWM(i, 0, 4095)
from Adafruit_MotorHAT.Adafruit_PWM_Servo_Driver import PWM import atexit pwm = PWM(0x60) pwm_frequency = 60 pwm.setPWMFreq(pwm_frequency) period_in_ms = 1000 / pwm_frequency pulse_steps = 4096 servo_midPoint_ms = 1.5 deflect_90_in_ms = 0.5 flect_90_in_ms = 2 steps_per_ms = pulse_steps / period_in_ms steps_per_degree = (deflect_90_in_ms * steps_per_ms) / 90 sero_mid_point_steps = servo_midPoint_ms * steps_per_ms def convert_degrees_to_pwm(position): return int(sero_mid_point_steps + (position * steps_per_degree)) def stop(): #set pin off flag pwm.setPWM(0, 0, 4096) atexit.register(stop) while 1: position = int(input("请输入角度(-90 ~ 90 0是中间):"))
class LRCameraServo(): pwm_pin = 1 last_angle = -1 def __init__(self): self.setup() def setup(self): GPIO.setwarnings(False) GPIO.setmode(GPIO.BOARD) self.pwm = PWM(0x40, debug=False) self.pwm.setPWMFreq(50) # 50 full 'pulses' per second self.front() # calibration def setServoPulse(self, pulse_width): # pulse: 1ms, range:[0.5, 2.5] pulseLength = 1000000.0 # 1,000,000 us per second pulseLength /= 50.0 # 50 Hz #print("%d us per period" % pulseLength) pulseLength /= 4096.0 # 12 bits of resolution #print("%d us per bit" % pulseLength) pulse_width *= 1000.0 pulse_width /= (pulseLength * 1.0) #print("pluse: %f " % (pulse_width)) self.pwm.setPWM(self.pwm_pin, 0, int(pulse_width)) # turn servo # angle to pulse width def turn_servo(self, angle): pulse_width = angle / 90.0 + 0.5 pulse_width = max(pulse_width, 0.5) pulse_width = min(pulse_width, 2.5) self.setServoPulse(pulse_width) # turn left (angle is based on front) def turn_right_servo_test(self, angle): angle = 90 - angle self.turn_servo(angle) # turn right ((angle is based on front)) def turn_left_servo_test(self, angle): angle = 90 + angle self.turn_servo(angle) # front def front(self): self.last_angle = 90 self.turn_servo(90) # turn left based on last angle def turn_right_servo(self, angle): real_angle = self.last_angle - angle self.turn_servo(real_angle) self.last_angle = real_angle # turn right based on last angle def turn_left_servo(self, angle): real_angle = self.last_angle + angle self.turn_servo(real_angle) self.last_angle = real_angle def destroy(self): self.pwm = None GPIO.cleanup()
servo_parameter_text[9]: 0.0, # paw angle servo_parameter_text[10]: 1.0, # step angle servo_parameter_text[11]: False, # move status } ## ==== set pin of servo ==== pin = {} pin[servo_parameter_text[6]] = 15 pin[servo_parameter_text[7]] = 0 pin[servo_parameter_text[8]] = 14 pin[servo_parameter_text[9]] = 1 ## ==== set pin of servo ==== servo = PWM(board["addr"]) servo.setPWMFreq(servo_parameter["frequency"]) def setServoPulse(pin, angle): pulseLength = 1000000 # 1,000,000 us per second pulseLength /= servo_parameter["frequency"] # Hz pulseLength /= 4096 # 12 bits of resolution pulse = (servo_parameter["pulse_max"] - servo_parameter["pulse_min"]) * ( angle - servo_parameter["angle_min"]) / ( servo_parameter["angle_max"] - servo_parameter["angle_min"]) + servo_parameter["pulse_min"] pulse *= 1000 pulse /= pulseLength servo.setPWM(pin, 0, int(pulse))
#!/usr/bin/python #This example is using the GPIO pin directly from Raspberry Pi 3 import sys import tty, termios from Adafruit_MotorHAT.Adafruit_PWM_Servo_Driver import PWM from time import sleep import argparse ticks = 4096.0 periodTime = 20000.0 #50Hz a period time is 20000us midTime = 1500.0 #Servo Middle: 1.5ms=1500us minVal = int(1000 / periodTime * ticks) #Minimum PWM length is 1ms=1000us maxVal = int(2000 / periodTime * ticks) #Maxium PWM length is 2ms=2000us initVal = int(midTime * ticks / periodTime) pulseDiv = 1 pulseVal = initVal pwm = PWM() #Initialize pwm pwm.setPWMFreq(50) #Setting Freq as 50Hz reset_order = [3, 2, 1, 4, 5, 6] for channelPin in reset_order: pwm.setPWM(channelPin, 0, initVal) sleep(1) pwm.setPWM(channelPin, 0, 0)
#!/usr/bin/python from Adafruit_MotorHAT import Adafruit_MotorHAT, Adafruit_DCMotor from Adafruit_MotorHAT.Adafruit_PWM_Servo_Driver import PWM import time import atexit pwm = PWM(0x6f, debug=True) pwm.setPWMFreq(1600) # create a default object, no changes to I2C address or frequency mh = Adafruit_MotorHAT(addr=0x6f) # recommended for auto-disabling motors on shutdown! def turnOffMotors(): mh.getMotor(1).run(Adafruit_MotorHAT.RELEASE) mh.getMotor(2).run(Adafruit_MotorHAT.RELEASE) # mh.getMotor(3).run(Adafruit_MotorHAT.RELEASE) # mh.getMotor(4).run(Adafruit_MotorHAT.RELEASE) atexit.register(turnOffMotors) right = mh.getMotor(1) left = mh.getMotor(2) # set the speed to start, from 0 (off) to 255 (max speed) right.setSpeed(150) left.setSpeed(150)