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]
