class Control:
''' rover control class '''
def __init__(self, left=LEFT, right=RIGHT):
''' Constructor '''
self.drive = Robot(left=left, right=right)
def off(self):
''' Stop all motors '''
self.drive.stop()
def cmd(self, char, step=STEP):
''' Perform required command '''
if char == 'f':
self.drive.forward(SPEED)
time.sleep(step)
elif char == 'b':
self.drive.backward(SPEED)
time.sleep(step)
elif char == 'r':
self.drive.right(SPEED)
time.sleep(step)
elif char == 'l':
self.drive.left(SPEED)
time.sleep(step)
elif char == '#':
time.sleep(step)
class Jeeno:
def __init__(self):
self.front_sensor = DistanceSensor(echo = 22, trigger = 27)
#self.back_sensor = DistanceSensor(echo = , trigger = )
self.robot = Robot(left=(6,12), right=(5,13))
self.move()
def move(self):
self.front_sensor.when_out_of_range = self.robot.forward
self.front_sensor.when_in_range = self.turn
def turn(self):
self.robot.stop()
if choice(['L','R']) == 'L':
self.left()
else:
self.right()
def left(self):
self.robot.forward(curve_left=1)
sleep(1)
self.robot.stop()
def right(self):
self.robot.forward(curve_right=1)
sleep(1)
self.robot.stop()
def __init__(self):
#movement variables
self.legs = Robot(left=(5, 6), right=(17, 27))
self.turning_right = False
self.turning_left = False
self.moving_forward = False
self.moving_backward = False
#used when preforming specific actions for fleeing Darth Vader
self.turning_around = False
self.time_turning_around = 0
self.running_away = False
self.time_running_away = 0
self.fleeing = False
#used to blink red-blue light
self.light = RGBLED(red=16, green=20, blue=21)
self.light.color = (1, 0, 0)
self.red = True
self.time_since_last_blink = 0
#used to make random movements
self.time_stopped = 0
self.time_moving = 0
self.moving = False
#used for reaction to characters
self.seeing_Leia = False
self.seen_Leia = False
self.time_seeing_Leia = 0
self.seeing_Obiwan = False
self.time_seeing_Obiwan = 0
self.seeing_Vader = False
self.time_seeing_Vader = 0
def __init__(self, level='lvl0'):
#instantiating all the motors and sensors on the bot
self.robot = Robot(left=MOTOR_L, right=MOTOR_R)
self.sonic = DistanceSensor(echo=SONIC_ECHO, trigger=SONIC_TRIG)
self.ir_l = MCP3008(IR_L)
self.ir_r = MCP3008(IR_R)
self.button = MCP3008(BTN)
self.bz = TonalBuzzer(BZ)
self.led = RGBLED(R, G, B)
#creating custom variables
self.speed = self.get_speed(level)
def __init__(self):
GPIO.cleanup()
self.__leftencoder = Encoder(21)
self.__rightencoder = Encoder(27)
self.__robot = Robot(left=(23, 24), right=(26, 22))
self.__en1 = 12
self.__en2 = 13
GPIO.setmode(GPIO.BCM)
GPIO.setup(self.__en1, GPIO.OUT)
GPIO.output(self.__en1, GPIO.HIGH)
GPIO.setup(self.__en2, GPIO.OUT)
GPIO.output(self.__en2, GPIO.HIGH)
def __init__(self):
#movement variables
self.legs = Robot(left=(5, 6), right=(17, 27))
self.turning_right = False
self.turning_left = False
self.moving_forward = False
self.moving_backward = False
#light variables
#used to blink red-blue light
self.light = RGBLED(red=16, green=20, blue=21)
self.light.color = (1, 0, 0)
self.red = True
self.time_since_last_blink = 0
def __init__(self):
window = np.zeros((100,100)) #initialising a black 100x100 window for using escape to quit
self.colour = {'red':0,'green':0,'blue':0,-1:0} #control dictionary for logic
left = (4,14) #left wheel gpio pins
right = (17,18) #right wheel gpio pins
self.robot = Robot(left,right) #robot initialisation class call
self.cap = cv2.VideoCapture(0) #recording video from camera 0 (i.e. the camera on rpi)
while(True):
ret, image = self.cap.read() #read from camera
if cv2.waitKey(1) != 27 :
cv2.imshow('window',window) #show the window previously made
self.botmove(image) #main bot moving method call
else:
break #exit if escape key is pressed
class RobotWheels:
robot = Robot(left=(5, 6), right=(22, 27))
def __init__(self):
pass
def move_forward(self):
self.robot.forward(0.2)
def move_backwards(self):
self.robot.backward(0.2)
def turn_right(self):
self.robot.right(0.2)
def turn_left(self):
self.robot.left(0.2)
def dance(self):
self.move_forward()
sleep(0.5)
self.stop()
self.move_backwards()
sleep(0.5)
self.stop()
self.turn_right()
sleep(0.5)
self.stop()
self.turn_left()
sleep(0.5)
self.stop()
def stop(self):
self.robot.stop()
def wheel_action(msg):
data = json.loads(msg["data"])
duration = data["duration"]
speed = data.get("speed", 1)
direction = data["direction"]
robot = Robot(left=config.WHEEL_LEFT, right=config.WHEEL_RIGHT)
if direction in "left right forward backward".split():
getattr(robot, direction)(speed)
time.sleep(duration)
def main(): """ メイン関数 """ # 接続ピン PIN_AIN1 = 6 PIN_AIN2 = 5 PIN_BIN1 = 26 PIN_BIN2 = 27 # 左右モーター設定(PWM) motors = Robot(left=(PIN_AIN1,PIN_AIN2),right=(PIN_BIN1,PIN_BIN2),pwm=True) # 0.1秒毎周期30（約3秒）のSIN値の信号源 srcleft = post_delayed(sin_values(period=30),0.1) # 0.1秒毎周期30（約3秒）のCOS値の信号源 srcright = post_delayed(cos_values(period=30),0.1) # 左右モータに信号源を接続 motors.source = zip(srcleft,srcright) # 停止(Ctr+c)まで待機 pause()
def main():
""" メイン関数 """
# 接続ピン
PIN_AIN1 = 6
PIN_AIN2 = 5
PIN_BIN1 = 26
PIN_BIN2 = 27
# 左右モーター設定(PWM)
motors = Robot(left=(PIN_AIN1, PIN_AIN2),
right=(PIN_BIN1, PIN_BIN2),
pwm=True)
# 1秒毎の正負パルス値の信号源
dirleft = post_delayed(scaled(alternating_values(True), -1, 1), 1)
dirright = post_delayed(scaled(alternating_values(False), -1, 1), 1)
# 左右モーターに信号源を接続
motors.source = zip(dirleft, dirright)
# 停止(Ctrl+c)まで待機
pause()
def __init__(self):
self._commands = [
0, # forward
0, # backward
0, # left
0, # right
0, # turbo
]
self._robot = Robot(left=(_LEFT_MOTOR_NEG_PIN,
_LEFT_MOTOR_POS_PIN),
right=(_RIGHT_MOTOR_POS_PIN,
_RIGHT_MOTOR_NEG_PIN))
# A Driver exposes a number of multiprocess Events objects that
# external objects can use to signal the need of an emergency stops.
# It is up to the caller to clear the safety stop Event.
self._safety_stop_event = mp.Event()
self._safety_stop_forward_event = mp.Event()
self._safety_stop_backward_event = mp.Event()
_logger.debug('{} initialized'.format(self.__class__.__name__))
def main():
""" メイン関数 """
# モータードライバ接続ピン
PIN_AIN1 = 6
PIN_AIN2 = 5
PIN_BIN1 = 26
PIN_BIN2 = 27
# A/D変換チャネル数
NUM_CH = 4
# 左右モーター設定(PWM)
motors = Robot(left=(PIN_AIN1,PIN_AIN2), \
right=(PIN_BIN1,PIN_BIN2), \
pwm=True)
# フォトリフレクタ（複数）設定（A/D変換）
photorefs = [MCP3004(channel=idx) for idx in range(NUM_CH)]
# ライントレース処理
motors.source = line_follow(photorefs)
# 停止(Ctr+c)まで待機
pause()
class MadmaxWheelbase():
def __init__(self):
self.wheel_base = Robot(
left=(sets['motor_in1_left'],sets['motor_in2_left'],sets['motor_enabler_left']),
right=(sets['motor_in3_right'],sets['motor_in4_right'],sets['motor_enabler_right']))
self.speed = 0.3
def forward(self, speed = None):
if speed:
self.speed = speed
self.wheel_base.forward(self.speed)
def backward(self, speed = None):
if speed:
self.speed = speed
self.wheel_base.backward(self.speed)
def stop(self):
self.wheel_base.stop()
def set_speed(self, speed):
self.speed = speed
from gpiozero import DistanceSensor, Robot
from time import sleep
robot = Robot(left=(7, 8), right=(9, 10))
#robot.forward(0.3)
def go_forward(n_seconds):
robot.forward(0.5)
sleep(n_seconds)
robot.stop()
def go_left(n_seconds):
robot.left(0.5)
sleep(n_seconds)
robot.stop()
def go_forward_cautious():
sensor = DistanceSensor(echo=18, trigger=17)
robot.forward(0.3)
while True:
##print('Distance: ', sensor.distance)
if sensor.distance < 0.1:
##print("less than 0.1")
robot.forward(0.5)
if sensor.distance < 0.5:
print("less than 0.05")
robot.forward(0.025)
if sensor.distance < 0.025:
print("About to stop")
import signal
from xbox360controller import Xbox360Controller
from gpiozero import Robot
robot = Robot(left=(19,26),right=(20,21))
def on_button_pressed(button):
print('Button {0} was pressed'.format(button.name))
if button.name == "button_a":
print('[Robot goes Forward]')
robot.forward()
elif button.name == "button_b":
print('[Robot goes Backward]')
robot.backward()
elif button.name == "button_trigger_l":
print('[Robot goes Left]')
robot.left()
elif button.name == "button_trigger_r":
print('[Robot goes Right]')
robot.right()
def on_button_released(button):
print('Button {0} was released'.format(button.name))
print('[Robot was Stoped]')
robot.stop()
def on_axis_moved(axis):
print('Axis {0} moved to {1} {2}'.format(axis.name,axis.x,axis.y))
from gpiozero import Robot robot = Robot(left=(5,6), right=(13,19))
from gpiozero import Robot, DistanceSensor
from time import sleep
import CERCBot
import random
burt_the_robot = Robot(left=(8, 7), right=(21, 20))
left_echo_pin = 14
left_trigger_pin = 15
centre_echo_pin = 17
centre_trigger_pin = 4
right_echo_pin = 23
right_trigger_pin = 18
threshold = 20
threshold2 = 25
dead_end = 0
fast = 0.7
slow = 0.6
def go_forwards(speed):
burt_the_robot.forward(speed)
print("Going forwards")
def go_backwards(speed):
burt_the_robot.backward(speed)
print("Going backwards")
def setup(self):
self.robot = Robot(left=left_wheel, right=right_wheel)
dotbot_ros.Subscriber("cmd_vel", Twist, self.on_cmd_vel)
from gpiozero import Robot
from time import sleep
robot = Robot(left=(4,14), right=(17,18))
for i in range(4):
robot.forward()
sleep(10)
robot.right()
sleep(1)
#!/usr/bin/python3 import time from gpiozero import Robot import RPi.GPIO as GPIO robot = Robot(left=(17, 18), right=(22, 23)) # Ultrasonic range sensor (pins) pin_trig = 13 pin_echo = 26 ## These may need to be adjusted depending upon the size of the robot and the speed of the motors # minimum distance before we turn in cm min_distance = 13 # speed when moving forward (between 0 and 1) speed_forward = 0.8 # speed when turning (between 0 and 1) speed_turn = 0.6 # Setup GPIO input/output and disable warnings GPIO.setmode(GPIO.BCM) GPIO.setwarnings (False) GPIO.setup(pin_trig, GPIO.OUT) GPIO.setup(pin_echo, GPIO.IN) # Set ultrasonic sensor off and wait to settle GPIO.output(pin_trig, 0) time.sleep(0.5) while True:
high = bus.read_byte_data(d_address, adr+1)
val=(high<<8)+low
if(val > 32768):
val = val - 65536
return val
magneto_start()
in1=17
in2=27
in3=23
in4=24
en1=PWMOutputDevice(18)
en2=PWMOutputDevice(19)
GPIO.setmode(GPIO.BCM)
robot = Robot((in1, in2), (in3, in4))
speed=1
en1.value=speed
en2.value=speed
#def user_input():
# while 1:
# global speed
# i=input("Please enter a number: ")
# print ('wrong input')
# if i== 'w':
# robot.forward()
# elif i=='s':
# robot.backward()
# elif i=='a':
cl = 0.1
def inrange():
global cl
robot.stop()
robot.backward(curve_right=0.5)
sleep(2)
#robot.right()
#robot.reverse()
sleep(1)
robot.forward(curve_right=cl)
def outrange():
global cl
robot.stop()
robot.forward(curve_right=cl)
sensor = DistanceSensor(echo=20,
trigger=21,
max_distance=1,
threshold_distance=0.15)
sensor.when_in_range = inrange
sensor.when_out_of_range = outrange
#robot = Robot(left=(26, 19), right=(6, 13))
robot = Robot(right=(19, 26), left=(6, 13))
robot.forward(curve_right=cl)
pause()
from gpiozero import Robot, MCP3008 from gpiozero.tools import scaled from signal import pause robot = Robot(left=(4, 14), right=(17, 18)) left = MCP3008(0) right = MCP3008(1) robot.source = zip(scaled(left.values, -1, 1), scaled(right.values, -1, 1)) pause()
from gpiozero import Robot
from bluedot import BlueDot
from signal import pause
def pos_to_values(x, y):
left = y if x > 0 else y + x
right = y if x < 0 else y - x
return (clamped(left), clamped(right))
def clamped(v):
return max(-1, min(1, v))
def drive():
while True:
if bd.is_pressed:
x, y = bd.position.x, bd.position.y
yield pos_to_values(x, y)
else:
yield (0, 0)
robot = Robot(left=(4, 14), right=(17, 18))
bd = BlueDot()
robot.source = drive()
pause()
#!/usr/bin/env python3
from gpiozero import Robot, LED, Button
import time
robot = Robot((9, 10), (8, 7)) # Left, Right
trig = LED(17) # Ultrasonic Distance Trigger
echo = Button(18) # Ultrasonic Distance Echo
# Return the distance from the sensor at the front to any obstruction.
def distance():
global trig, echo
trig.off()
time.sleep(0.01)
trig.on()
time.sleep(0.00001)
trig.off()
echo.wait_for_release()
startTime = time.time()
echo.wait_for_press(0.1)
elapsed = time.time() - startTime
distance = elapsed * 17163
if elapsed > 0.04:
print("Too close")
from gpiozero import Robot
from time import sleep
robot = Robot(left=(4, 14), right=(17, 18))
for i in range(4):
robot.forward()
sleep(10)
robot.right()
sleep(1)
import curses
from gpiozero import Robot
import sys
robot = Robot(left=(27, 24), right=(16, 23))
actions = {
curses.KEY_UP: robot.forward,
curses.KEY_DOWN: robot.backward,
curses.KEY_LEFT: robot.left,
curses.KEY_RIGHT: robot.right,
}
def main(stdscr):
nextKey = None
while True:
curses.halfdelay(1)
if nextKey is None:
key = stdscr.getch()
else:
key = nextKey
nextKey = None
if key != -1:
curses.halfdelay(3)
action = actions.get(key)
if action is not None:
action()
nextKey = key
while nextKey == key:
nextKey = stdscr.getch()
def getchar():
fd = sys.stdin.fileno()
old_setting = termios.tcgetattr(fd)
ch=0
try:
tty.setraw(sys.stdin.fileno())
ch=sys.stdin.read(1)
finally:
termios.tcsetattr(fd, termios.TCSADRAIN,old_setting)
return ch
try:
us = UltraSound(6,12)
robot = Robot(left=(23,22),right=(17,18))
speed=1.0
while True:
obstdistance = us.measure()
print(obstdistance)
if obstdistance < 15:
speed=0.5
robot.stop()
robot.right(speed)
time.sleep(0.01)
robot.reverse(speed)
time.sleep(2)
speed =1.0
robot.forward(speed)
from time import sleep
from gpiozero import Robot
tiempo = 5
robot = Robot(left=(7, 8), right=(9, 10))
while True:
robot.forward()
sleep(tiempo)
robot.stop()
robot.right()
sleep(tiempo)
robot.stop()
robot.left()
sleep(tiempo)
robot.stop()
robot.backward()
sleep(tiempo)
robot.stop()
from gpiozero import Robot, MCP3008 from signal import pause robot = Robot(left=(4, 14), right=(17, 18)) left = MCP3008(0) right = MCP3008(1) robot.source = zip(left.values, right.values) pause()
from gpiozero import Robot, Motor, MotionSensor from signal import pause robot = Robot(left=Motor(4, 14), right=Motor(17, 18)) pir = MotionSensor(5) pir.when_motion = robot.forward pir.when_no_motion = robot.stop pause()
from bluedot import BlueDot
from gpiozero import Robot
bd = BlueDot()
robot = Robot(left=(8, 7), right=(10, 9))
def move(pos):
if pos.top:
robot.forward()
elif pos.bottom:
robot.backward()
elif pos.right:
robot.right()
elif pos.left:
robot.left()
def stop():
robot.stop()
bd.when_pressed = move
bd.when_moved = move
bd.when_released = stop
from gpiozero import DistanceSensor from gpiozero import Robot from time import sleep from signal import pause robot = Robot(right=(19, 26), left=(6, 13)) robot.forward() sleep(5) robot.right(0.5) sleep(5)
from time import sleep
from gpiozero import Robot
from bluedot import BlueDot
from signal import pause
robby = Robot(left=(9, 10), right=(8, 7))
tleft = 0.85
tright = 0.85
def line():
robby.forward(1)
sleep(1.15)
robby.left(1)
sleep(tleft)
robby.forward(1)
sleep(2)
robby.right(1)
sleep(tright)
robby.forward(0.4)
sleep(0.5)
robby.left(1)
sleep(tleft)
robby.forward(1)
sleep(0.9)
robby.stop()
def remoteAndroid():
bd = BlueDot(
#!/usr/bin/python
import sys, tty, termios
import picamera, time
import cwiid
from gpiozero import Robot
robot = Robot(left=(17, 18), right=(22, 23))
camera_enable = False
try:
camera = picamera.PiCamera()
camera.hflip=True
camera.vflip=True
camera_enable=True
except:
print ("Camera not found - disabled");
photo_dir = "/home/pi/photos"
# delay between button presses
delay = 0.2
current_direction = "stop"
# speed is as a percentage (ie. 100 = top speed)
# start speed is 50% which is fairly slow on a flat surface
speed = 100
print ("Press 1 + 2 on the Wii Remote")
time.sleep(1)
# Keep trying to connect to the remote
while True:
from gpiozero import Robot, DistanceSensor from signal import pause sensor = DistanceSensor(23, 24, max_distance=1, threshold_distance=0.2) robot = Robot(left=(4, 14), right=(17, 18)) sensor.when_in_range = robot.backward sensor.when_out_of_range = robot.stop pause()
from gpiozero import Robot, MotionSensor from signal import pause robot = Robot(left=(4, 14), right=(17, 18)) pir = MotionSensor(5) robot.source = zip(pir.values, pir.values) pause()
# This uses a hbridge module
# guide found @ https://projects.raspberrypi.org/en/projects/build-a-buggy/2
# and merged with another guide found @ https://gpiozero.readthedocs.io/en/v1.1.0/recipes.html#keyboard-controlled-robot
from evdev import InputDevice, list_devices, ecodes
from gpiozero import Robot
johnny = Robot(left=(7,8), right=(9,10))
devices = [InputDevice(device) for device in list_devices()]
keyboard = devices[0] # this may vary
keypress_actions = {
ecodes.KEY_UP: johnny.forward,
ecodes.KEY_DOWN: johnny.backward,
ecodes.KEY_LEFT: johnny.left,
ecodes.KEY_RIGHT: johnny.right,
}
for event in keyboard.read_loop():
if event.type == ecodes.EV_KEY:
if event.value == 1: # key down
keypress_actions[event.code]()
if event.value == 0: # key up
johnny.stop()
from gpiozero import Robot
from evdev import InputDevice, list_devices, ecodes
robot = Robot(left=(4, 14), right=(17, 18))
# Get the list of available input devices
devices = [InputDevice(device) for device in list_devices()]
# Filter out everything that's not a keyboard. Keyboards are defined as any
# device which has keys, and which specifically has keys 1..31 (roughly Esc,
# the numeric keys, the first row of QWERTY plus a few more) and which does
# *not* have key 0 (reserved)
must_have = {i for i in range(1, 32)}
must_not_have = {0}
devices = [
dev
for dev in devices
for keys in (set(dev.capabilities().get(ecodes.EV_KEY, [])),)
if must_have.issubset(keys)
and must_not_have.isdisjoint(keys)
]
# Pick the first keyboard
keyboard = devices[0]
keypress_actions = {
ecodes.KEY_UP: robot.forward,
ecodes.KEY_DOWN: robot.backward,
ecodes.KEY_LEFT: robot.left,
ecodes.KEY_RIGHT: robot.right,
}
for event in keyboard.read_loop():
