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)
