コード例 #1
0
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")
コード例 #2
0
class WeatherDashboard:

    servo_pin = 17
    led_pin = 14
    servoCorrection = 0.5
    maxPW = (2.0 + servoCorrection) / 1000
    minPW = (1.0 - servoCorrection) / 1000

    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)

    def move_servo(self, servo_position=0):
        self.servo.value = self.convert_percentage_to_integer(servo_position)

    def turnOffServo(self):
        sleep(2)
        self.servo.close()

    def set_led_status(self, led_status=0):

        if (led_status == 0):
            self.led.off()
        elif (led_status == 1):
            self.led.on()
        else:
            self.led.blink()

    def convert_percentage_to_integer(self, percentage_amount):
        #adjust for servos that turn counter clockwise by default
        adjusted_percentage_amount = 100 - percentage_amount
        return (adjusted_percentage_amount * 0.02) - 1
コード例 #3
0
from gpiozero import Servo
from time import sleep

servoPin = 17

servoCorrection = 0.5
maxPW = (2.0 + servoCorrection) / 1000
minPW = (1.0 - servoCorrection) / 1000

servo = Servo(servoPin, min_pulse_width=minPW, max_pulse_width=maxPW)

servo.min()
sleep(5)
servo.max()
sleep(5)
servo.min()
sleep(5)
servo.max()
sleep(5)
servo.min()
sleep(5)
servo.max()
sleep(5)

servo.close()
コード例 #4
0
class RoPiServo:

    # initialize
    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!")

    # clean all queues
    def cleanQueues(self):
        log.debug("Cleaning queues...")
        self.clearQueue(self.queue1)
        self.clearQueue(self.queue2)

    # clean queue
    def clearQueue(self, q):
        while not q.empty():
            q.get()

    # move servos
    def move_servo1(self, amount):
        self.queue1.put(amount)

    def move_servo2(self, amount):
        self.queue2.put(amount)

    # go UP
    def move_up(self):
        self.move_servo1(-0.1)

    # go DOWN
    def move_down(self):
        self.move_servo1(0.1)

    # go LEFT
    def move_left(self):
        self.move_servo2(0.1)

    # go RIGHT
    def move_right(self):
        self.move_servo2(-0.1)

    # reset position
    def reset(self):
        self.cleanQueues()
        self.servo1_position.value = 0.5
        self.servo1.mid()
        self.servo2_position.value = 0.5
        self.servo2.mid()

    # control process 1
    def P1(self):
        self.worker(self.servo1, self.servo1_position, self.queue1)

    # control process 2
    def P2(self):
        self.worker(self.servo2, self.servo2_position, self.queue2)

    # worker
    def worker(self, servo, position, queue):
        try:
            while True:

                if not queue.empty():
                    value = queue.get()
                    value = position.value + value
                    log.debug("Moving to: " + str(value))
                    if value > -1 and value < 1:
                        position.value = value
                        servo.value = value

        except KeyboardInterrupt:
            pass

    # terminate
    def terminate(self):
        log.debug("Servos termination...")
        self.process1.terminate()
        self.process2.terminate()
        self.reset()
        self.queue1.close()
        self.queue1.join_thread()
        self.queue2.close()
        self.queue2.join_thread()
        sleep(_conf['servo_reset_time'])
        self.servo1.close()
        self.servo2.close()