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)