def __init__(self, remote_address):
# set PINs on BOARD
log.debug("Initializing Servos...")
log.debug("> pin 1: " + str(_conf['servo_1_pin']))
log.debug("> pin 2: " + str(_conf['servo_2_pin']))
# using Servo
rem_pi = PiGPIOFactory(host=remote_address)
self.servo1 = Servo(_conf['servo_1_pin'], pin_factory=rem_pi)
self.servo2 = Servo(_conf['servo_2_pin'], pin_factory=rem_pi)
# servos positions
self.servo1_position = Value('d', 0.5)
self.servo2_position = Value('d', 0.5)
# queues and processes
log.debug("Initializing Servos queues and processes...")
self.queue1 = Queue()
self.queue2 = Queue()
self.process1 = Process(target=self.P1)
self.process2 = Process(target=self.P2)
self.process1.start()
self.process2.start()
log.debug("...init done!")
def __initServo(self):
self.myServo1 = Servo(self.myGPIO1,
min_pulse_width=self.minPW,
max_pulse_width=self.maxPW)
self.myServo2 = Servo(self.myGPIO2,
min_pulse_width=self.minPW,
max_pulse_width=self.maxPW)
def ConnectToNetworkGPIO(hostname, MIN_PW, MAX_PW, iFrontTPin, iBackTPin,
iLeftTPin, iRightPin):
#sets the pinfactory which enables networking features. This class can take IP addresses, but host names are more constant.
remote_host = PiGPIOFactory(host=hostname)
#pulse width units for the Servo class are in seconds, below are the default values
#Servo(pin, *, initial_value=0, min_pulse_width=1/1000, max_pulse_width=2/1000, frame_width=20/1000, pin_factory=None)
objFrontThruster = Servo(iFrontTPin,
min_pulse_width=MIN_PW,
max_pulse_width=MAX_PW,
pin_factory=remote_host)
objBackThruster = Servo(iBackTPin,
min_pulse_width=MIN_PW,
max_pulse_width=MAX_PW,
pin_factory=remote_host)
objLeftThruster = Servo(iLeftTPin,
min_pulse_width=MIN_PW,
max_pulse_width=MAX_PW,
pin_factory=remote_host)
objRightThruster = Servo(iRightPin,
min_pulse_width=MIN_PW,
max_pulse_width=MAX_PW,
pin_factory=remote_host)
#dictionary of thruster servo objects
thrusters = {
"Front": objFrontThruster,
"Back": objBackThruster,
"Left": objLeftThruster,
"Right": objRightThruster
}
return thrusters
def __init__(self, pin):
self._servo = Servo(pin,
self._pos,
self.pulse[0],
self.pulse[1],
20 / 1000,
pin_factory=factory)
self.set_level(self._level)
def __init__(self, servo_position=0, led_status=0):
self.servo = Servo(self.servo_pin,
min_pulse_width=self.minPW,
max_pulse_width=self.maxPW)
self.led = LED(self.led_pin)
self.move_servo(servo_position)
self.set_led_status(led_status)
class motion_handler:
def __init__(self,
sweep_delay_sec=3,
movement_speed=0.25,
motor_pin=19,
tick_interval_sec=0.45):
self.motor = Servo(motor_pin)
self.movementSpeed = movement_speed
self.motorPin = motor_pin
self.tickIntervalSec = tick_interval_sec
self.sweepDelaySec = sweep_delay_sec
# setup feedback thread
self.sweepTimeMarker = time.time()
self.sweepMode = False
self.delta = 0
self.thread = threading.Thread(target=self.motion_tick)
self.thread.setDaemon(True)
self.thread.setName("motion_handler_thread")
# Run feedback tick loop
self.isRunning = True
self.thread.start()
def set_motion_delta(self, sweep_mode, delta):
#print("Sweep:",sweep_mode,", Delta:",delta)
if (sweep_mode):
if (time.time() - self.sweepTimeMarker > self.sweepDelaySec):
self.sweepMode = True
else:
self.sweepMode = False
self.sweepTimeMarker = time.time()
angle_of_sight_degree = 12
# +ve: look up, -ve: look down
self.delta = delta * angle_of_sight_degree / 90
def motion_tick(self):
# start at 90 degree
pos = 0 # range from -1 to 1
sweep = 1
self.motor.value = pos
while self.isRunning:
if (self.sweepMode):
pos += self.movementSpeed * sweep
else:
pos += self.delta
if (pos > 1):
pos = 1
sweep = -1
elif (pos < -1):
pos = -1
sweep = 1
self.motor.value = pos
time.sleep(self.tickIntervalSec)
def __del__(self):
self.motor.stop()
GPIO.cleanup()
class PowerSelector:
pulse = FS5106S
_min_level = 1
_max_level = 9
_min_pos = -1.0
_max_pos = 1.0
_delta = (_max_pos - _min_pos) / (_max_level - _min_level)
_level = (_max_level - _min_level + 1) // 2
def __init__(self, pin):
self._servo = Servo(pin,
self._pos,
self.pulse[0],
self.pulse[1],
20 / 1000,
pin_factory=factory)
self.set_level(self._level)
@property
def _pos(self):
# level 1 = 1
# level 9 = -1
# the servo is installed reversed,
# so -1 - is max power, 1 - is min
pos = self._max_pos - \
(self._level - self._min_level) * self._delta
if pos > self._max_pos:
pos = self._max_pos
if pos < self._min_pos:
pos = self._min_pos
return pos
def set_level(self, new_level):
if new_level < self._min_level:
new_level = self._min_level
if new_level > self._max_level:
new_level = self._max_level
self._level = new_level
logger.info(f"Setting power level to {new_level}")
pos = self._pos
logger.debug(f"Servo pos is set to {pos}")
self._servo.value = self._pos
sleep(3)
self._servo.detach()
def detach(self):
self._servo.detach()
def doIt3():
try:
for pin in PINS:
servo = Servo(pin)
servo.mid()
time.sleep(1)
except Exception as e:
with open('failedToFeed.txt', 'w') as info:
info.write('something went wrong with the servo')
info.write(str(e))
def moveServo():
led = LED(23)
led.on()
servo = Servo(14)
servo.value = -1
sleep(2)
servo.value = 0
sleep(2)
servo.value = 1
sleep(2)
led.off()
def execute():
gpio = 17
servo = Servo(gpio)
print("Airdrop initiated!")
i = 1
while i in range(1, 4):
servo.mid()
sleep(1)
i = i + 1
print("Done.. Enjoy!")
return
def __init__(self):
self._yaw_half_range = 90.0
self._pitch_half_range = 90.0
self._angular_margin = 0
self._yaw = 0.0
self._pitch = 0.0
self._yaw_servo = Servo(PIN_A)
self._pitch_servo = Servo(PIN_B)
class Arm:
def __init__(self, pin):
self.pin = pin
self.arm = Servo(self.pin)
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(self.pin, GPIO.OUT)
def move(self):
self.arm.max()
time.sleep(0.8)
self.arm.mid()
time.sleep(0.8)
class RemoveStopper:
def __init__(self):
self.servo = Servo(pin_fig.remove_stopperservo)
self.servo.min()
sleep(1)
def on(self):
self.servo.value = -0.5
# sleep(1)
print("remove stopper on")
def off(self):
self.servo.close()
print("remove stopper off")
def main():
recognizer = aiy.cloudspeech.get_recognizer()
recognizer.expect_phrase('maximum')
recognizer.expect_phrase('minimum')
recognizer.expect_phrase('middle')
button = aiy.voicehat.get_button()
aiy.audio.get_recorder().start()
servo = Servo(26)
while True:
print('Press the button and speak')
button.wait_for_press()
print('Listening...')
text = recognizer.recognize()
if text is None:
print('Sorry, I did not hear you.')
else:
print('You said "', text, '"')
if 'maximum' in text:
print('Moving servo to maximum')
servo.max()
elif 'minimum' in text:
print('Moving servo to minimum')
servo.min()
elif 'middle' in text:
print('Moving servo to middle')
servo.mid()
def main():
stream = StreamListener.createStream()
stream.filter("Google Yahoo", async=True)
# build a recognizer and load it up with terms
rec = aiy.cloudspeech.get_recognizer()
rec.expect_phrase('min')
rec.expect_phrase('max')
rec.expect_phrase('mid')
# start listening
aiy.audio.get_recorder().start()
# setup servo 0
servo = Servo(26)
# setup the button
but = aiy.voicehat.get_button()
# the led for the button
led = 26
GPIO.setmode(GPIO.BCM)
GPIO.setup(led, GPIO.OUT)
# one time init message printed to console and said through speaker
print("initializing system")
say("initializing system")
sleep(1) # wait for one second
while True:
say("press button and say min, max or mid to control servo")
GPIO.output(led, GPIO.HIGH)
print("press button to command servo")
but.wait_for_press()
print("listening")
text = rec.recognize()
if text is None:
GPIO.output(led, GPIO.LOW)
say("That is not a valid command!")
else:
text = text.lower()
GPIO.output(led, GPIO.HIGH)
if 'min' in text:
say("min")
print("min")
servo.min()
elif 'max' in text:
say("max")
print("max")
servo.max()
elif 'mid' in text:
say("mid")
print("mid")
servo.mid()
else:
say("i'm sorry i heard, " + text +
" which is not a valid command")
print("i'm sorry i heard, " + text +
" which is not a valid command")
GPIO.output(led, GPIO.LOW)
def Move_Servo():
servo = Servo(26)
servo.max()
sleep(.5)
servo.min()
sleep(.25)
servo.max()
def __init__(self):
#set default
self.pan = Servo(4)
self.tilt = Servo(25)
def servoUpdate(data): #update servos
self.pan.value = data.pan
self.tilt.value = data.tilt
#create the node and subscribe
rospy.Subscriber('servos', servos, servoUpdate)
rospy.init_node('servos', anonymous=True)
self.rate = rospy.Rate(10)
def __init__(self, config):
'''
:param pwmPin the pin which connects to the PWM input of the servo
:param servoPowerPin the pin which controls the relay for power to the servo (high=power on, low (default) = power off
:param position0PWM duty cycle which puts servo in position 0
:param position1PWM duty cycle which puts servo in position 1
:param real is this on a real pi? (false only for certain testing)
'''
self.servo = None
self.relay = None
# is position actively changing?
self.changing = True
self.timeToChange = config["timeToChange"]
self.lock = threading.RLock()
# unknown at startup
self.position = -1
# really on a pi with a motor?
self.real = config["real"]
self.position0 = config["position0PWM"]
self.position1 = config["position1PWM"]
if config["real"]:
self.servo = Servo(config["servoPin"])
self.relay = DigitalOutputDevice(config["relayPin"])
def __init__(self, red_led_pin, green_led_pin, left_servo_pin,
right_servo_pin, left_motor_forward, left_motor_backward,
right_motor_forward, right_motor_backward):
# Input
self.imu = Imu()
self.camera = Camera()
# Output
self.red_led = Led(red_led_pin)
self.green_led = Led(green_led_pin)
self.left_servo = Servo(left_servo_pin, min_angle=-90, max_angle=90)
self.right_servo = Servo(right_servo_pin, min_angle=-90, max_angle=90)
self.left_motor = Motor(forward=left_motor_forward,
backward=left_motor_backward)
self.right_servo = Motor(forward=right_motor_forward,
backward=right_motor_backward)
def __init__(self, servo_position=0, led_status=0):
self.servo = Servo(self.servo_pin)
self.led = LED(self.led_pin)
self.move_servo(servo_position)
self.set_led_status(led_status)
def initialize(self):
if Car.speed is None or Car.steering is None:
try:
from gpiozero import Servo
from aiy.pins import PIN_A
from aiy.pins import PIN_B
Car.speed = Servo(PIN_B)
Car.steering = Servo(PIN_A)
Car.connected = True
except:
self.log('ERROR', 'Driving is not supported')
Car.connected = False
if len(Car.config.keys()) == 0:
Car.load_config()
return Car.connected
def handle_brew(self, message):
self.speak_dialog('brew')
servo = Servo(17)
servo.min()
sleep(1)
servo.max()
sleep(1)
servo.min()
sleep(1)
def __init__(self, pin_gpio, min_angle=-90, max_angle=90):
self.servo = Servo(pin_gpio,
min_pulse_width=0.5 / 1000,
max_pulse_width=2.5 / 1000,
pin_factory=factory)
self.MAX_angle = max_angle
self.MIN_angle = min_angle
self.angle = self.MIN_angle
def wiggle_servos(GPIOs, diff, vel):
val = 0
servos = [Servo(i, min_pulse_width=minPW, max_pulse_width=maxPW) for i in GPIOs]
while True:
val += vel
for i in range(len(servos)):
v = np.sin((i * diff + val) / 100.0) / 1.2
servos[i].value = v
sleep(0.05)
def __init__(self, aType, actuatorID, pins, partNumber, direction):
"""
Constructor to initialize an Actutator object, which can be an AngularServo(), Motor(), or Relay()
Key arguments:
self - Newly created object
aType - Single String character to select type of actuator to create (S=Servo, M=Motor, R=Relay)
actuatorID - Interger CONSTANT defined in Driver.py to enable quick array searches
pins - Array to document wires / pins being used by Raspberry Pi to control an actuator
partNumber - Vendor part number string variable (e.g. Seamuing MG996R)
direction - Set counter-clockwise (CCW) / Linear IN or clockwise (CW) / Linear OUT as the forward direction
Return value:
Newly created Actuator() object
"""
currentProgramFilename = os.path.basename(__file__)
self.DebugObject = Debug(True, currentProgramFilename)
self.actuatorID = actuatorID
self.actuatorType = aType
numOfWires = len(pins)
wires = np.empty(numOfWires, dtype=object) # TODO wires = ndarray((len(pins),),int) OR wires = [None] * len(pins) # Create an array on same length as pins[?, ?, ?]
for i in range(numOfWires):
#TODO REMOVE print("PIN: " + repr(i))
self.wires[i] = pins[i]
self.partNumber = partNumber
self.forwardDirection = direction
# The last wire in array is the PWM control pin
tempServoObject = Servo(pins[0]) #TODO REMOVE BECAUSE TO SIMPLE AN OBJECT
#tempServoObject = gpiozero.Servo(pins[0]) #TODO REMOVE BECAUSE TO SIMPLE AN OBJECT
tempAngularServoObject = AngularSevo(wires[len(wires)-1])
# The last two wires in array are the INPUT control pins
tempMotorObject = Motor(wires[len(wires)-2], wires[len(wires)-1])
# The last wire in array is the relay control pin
tempRelayObject = OutputDevice(wires[len(wires)-1])
# https://gist.github.com/johnwargo/ea5edc8516b24e0658784ae116628277
# https://gpiozero.readthedocs.io/en/stable/api_output.html
# https://stackoverflow.com/questions/14301967/bare-asterisk-in-function-arguments/14302007#14302007
if(aType == "S"):
self.actuatorObject = tempAngularServoObject
#TODO If above DOES NOT WORK: self.actuatorType = Servo(wires[0], initial_value=0, min_pulse_width=1/1000, max_pulse_width=2/1000, frame_width=20/1000, pin_factory=None)
elif(aType == "M"):
self.actuatorObject = tempMotorObject
#TODO If above DOES NOT WORK: self.actuatorType = Motor(wires[0], wires[1], pwm=true, pin_factory=None)
elif(aType == "R"):
self.actuatorObject = tempRelayObject
#TODO If above DOES NOT WORK: self.actuatorObject = gpiozero.OutputDevice(wired[0], active_high=False, initial_value=False)
else:
self.DebugObject.Dprint("INVALID Actutator Type in __init__ method, please use S, M, or R string as first parameter to Actuator() Object")
def __init__(self, controller_connected):
self.front_right_wheel = Servo(16)
self.front_left_wheel = Servo(19)
self.back_right_wheel = Servo(20)
self.back_left_wheel = Servo(26)
self.steering_servo = AngularServo(21, min_angle=-45, max_angle=45)
self.speed = -1
self.limiter = -1
self.regulator = threading.Event()
self.regulator_thread = threading.Thread(target=self.regulator_run, args=(lambda: controller_connected,))
self.regulator_thread.start()
self.regulator_thread.join()
def main():
rec = aiy.cloudspeech.get_recognizer()
rec.expect_phrase('min')
rec.expect_phrase('max')
rec.expect_phrase('mid')
aiy.audio.get_recorder().start()
servo = Servo(26)
but = aiy.voicehat.get_button()
led = 26
GPIO.setmode(GPIO.BCM)
GPIO.setup(led, GPIO.OUT)
print("initializing system")
say("initializing system")
sleep(1)
while True:
say("press button and say min, max or mid to control servo")
GPIO.output(led, GPIO.HIGH)
print("press button to command servo")
but.wait_for_press()
print("listening")
text = rec.recognize()
if text is None:
GPIO.output(led, GPIO.LOW)
say("That is not a valid command!")
else:
text = text.lower()
GPIO.output(led, GPIO.HIGH)
if 'min' in text:
say("min")
print("min")
servo.min()
elif 'max' in text:
say("max")
print("max")
servo.max()
elif 'mid' in text:
say("mid")
print("mid")
servo.mid()
else:
say("i'm sorry i heard, " + text +
" which is not a valid command")
print("i'm sorry i heard, " + text +
" which is not a valid command")
GPIO.output(led, GPIO.LOW)
def init_serv():
global gserv, tserv
print("start serv init")
gserv.append(
Servo(PIN_A,
initial_value=0,
min_pulse_width=.0006,
max_pulse_width=.0024))
serv_move(ServType.MOUSE, 0)
sleep(1)
serv_move(ServType.MOUSE, None)
#Noneを指定すると、サーボへのパルス指定をオフできて、余計な電流が流れない。
#ただし、再開するには、0を指定する必要あり。
gserv.append(
Servo(4, initial_value=0, min_pulse_width=.0006,
max_pulse_width=.0024))
serv_move(ServType.HEAD, 0)
sleep(1)
serv_move(ServType.HEAD, None)
#gserv.append(Servo(PIN_D, initial_value=0, min_pulse_width=.0006, max_pulse_width=.0024))
gserv.append(
Servo(PIN_B,
initial_value=0,
min_pulse_width=.0006,
max_pulse_width=.0024))
serv_move(ServType.BODY, 0)
sleep(1)
serv_move(ServType.BODY, None)
print("end serv init")
#tserv=Servo(PIN_A, min_pulse_width=.0006, max_pulse_width=.0024)
#gserv.append(Servo(PIN_C, min_pulse_width=.0006, max_pulse_width=.0024))
#serv_move(ServType.BODY, 0)
#sleep(2)
pass
def __init__(self, init_value=0.0):
self.steering = init_value
self.config_handler = ConfigHandler.get_instance()
# Get the config value, then re-write it to the config. We do this so in the case that there is no config file
# yet, it will create one with the default value
steering_pin = self.config_handler.get_config_value_or(
'steering_pin', Constants.GPIO_PIN_STEERING_SERVO)
self.config_handler.set_config_value('steering_pin', steering_pin)
self.servo = Servo(steering_pin)
logging.debug(f"Setting initial steering to {self.steering}")
def __init__(self,
sweep_delay_sec=3,
movement_speed=0.25,
motor_pin=19,
tick_interval_sec=0.45):
self.motor = Servo(motor_pin)
self.movementSpeed = movement_speed
self.motorPin = motor_pin
self.tickIntervalSec = tick_interval_sec
self.sweepDelaySec = sweep_delay_sec
# setup feedback thread
self.sweepTimeMarker = time.time()
self.sweepMode = False
self.delta = 0
self.thread = threading.Thread(target=self.motion_tick)
self.thread.setDaemon(True)
self.thread.setName("motion_handler_thread")
# Run feedback tick loop
self.isRunning = True
self.thread.start()
from gpiozero import Button
from gpiozero import Servo
from time import sleep
button = Button(16)
servo = Servo(14)
servo.min()
global barrier
barrier = "down"
def move():
if barrier == "down":
servo.max()
barrier = "up"
sleep(3)
else:
servo.min()
barrier = "down"
Sleep(3)
while True:
button.when_pressed = move
#!/usr/bin/env python3
"""Demonstrates simultaneous control of two servos on the hat.
One servo uses the simple default configuration, the other servo is tuned to
ensure the full range is reachable.
"""
from time import sleep
from gpiozero import Servo
from aiy.pins import PIN_A
from aiy.pins import PIN_B
# Create a default servo that will not be able to use quite the full range.
simple_servo = Servo(PIN_A)
# Create a servo with the custom values to give the full dynamic range.
tuned_servo = Servo(PIN_B, min_pulse_width=.0005, max_pulse_width=.0019)
# Move the Servos back and forth until the user terminates the example.
while True:
simple_servo.min()
tuned_servo.max()
sleep(1)
simple_servo.mid()
tuned_servo.mid()
sleep(1)
simple_servo.max()
tuned_servo.min()
sleep(1)
from gpiozero import Servo
from time import sleep
servo = Servo(14)
while True:
servo.min()
sleep(1)
servo.max()
sleep(1)
from gpiozero import Button
from gpiozero import Servo
from time import sleep
from signal import pause
button_up = Button(21)
button_down = Button(20)
servo = Servo(14)
servo.min()
while True:
button_up.when_pressed = servo.max()
button_down.when_pressed = servo.mix()
sleep(3)
