def setupMotors(): # Sets up gpiozero Motor objects for pins specified in Pin setup base = gz.Motor(BASE_HI, BASE_LOW, pwm=True) elbow1 = gz.Motor(ELBOW1_HI, ELBOW1_LOW, pwm=True) elbow2 = gz.Motor(ELBOW2_HI, ELBOW2_LOW, pwm=True) claw = gz.Motor(CLAW_HI, CLAW_LOW, pwm=True) return base, elbow1, elbow2, claw
def __init__(self): # Controling with gpiozero source: https://gpiozero.readthedocs.io/en/stable/api_output.html self.move = {'forward': self.move_forward, 'backward': self.move_backward, 'right': self.turn_right, 'left': self.turn_left, 'stop turn': self.stop_turn, 'stop forward/backward': self.stop_forward_reverse} self.drive_motor = gpio.Motor(24,23) self.drive_motor_2 = gpio.Motor(16,20) self.pwm = PWM(0x6F) self.pwm.setPWMFreq(60) self.motor_angle = 370.0
def __init__(self, right_for, right_back, left_for, left_back, sensor=None): self.right = gpiozero.Motor(right_for, right_back) self.left = gpiozero.Motor(left_for, left_back) self.sensor = sensor self.speed = 1.0 self.powerRatio = 1.0
def __init__( self, contactSwitch=[2, 3], ledVolume=4, potVolume=17, motorDirection=[18, 23, 24], muteSwitch=25, ): self.contactSwitch = [ gpiozero.Button(contactSwitch[0], bounce_time=self.BOUNCE_TIME), gpiozero.Button(contactSwitch[1], bounce_time=self.BOUNCE_TIME) ] self.ledVolume = gpiozero.PWMLED(ledVolume) self.potVolume = gpiozero.MCP3008(channel=potVolume) # TODO program motorDirection[2] for PWM speed control # see L298N motor driver documentation for details self.motorDirection = [ gpiozero.Motor(motorDirection[0], motorDirection[1], pwm=False), gpiozero.PWMOutputDevice(motorDirection[2]) ] # This is a toggle switch not a button self.muteSwitch = gpiozero.Button(muteSwitch, bounce_time=self.BOUNCE_TIME) self.strikeState = 'idle'
def __init__(self, backmotor1, backmotor2, frontservo, frontservoReverser: bool, throttleMaxAfter: float): self.throttleMaxAfter = abs(throttleMaxAfter) self.frontservoReverser = frontservoReverser self.backmotor = gpiozero.Motor(forward=backmotor1, backward=backmotor2, pwm=True)
def __init__(self, pwmPin, forwardPin, backwardPin, encoderPin=None): ''' `forwardPin`: the motor rotate forward when this pin is on\n `backwardPin`: the motor rotate backward when this pin is on\n `encoderPin`: pin of motor's encoder phase A, default to None ''' self.pwmPin = gpiozero.OutputDevice(pwmPin) self.pwmPin.on() self.motor = gpiozero.Motor(forwardPin, backwardPin) if encoderPin is not None: self.encoderPin = gpiozero.InputDevice(encoderPin)
def __init__(self, gpio_interface, enable_pin, motor_pin_1, motor_pin_2, pwm_offset): self.gpio_interface = gpio_interface self.enable_pin = enable_pin self.motor_pin_1 = motor_pin_1 self.motor_pin_2 = motor_pin_2 self.pwm_offset = pwm_offset if self.gpio_interface == USE_RPI_GPIO: status.is_rpi_gpio_used = True RPi.GPIO.setmode(RPi.GPIO.BCM) RPi.GPIO.setwarnings(False) RPi.GPIO.setup(enable_pin , RPi.GPIO.OUT) RPi.GPIO.setup(motor_pin_1, RPi.GPIO.OUT) RPi.GPIO.setup(motor_pin_2, RPi.GPIO.OUT) RPi.GPIO.output(motor_pin_1, RPi.GPIO.LOW) RPi.GPIO.output(motor_pin_2, RPi.GPIO.LOW) RPi.GPIO.output(enable_pin , RPi.GPIO.LOW) self.pwm = RPi.GPIO.PWM(enable_pin, PWM_FREQUENCY) self.pwm.start(DC_MOTOR_PWM_MIN) elif self.gpio_interface == USE_RPI_ZERO: self.motor = gpiozero.Motor(motor_pin_2, motor_pin_1, enable_pin, pwm = True) elif self.gpio_interface == USE_PI_GPIO: if not utils.is_process_running('pigpiod'): log(ERROR, 'DcMotor: pigpiod process not started') os._exit(3) self.pigpio = pigpio.pi() self.pigpio.set_mode(enable_pin , pigpio.OUTPUT) self.pigpio.set_mode(motor_pin_1, pigpio.OUTPUT) self.pigpio.set_mode(motor_pin_2, pigpio.OUTPUT) self.pigpio.write(enable_pin , 0) self.pigpio.write(motor_pin_1, 0) self.pigpio.write(motor_pin_2, 0) self.pigpio.set_PWM_range (enable_pin, DC_MOTOR_PWM_MAX) self.pigpio.set_PWM_frequency(enable_pin, PWM_FREQUENCY ) self.speed = DC_MOTOR_PWM_MIN self.direction = STOPPED
def __init__(self, gpio_interface, enable_pin, motor_pin_1, motor_pin_2, pwm_offset): self.gpio_interface = gpio_interface self.enable_pin = enable_pin self.motor_pin_1 = motor_pin_1 self.motor_pin_2 = motor_pin_2 self.pwm_offset = pwm_offset if self.gpio_interface == const.USE_RPI_GPIO: RPi.GPIO.setmode(RPi.GPIO.BCM) RPi.GPIO.setwarnings(False) RPi.GPIO.setup(enable_pin, RPi.GPIO.OUT) RPi.GPIO.setup(motor_pin_1, RPi.GPIO.OUT) RPi.GPIO.setup(motor_pin_2, RPi.GPIO.OUT) RPi.GPIO.output(motor_pin_1, RPi.GPIO.LOW) RPi.GPIO.output(motor_pin_2, RPi.GPIO.LOW) RPi.GPIO.output(enable_pin, RPi.GPIO.LOW) self.pwm = RPi.GPIO.PWM(enable_pin, PWM_FREQUENCY) self.pwm.start(PWM_MIN) elif self.gpio_interface == const.USE_RPI_ZERO: self.motor = gpiozero.Motor(motor_pin_2, motor_pin_1, enable_pin, pwm=True) elif self.gpio_interface == const.USE_PI_GPIO: self.pigpio = pigpio.pi() self.pigpio.set_mode(enable_pin, pigpio.OUTPUT) self.pigpio.set_mode(motor_pin_1, pigpio.OUTPUT) self.pigpio.set_mode(motor_pin_2, pigpio.OUTPUT) self.pigpio.write(enable_pin, 0) self.pigpio.write(motor_pin_1, 0) self.pigpio.write(motor_pin_2, 0) self.pigpio.set_PWM_range(enable_pin, PWM_MAX) self.pigpio.set_PWM_frequency(enable_pin, PWM_FREQUENCY) self.speed = PWM_MIN self.direction = STOPPED
def __init__(self, a, b, ena): self.motor = gpi.Motor(a, b, enable=ena)
balloons = data[0:2], data[2:4], data[4:6] balloons = [(p, h) if h else None for p, h in balloons] except zmq.error.Again: balloons = None return balloons # set up GPIO hardware PIEZOPIN = 4 BUTTONPIN = 25 LEDPIN = 22 LED_RED_PIN = 23 buzzer = gpz.TonalBuzzer(PIEZOPIN) led = gpz.LED(LEDPIN) led_red = gpz.LED(LED_RED_PIN) rmotor = gpz.Motor(20, 16, 12, pwm=True) lmotor = gpz.Motor(26, 19, 5, pwm=True) lsensor = gpz.DistanceSensor(21, 24) # echo, trigger rsensor = gpz.DistanceSensor(13, 27) lsensor._queue.stop() # stop the auto-checking rsensor._queue.stop() # stop the auto-checking button = gpz.Button(BUTTONPIN, bounce_time=0.2) def beep(length=0.1, freq=500): buzzer.play(freq) time.sleep(length) buzzer.stop() def read_sensors():
def __init__(self): self.main = gpio.Motor(**MAIN_MOTOR_SETTINGS) self.brb = gpio.Button(**BIG_RED_BUTTON_SETTINGS) self.aux = pantilthat.PanTilt()
import gpiozero as gpio # Sends PWM signal on the MOTOR_X_FORWARD_PIN (value>0) or the MOTOR_X_BACKWARD_PIN (value<0) # Invalid for our use (should send PWM through MOTOR_X_ENABLE_PIN) MOTOR_R_FORWARD_PIN = 17 MOTOR_R_BACKWARD_PIN = 18 MOTOR_R_ENABLE_PIN = 27 MOTOR_L_FORWARD_PIN = 22 MOTOR_L_BACKWARD_PIN = 23 MOTOR_L_ENABLE_PIN = 24 right_motor = gpio.Motor(forward=MOTOR_R_FORWARD_PIN, backward=MOTOR_R_BACKWARD_PIN, enable=MOTOR_R_ENABLE_PIN) left_motor = gpio.Motor(forward=MOTOR_L_FORWARD_PIN, backward=MOTOR_L_BACKWARD_PIN, enable=MOTOR_L_ENABLE_PIN) while True: r_value = float(input("Right motor value: ")) l_value = float(input("Left motor value: ")) right_motor.value = r_value left_motor.value = l_value print("\n") cmd = input("Enter a command (blank to do nothing): ") if cmd == "stop": right_motor.stop() left_motor.stop()
def setupMotors(): base = gz.Motor(BASE_HI, BASE_LOW, pwm=True) elbow1 = gz.Motor(ELBOW1_HI, ELBOW1_LOW, pwm=True) elbow2 = gz.Motor(ELBOW2_HI, ELBOW2_LOW, pwm=True) claw = gz.Motor(CLAW_HI, CLAW_LOW, pwm=True) return base, elbow1, elbow2, claw
import gpiozero from time import sleep print "creating motor objects" # back motors br = gpiozero.Motor(22, 27) # back right bl = gpiozero.Motor(23, 24) # back left print "created back motor objects" # front motors fr = gpiozero.Motor(12,16) # front right fl = gpiozero.Motor(6,5) # front left print "created front motor objects" print "finish"
sumRightAlpha = sumRightAlpha + alpha rightAlpha = sumRightAlpha / (len(rightAlphaV)) else: rightAlpha = 0 alphaError = rightAlpha + leftAlpha print('Right alpha is: %f' % rightAlpha) print('Left alpha is: %f' % leftAlpha) print('Alpha error is: %f' % alphaError) return alphaError #Main function #Motors setup motorR = gpio.Motor(18, 23, 1) motorL = gpio.Motor(17, 22, 1) #Camera setup cam = cv2.VideoCapture(0) while (True): #Robot starts by viewing what's ahead: ret, frame = cam.read() blackwhite = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) dummy, threshold = cv2.threshold(blackwhite, 95, 255, cv2.THRESH_BINARY) cannyT = cv2.Canny(threshold, 100, 120) #calculate and apply ROI roiT = cannyT[350:405, 0:640] lines = cv2.HoughLinesP(roiT, 2, np.pi / 180, 20, 20, 2)
import time import gpiozero import drivetrain drivetrain = drivetrain.Drivetrain([gpiozero.Motor(22, 27, 17)], [gpiozero.Motor(3, 2, 4)]) while True: drivetrain.setBothOutputs(1, 1) time.sleep(2) drivetrain.setBothOutputs(-1, -1) time.sleep(2)
import gpiozero as gz import time #port 1 relay = gz.Motor(24, 27) relay_enable = gz.OutputDevice(5, initial_value=1) #port 2 prt2 = gz.Motor(6, 22) prt2_enable = gz.OutputDevice(17, initial_value=1) #port 3 prt3 = gz.Motor(23, 16) prt3_enable = gz.OutputDevice(12, initial_value=1) #port 4 prt4 = gz.Motor(13, 18) prt4_enable = gz.OutputDevice(25, initial_value=1) def on(relay): relay.forward() def off(relay): relay.stop() def procedure(relay): print("Starting...") on(relay)
import gpiozero from flask import Flask, render_template, request from time import sleep app = Flask(__name__) devices = { 'motor1': { 'object': gpiozero.Motor(22, 27), 'name': 'motor1', 'state': 'stopped' }, 'motor2': { 'object': gpiozero.Motor(23, 24), 'name': 'motor2', 'state': 'stopped' }, #'servo' : {'object' : gpiozero.Servo(18), 'name': 'servo', 'state' : 'stopped' } , 'led': { 'object': gpiozero.DigitalOutputDevice(25), 'name': 'led', 'state': 'off' } } @app.route("/") def main(): # Put data in templateData templateData = {'devices': devices} # Pass the template data into the template main.html and return it to the user return render_template('main.html', **templateData)
import gpiozero as gz import time motor = gz.Motor(11, 13) motor.forward() time.sleep(1) motor.stop()
import imutils import time #import serial #import RPi.GPIO as GPIO #import signal #import atexit import gpiozero as gz servopin1 = 23 servopin2 = 24 pi = pigpio.pi() pi.set_mode(servopin1, pigpio.OUTPUT) pi.set_mode(servopin2, pigpio.OUTPUT) pi.set_PWM_frequency(servopin1, 50) pi.set_PWM_frequency(servopin2, 50) motor_r = gz.Motor(17, 18) motor_l = gz.Motor(27, 22) counter = 0 #kp=float(0.5/150) ball_x = 0 plus1 = 1500 plus2 = 1200 search = 1 search1 = 1 flag = 0 target1 = 500 target2 = 500 camera = cv2.VideoCapture(0) boundaries = [(
#By: Noel Caverly import gpiozero #from RPIO import PWM import time #Constants FORWARD_PIN = 18 #12 is linked BACKWARD_PIN = 19 #13 is linked PEDALFW_PIN = 14 PEDALBW_PIN = 15 WARNING_PIN = 6 #INITIALIZE #PWM switch = gpiozero.Motor(FORWARD_PIN, BACKWARD_PIN) pedal = gpiozero.Motor(PEDALFW_PIN, PEDALBW_PIN) warningLED = gpiozero.LED(WARNING_PIN) #TESTING switch.forward() print("going forward") time.sleep(10) switch.backward() print("backwards") time.sleep(10) switch.stop() print("complete")
class Robot(): # back motors br = gpiozero.Motor(22, 27) # back right, connected to rpi BCM 27 and 22 bl = gpiozero.Motor(23, 24) # back left, connected to rpi BCM 23 and 24 # front motors fr = gpiozero.Motor(12, 16) # front right, connected to rpi BCM 12 and 16 fl = gpiozero.Motor(6, 5) # front left, connected to rpi BCM 6 and 5 opt = gpiozero.Button( 17 ) # opt is the optocoupler that is measuring encoder in back-left wheel, the encoder has 20 holes counter = 0 # variable needed to count up to the 20 holes in the step function print "created motors" def __init__(self): print "created class" def forward(self, speed=1): """ """ print "forward ", speed self.br.forward(speed) self.bl.forward(speed) self.fr.forward(speed) self.fl.forward(speed) def backward(self, speed=1): print "backward ", speed self.br.backward(speed) self.bl.backward(speed) self.fr.backward(speed) self.fl.backward(speed) def stop(self): print "stop" self.br.stop() self.bl.stop() self.fr.stop() self.fl.stop() def right(self, degrees=90): self.counter = 0 if degrees == 90: limit = 12 elif degrees == 180: limit = 24 elif degrees == 270: limit = 36 elif degrees == 360: limit = 48 else: limit = 12 def count_one(): self.counter = self.counter + 1 print " counter is ", self.counter if self.counter >= limit: # hardcoded number based on my current system self.stop() self.opt.when_pressed = count_one # Turning Right Movement self.fl.forward(1) self.bl.forward(1) self.fr.backward(1) self.br.backward(1) """ while self.counter < 10: sleep(1.0/1000000.0) self.stop() """ def left(self, degrees=90): self.counter = 0 if degrees == 90: limit = 12 elif degrees == 180: limit = 24 elif degrees == 270: limit = 36 elif degrees == 360: limit = 48 else: limit = 12 def count_one(): self.counter = self.counter + 1 print " counter is ", self.counter if self.counter >= limit: # hardcoded number based on my current system self.stop() self.opt.when_pressed = count_one self.fl.backward(1) self.bl.backward(1) self.fr.forward(1) self.br.forward(1) #sleep(1) #self.stop() def step(self, direction): self.counter = 0 def count_one(): self.counter = self.counter + 1 print " counter is ", self.counter, " - ", int(round(time() * 1000)) if self.counter >= 20: self.stop() self.opt.when_pressed = count_one if direction == "f": self.forward(1) elif direction == "b": self.backward(1) else: self.forward( 1 ) # for now the default is forward, this function may throw an error later """ while self.counter < 20: #sleep(1.0/1000000000.0) pass self.stop() """ def steps_forward(self, num_steps=1): for i in range(0, num_steps): self.step("f") def steps_backward(self, num_steps=1): for i in range(0, num_steps): self.step("b")
import gpiozero from time import sleep print "Declare motors" # Declaring motors on GPIOs 22, 27, 23 and 24. These are for moving f/b. motor1 = gpiozero.Motor(22, 27) motor2 = gpiozero.Motor(23, 24) # Declaring servomotor on GPIO 18. This will give direction. servo = gpiozero.Servo(18) print "First routine" # First routine. Robot move forward. servo.mid() motor1.forward(1) # Max speed motor2.forward(1) # Max speed print "About to sleep" sleep(5) print "Stopping motors" motor1.stop() motor2.stop() print "Finish"
# right speed pulse counter event def ev_right_count(): global counter_right counter_right += 1 # left speed pulse counter event def ev_left_count(): global counter_left counter_left += 1 # Motor gpio setup (forward pin, backward pin) right_motors = gpio.Motor(17, 27) left_motors = gpio.Motor(24, 23) # speed encoder sensor setup right_speed = gpio.DigitalInputDevice(25) left_speed = gpio.DigitalInputDevice(22) right_speed.when_activated = ev_right_count # event left_speed.when_activated = ev_left_count # event def counter_reset(): global counter_right, counter_left counter_right = 0 counter_left = 0
import gpiozero import numpy as np import cwiid steering = gpiozero.AngularServo(18, min_angle=-60, max_angle=60) drive = gpiozero.Motor(17, 21, enable=None, pwm=True, pin_factory=None) wii = cwiid.Wiimote() wii.rpt_mode = cwiid.RPT_BTN | cwiid.RPT_ACC def steer(angle): if np.absolute(angle) < 5: angle = 0 steering.angle = angle def drive(speed): if np.absolute(speed) < 0.15: drive.stop() elif speed < 0: drive.backward(abs(speed)) else: drive.forward(speed) while True: steer(np.clip(np.interp(wii.state["acc"][cwiid.X] - 95), 0, 50, -50, 50), -60, 60) drive(np.clip(np.interp(wii.state["acc"][cwiid.Y] - 95), 0, 50, -1, 1), -1, 1)
import json import gpiozero import time from gpiozero.pins.pigpio import PiGPIOFactory from gpiozero import Servo from flask import Flask, render_template, request, abort from flask_restful import abort, Api factory = PiGPIOFactory() # Define Motor Configuration # Used for controlling forwards and backwards. motor_1 = gpiozero.Motor(15, 14,pwm=False,pin_factory=factory) # Used for controlling direction. motor_2 = gpiozero.Motor(23, 24,pwm=False, pin_factory=factory) #Define servo servoPin = 17 #GPIO servo = Servo(servoPin, max_pulse_width=1.9/1000, min_pulse_width=0.4/1000,pin_factory=factory) speed = 0.5 pwm = gpiozero.PWMOutputDevice(3,initial_value=speed, pin_factory=factory) # Setup the server. app = Flask(__name__) api = Api(app) speed = 0.5 # Application routing.
def __init__(self): self._motor_front_left = gpiozero.Motor(forward=6, backward=5) self._motor_front_right = gpiozero.Motor(forward=12, backward=13) self._motor_back_left = gpiozero.Motor(forward=16, backward=19) self._motor_back_right = gpiozero.Motor(forward=20, backward=26) self._horn = gpiozero.LED(4)
import time import gpiozero as gp l = gp.Motor(6, 13) r = gp.Motor(2, 3) pan = gp.AngularServo(12) tilt = gp.AngularServo(8) time.sleep(10) try: l.forward() r.forward() time.sleep(2) l.backward() time.sleep(0.5) l.forward() time.sleep(1) r.backward() time.sleep(0.5) r.forward() time.sleep(1) finally: r.stop() l.stop() pan.angle = 0 pan.detach() tilt.angle = 0 tilt.detach()
Ki = 0.1 MOTOR_L = 80.0 MOTOR_R = 80.0 AUX1 = 0 AUX2 = 0 pin1 = 4 pin2 = 17 pin3 = 2 pin4 = 3 frequency = 20 left_motor = gpiozero.Motor("BOARD12", "BOARD13", None, True, None) right_motor = gpiozero.Motor("BOARD8", "BOARD10", None, True, None) GPIO.setup(pin1, GPIO.IN) GPIO.setup(pin2, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) GPIO.setup(pin3, GPIO.IN) GPIO.setup(pin4, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) def ei_l(pin4): global counter_L if (GPIO.input(pin3) == True): counter_L -= 1 else: counter_L += 1
import gpiozero as gpio import sys import time motors = [ gpio.Motor(17, 18), gpio.Motor(22, 23), gpio.Motor(9, 25), gpio.Motor(11, 8) ] clk = 0.5 ''' instructions: stopall closeall setmotor m1_speed m2_speed m3_speed m4_speed m5_speed stopmotor m ''' try: while True: inp = sys.stdin.readline() tokens = inp.split() if len(tokens) <= 0: continue else: inst_name = tokens[0]