def MoveBackward(self, steering=0, speed=40):
steer_pair = MoveSteering(OUTPUT_A, OUTPUT_B, motor_class=LargeMotor)
steer_pair.on_for_seconds(steering=0,
speed=20,
seconds=2,
brake=True,
block=True)
class ThirdStage:
def __init__(self):
self.steeringDrive = MoveSteering(OUTPUT_B, OUTPUT_C)
self.moveTank = MoveTank(OUTPUT_B, OUTPUT_C)
self.mvInfrared = MVInfraredSensor()
def Start(self):
# go until wall
self.goUntilDistanceFromWall(41)
# turn right
self.moveTank.on_for_rotations(SpeedPercent(-40), SpeedPercent(40),
1.33)
#self.steeringDrive.on(100, SpeedPercent(40))
# go until wall
self.goUntilDistanceFromWall(36.4)
# turn right
self.moveTank.on_for_rotations(SpeedPercent(-40), SpeedPercent(40),
1.33)
#self.steeringDrive.on(100, SpeedPercent(40))
sleep(4)
self.steeringDrive.on_for_seconds(0, SpeedPercent(-100), 6)
def goUntilDistanceFromWall(self, distance, speed=-40):
while True:
#self.moveTank.on_for_rotations(SpeedPercent(speed), SpeedPercent(speed), 0.25)
self.steeringDrive.on(0, SpeedPercent(speed))
print(self.mvInfrared.getDistance())
if self.mvInfrared.getDistance() < distance:
self.steeringDrive.off()
return
def square():
motor_pair = MoveSteering(OUTPUT_B, OUTPUT_C)
for i in range(4):
# Move robot forward for 3 seconds
motor_pair.on_for_seconds(steering=0, speed=50, seconds=3)
# Turn robot left 90 degrees (adjust rotations for your particular robot)
motor_pair.on_for_rotations(steering=-100, speed=15, rotations=0.5)
class Driver:
def __init__(self):
self.driver = MoveSteering(OUTPUT_B, OUTPUT_C)
self.speed = 40
def set_speed(self, speed):
self.speed = max(-100, min(100, speed))
def get_speed(self):
return self.speed
def move(self):
self.driver.on(0, SpeedPercent(self.speed))
def move_cm(self, cm):
TRANSFORM_CONST = 37.0
self.driver.on_for_degrees(0, SpeedPercent(self.speed), cm * TRANSFORM_CONST)
def move_neg_cm(self, cm):
TRANSFORM_CONST = 37.0
self.driver.on_for_degrees(0, SpeedPercent(self.speed), -cm * TRANSFORM_CONST)
def reverse(self):
self.driver.on(0, SpeedPercent(-self.speed))
def reverse_cm(self, cm):
TRANSFORM_CONST = 37.0
self.driver.on_for_degrees(0, SpeedPercent(-self.speed), cm*TRANSFORM_CONST)
def stop(self):
self.driver.off()
def turn(self, steering):
steering = max(-100, min(100, steering))
self.driver.on(steering, self.speed)
def turn_rotations(self, steering, rotations):
steering = max(-100, min(100, steering))
self.driver.on_for_rotations(steering, SpeedPercent(self.speed), rotations)
def turn_degrees(self, degrees):
TRANSFORM_CONST = 3.9
self.driver.on_for_degrees(100, SpeedPercent(self.speed), degrees * TRANSFORM_CONST)
def turn_neg_degrees(self, degrees):
TRANSFORM_CONST = 3.9
steering = 100 if degrees > 0 else -100
self.driver.on_for_degrees(steering, SpeedPercent(self.speed), -degrees * TRANSFORM_CONST)
def move_seconds(self, seconds):
self.driver.on_for_seconds(0, self.speed, seconds)
def back_seconds(self, seconds):
self.driver.on_for_seconds(0, -self.speed, seconds)
def start(self):
# move over start line
steeringDrive = MoveSteering(OUTPUT_B, OUTPUT_C)
steeringDrive.on_for_seconds(0, SpeedPercent(-40), 4)
# find and follow line
self.mvFollowLine.lookForLine(-40)
self.mvFollowLine.followLine()
steeringDrive.on_for_seconds(0, SpeedPercent(-40), 2)
print("First over")
class MVFollowLine:
def __init__(self):
self.colorSensor = MVColorSensor()
self.steeringDrive = MoveSteering(OUTPUT_B, OUTPUT_C)
self.oldError = 0.01
self.timer = 0
def followLine(self):
isRed = False
self.timer = time()
while not isRed:
self._followLine(self.oldError)
if (time() - self.timer) > 100:
isRed = self._isRed(self.colorSensor.getRGB())
self.steeringDrive.off()
def lookForLine(self, speed=-40):
intensity = self.colorSensor.getRefectionLight()
while intensity < 17: # prev 20
print(intensity)
self.steeringDrive.on(0, SpeedPercent(speed))
intensity = self.colorSensor.getRefectionLight()
def turnOnLine(self):
epsilon = 10
while True:
intensity = self.colorSensor.getRefectionLight()
if 18 < intensity and intensity < 22:
self.steeringDrive.on_for_seconds(0, SpeedPercent(-30), 2)
break
else:
self._followLine(self.oldError)
def _followLine(self, oldError, kp=100, ki=0):
intensity = self._mapping(self.colorSensor.getRefectionLight())
speed = -20
self.steeringDrive.on(0.7 * intensity, SpeedPercent(speed))
#self.oldError = intensity
def _mapping(self, x):
if x <= 20:
return max(100 / 12 * x - 1000 / 6, -100)
return min(5 * x - 100, 100)
# red : 150, 175, 286
# white: 137, 151, 181
# black: 38, 32, 40
# yellow: 190, 143, 40
def _isRed(self, rgb):
return rgb[0] > 145 and rgb[1] > 165 and rgb[2] > 250
def move():
motor_pair = MoveSteering(OUTPUT_B, OUTPUT_C)
touch_sensor = TouchSensor()
# Start robot moving forward
motor_pair.on(steering=0, speed=60)
# Wait until robot touches wall
touch_sensor.wait_for_pressed()
# Stop moving forward
motor_pair.off()
# Reverse away from wall
motor_pair.on_for_seconds(steering=0, speed=-10, seconds=2)
motor_pair.on_for_rotations(steering=-100, speed=15, rotations=0.5)
motor_pair.on_for_rotations(steering=-100, speed=15, rotations=0.5)
def MoveForward(self, steering=0, speed=-20):
steer_pair = MoveSteering(OUTPUT_A, OUTPUT_B, motor_class=LargeMotor)
drill = Drill()
#We make this condition to check if the Robot
if drill.Drilling() == 1:
steer_pair.off()
if self.is_drilled == False:
self.is_drilled = True
print("drilling")
sleep(2)
mm = MediumMotor(OUTPUT_D)
sp = 90
time = 10
mm.on_for_seconds(speed=SpeedRPM(sp), seconds=time)
print("Number of rotations =" + str(sp / 6))
else:
steer_pair.on_for_seconds(steering=0,
speed=-1 * SpeedRPM(12),
seconds=1,
brake=True,
block=True)
class EV:
def __init__(self):
self.button = Button()
self.tank = MoveSteering(OUTPUT_C, OUTPUT_B)
self.cs = ColorSensor()
self.cs.mode = ColorSensor.MODE_COL_REFLECT
self.gs = GyroSensor()
self.gs.reset()
self.before_direction = self.gyro()
def steer(self, steer, speed=SPEED, interval=INTERVAL):
"""
steer the motor by given params for time intarval [ms]
"""
if self.is_white(): # clockwise
self.tank.on_for_seconds(steer, speed, interval / 1000)
else:
self.tank.on_for_seconds(-steer, speed, interval / 1000)
data = (self._update_direction(), not self.is_white())
sleep(interval / 1000)
return data
def turn_degrees(self, radian):
self.tank.turn_degrees(SPEED, math.degrees(radian))
def on_for_millis(self, millis):
self.tank.on_for_seconds(0, SPEED, millis / 1000)
def gyro(self):
return self.gs.value()
def is_white(self):
return self.cs.value() > 30
# def _send(self, data):
# data = str(data).encode()
# self.socket.send(data)
# print(data)
def _update_direction(self):
current_direction = self.gyro()
m_direction = (current_direction + self.before_direction) / 2
self.before_direction = current_direction
return m_direction
def walkSeconds(direction, velocity, seconds):
steering_drive = MoveSteering(OUTPUT_B, OUTPUT_C)
steering_drive.on_for_seconds(direction, SpeedPercent(velocity), seconds)
def Robotrun4():
robot = MoveSteering(OUTPUT_A, OUTPUT_B)
tank = MoveTank(OUTPUT_A, OUTPUT_B)
colorLeft = ColorSensor(INPUT_1)
colorRight = ColorSensor(INPUT_3)
gyro = GyroSensor(INPUT_2)
motorC = LargeMotor(OUTPUT_C)
motorD = LargeMotor(OUTPUT_D)
motorB = LargeMotor(OUTPUT_B)
motorA = LargeMotor(OUTPUT_A)
Constants.STOP = False
gyro.reset()
GyroDrift()
gyro.reset()
show_text("Robot Run 2")
motorC.off(brake=True)
#GyroTurn(steering=-50, angle=5)
acceleration(degrees=DistanceToDegree(30), finalSpeed=30)
lineFollowPID(degrees=DistanceToDegree(30), kp=1.3, ki=0.01, kd=15, color=ColorSensor(INPUT_3))
acceleration(degrees=DistanceToDegree(5), finalSpeed=30)
accelerationMoveBackward(degrees = DistanceToDegree(7), finalSpeed=50, steering=0)
motorC.on_for_seconds(speed=15, seconds=1, brake=False)
GyroTurn(steering=50, angle=20)
acceleration(degrees=DistanceToDegree(20), finalSpeed=30)
GyroTurn(steering=-55, angle=22)
acceleration(degrees=DistanceToDegree(17), finalSpeed=30)
gyro.mode = "GYRO-ANG"
while gyro.value() < -10 and False == Constants.STOP:
motorA.on(speed = 20)
lineFollowPID(degrees=DistanceToDegree(15), kp=1.3, ki=0.01, kd=15, color=ColorSensor(INPUT_3))
lineFollowTillIntersectionPID(kp=1.3, ki=0.01, kd=15, color=ColorSensor(INPUT_3), color2=ColorSensor(INPUT_1))
lineFollowPID(degrees=DistanceToDegree(10), kp=1.3, ki=0.01, kd=15, color=ColorSensor(INPUT_3))
lineFollowTillIntersectionPID(kp=1.3, ki=0.01, kd=15, color=ColorSensor(INPUT_3), color2=ColorSensor(INPUT_1))
if gyro.angle > 2 and False == Constants.STOP:
GyroTurn(steering=-50, angle=gyro.angle)
elif gyro.angle < -2 and False == Constants.STOP:
ang = -1 * gyro.angle
GyroTurn(steering=50, angle=ang)
accelerationMoveBackward(degrees = DistanceToDegree(5), finalSpeed=50, steering=0)
acceleration(degrees=DistanceToDegree(12), finalSpeed=50, steering=2.5)
motorC.on_for_degrees(speed=-25, degrees=150, brake=True)
motorD.on_for_degrees(speed=-25, degrees=150, brake=True)
acceleration(degrees=DistanceToDegree(12), finalSpeed=45, steering=4)
#acceleration(degrees=DistanceToDegree(12), finalSpeed=45, steering=5)
#Moving treadmill
if False == Constants.STOP:
tank.on_for_seconds(left_speed=1, right_speed=20, seconds=5.5)
#motorB.on_for_seconds(speed=15, seconds=10)
motorC.on_for_seconds(speed=25, seconds=2, brake=False)
motorD.on_for_seconds(speed=25, seconds=2, brake=False)
accelerationMoveBackward(degrees = DistanceToDegree(5), finalSpeed=20, steering=0)
while colorLeft.reflected_light_intensity < Constants.WHITE:
robot.on(steering=0, speed=-20)
accelerationMoveBackward(degrees = DistanceToDegree(2), finalSpeed=10, steering=0)
GyroTurn(steering=-50, angle=gyro.angle)
MoveBackwardBlack(10)
ang = -1 * (88 + gyro.angle)
GyroTurn(steering=-100, angle=ang)
# wall square
if False == Constants.STOP:
robot.on_for_seconds(steering=5, speed=-10, seconds=2.7, brake=False)
# moving towards row machine
acceleration(degrees=DistanceToDegree(3), finalSpeed=50, steering=0)
ang = math.fabs(89 + gyro.angle)
show_text(str(ang))
if ang > 2 and False == Constants.STOP:
GyroTurn(steering=-100, angle=ang)
acceleration(degrees=DistanceToDegree(26), finalSpeed=50, steering=0)
GyroTurn(steering=100, angle=68)
#acceleration(degrees=DistanceToDegree(1), finalSpeed=20, steering=0)
if False == Constants.STOP:
motorC.on_for_seconds(speed=-10, seconds=1.5, brake=False)
GyroTurn(steering=100, angle=2)
sleep(0.2)
GyroTurn(steering=-100, angle=2)
motorC.on_for_seconds(speed=-10, seconds=0.2, brake=True)
motorC.off(brake=True)
acceleration(degrees=DistanceToDegree(1), finalSpeed=20, steering=0)
accelerationMoveBackward(degrees = DistanceToDegree(10), finalSpeed=20, steering=0)
GyroTurn(steering=-100, angle=10)
#DOING Row Machine
if False == Constants.STOP:
motorC.on_for_seconds(speed=20, seconds=2)
ang = 90 + gyro.angle
GyroTurn(steering=-100, angle=ang)
acceleration(degrees=DistanceToDegree(28), finalSpeed=50, steering=0)
lineSquare()
#Moving towards weight machine
show_text(str(gyro.angle))
ang = math.fabs(87 + gyro.angle)
show_text(str(ang))
GyroTurn(steering=100, angle=ang)
acceleration(degrees=DistanceToDegree(22), finalSpeed=30, steering=0)
if False == Constants.STOP:
motorD.on_for_degrees(speed=-20, degrees=160)
GyroTurn(steering=-100, angle=ang)
accelerationMoveBackward(degrees = DistanceToDegree(20), finalSpeed=20, steering=0)
if False == Constants.STOP:
motorD.on_for_seconds(speed=20, seconds=2, brake=True)
lineSquare()
if False == Constants.STOP:
GyroTurn(steering=-40, angle=85)
lineFollowRightPID(degrees=DistanceToDegree(30), kp=1.3, ki=0.01, kd=15, color=colorLeft)
lineFollowTillIntersectionRightPID(kp=1.3, ki=0.01, kd=15, color=colorLeft, color2=colorRight)
lineFollowRightPID(degrees=DistanceToDegree(34), kp=1.3, ki=0.01, kd=15, color=colorLeft)
if False == Constants.STOP:
GyroTurn(steering=50, angle=20)
acceleration(degrees=DistanceToDegree(12), finalSpeed=30, steering=2)
lineSquare()
if False == Constants.STOP:
GyroTurn(steering=100, angle=75)
motorC.on_for_seconds(speed=-10, seconds=1, brake=False)
acceleration(degrees=DistanceToDegree(6.5), finalSpeed=30, steering=0)
motorC.on_for_seconds(speed=10, seconds=2, brake=True)
if False == Constants.STOP:
GyroTurn(steering=50, angle=75)
acceleration(degrees=DistanceToDegree(5), finalSpeed=30, steering=0)
while Constants.STOP == False:
acceleration(degrees=DistanceToDegree(3), finalSpeed=31, steering=0)
accelerationMoveBackward(degrees = DistanceToDegree(3), finalSpeed=30, steering=0)
motorC.off(brake=False)
motorD.off(brake=False)
from ev3dev2.motor import (MoveSteering, MediumMotor, OUTPUT_A, OUTPUT_B,
OUTPUT_C)
from ev3dev2.sensor.lego import UltrasonicSensor
from time import sleep
motor_pair = MoveSteering(OUTPUT_B, OUTPUT_C)
medium_motor = MediumMotor(OUTPUT_A)
ultrasonic_sensor = UltrasonicSensor()
# Start robot moving forward
motor_pair.on(steering=0, speed=10)
# Wait until robot less than 3.5cm from cuboid
while ultrasonic_sensor.distance_centimeters > 3.5:
sleep(0.01)
# Stop moving forward
motor_pair.off()
# Lower robot arm over cuboid
medium_motor.on_for_degrees(speed=-10, degrees=90)
# Drag cuboid backwards for 2 seconds
motor_pair.on_for_seconds(steering=0, speed=-20, seconds=2)
# Raise robot arm
medium_motor.on_for_degrees(speed=10, degrees=90)
# Move robot away from cuboid
motor_pair.on_for_seconds(steering=0, speed=-20, seconds=2)
robot.on_for_degrees(speed=20, steering = 0, degrees = DistanceToDegree(2))
robot.on_for_degrees(degrees=DistanceToDegree(0.75), steering=2, speed=-10)
counter += 1
robot.off()
accelerationMoveBackward(degrees=DistanceToDegree(10), steering=-15, finalSpeed=-20)
GyroTurn(steering=-100, angle=40)
acceleration(degrees=DistanceToDegree(10.5), finalSpeed=20)
while colorRight.reflected_light_intensity < Constants.WHITE and False == Constants.STOP:
robot.on(speed=10, steering=0)
robot.off()
acceleration(degrees=DistanceToDegree(2), finalSpeed=20)
GyroTurn(steering=-100, angle=45)
# wall square
robot.on_for_seconds(steering=5, speed=-10, seconds=2)
acceleration(degrees=DistanceToDegree(55), finalSpeed=30, steering=1)
#lineFollowPID(degrees=DistanceToDegree(40), kp=1.25, ki=0.01, kd=5, color=ColorSensor(INPUT_3))
lineSquare()
acceleration(degrees=DistanceToDegree(20), finalSpeed=30, steering=-2)
motorC.on_for_seconds(speed=-20, seconds=0.5, brake=False)
motorC.on_for_degrees(speed=20, degrees=7, brake=True)
accelerationMoveBackward(degrees=DistanceToDegree(20), finalSpeed=30)
lineSquare()
GyroTurn(steering=-45, angle=85)
acceleration(degrees=DistanceToDegree(3.5), finalSpeed=10)
GyroTurn(steering=-50, angle=15)
#!/usr/bin/env pybricks-micropython
import pickle
from ev3dev2.sensor.lego import InfraredSensor, ColorSensor
from ev3dev2.motor import LargeMotor, OUTPUT_B, OUTPUT_C, SpeedPercent, MoveTank, MoveSteering
import time
import sys
from time import sleep
tank = MoveSteering(OUTPUT_B, OUTPUT_C)
FORWARD, BACKWARD, LEFT, RIGHT, WAIT = range(5)
with open('maze', 'rb') as fp:
actions = pickle.load(fp)
for action in actions:
if action[0] == FORWARD:
tank.on_for_seconds(steering=0, speed=40, seconds=action[1])
elif action[0] == BACKWARD:
tank.on_for_seconds(steering=0, speed=-40, seconds=action[1])
elif action[0] == LEFT:
tank.on_for_seconds(steering=100, speed=30, seconds=action[1])
elif action[0] == RIGHT:
tank.on_for_seconds(steering=-100, speed=30, seconds=action[1])
elif action[0] == WAIT:
sleep(action[1])
sleep(0.02)
elif color_sensor.color == 6:
music.speak("I found something white on the surface of Mars")
elif color_sensor.color == 7:
music.speak("I found a rock on the surface of Mars")
color_arm.on_for_rotations(SpeedPercent(-15), 0.3)
time.sleep(3)
demo_count = 0
while True:
tank_drive.on(SpeedPercent(50), SpeedPercent(50))
if ir.value() > 70:
tank_drive.on_for_seconds(SpeedPercent(-50), SpeedPercent(-50), 1)
steering_drive.on_for_seconds(90, SpeedPercent(75), 1)
demo_count += 1
elif ir.value() < 35:
tank_drive.off()
music.play_file("Overpower.wav")
deploy_color_sensor()
demo_count += 1
elif touch_sensor.is_pressed:
tank_drive.off()
music.play_note("F4", 0.5)
music.play_note("D4", 0.5)
deploy_color_sensor()
demo_count += 1
#!/usr/bin/env python3
"""
Move robot in a square path without using the Gyro sensor.
This script is a simple demonstration of moving forward and turning.
"""
from ev3dev2.motor import MoveSteering, OUTPUT_B, OUTPUT_C
motor_pair = MoveSteering(OUTPUT_B, OUTPUT_C)
for i in range(4):
# Move robot forward for 3 seconds
motor_pair.on_for_seconds(steering=0, speed=50, seconds=3)
# Turn robot left 90 degrees (adjust rotations for your particular robot)
motor_pair.on_for_rotations(steering=-100, speed=5, rotations=0.5)
#!/usr/bin/env python3 from ev3dev2.motor import MoveSteering, OUTPUT_B, OUTPUT_C from time import sleep steer_pair = MoveSteering(OUTPUT_B, OUTPUT_C) # 스티어링 모드 설정 steer_pair.on(0,50) # 직진 스팅어링으로 속도 50% 무한 주행 sleep(1) steer_pair.off(brake=True) # 주행 멈춤 sleep(1) steer_pair.on_for_seconds(30,50, 2) # 좌회전 스팅어링으로 속도 50% 2초 주행 sleep(1) # 직진 스팅어링으로 속도 50% 반대방향 3회전 주행 steer_pair.on_for_rotations(0,50, -3) sleep(1) steer_pair.on_for_degrees(0,50, 180) # 직진 스팅어링으로 속도 50% 180도 주행 sleep(1)
return cor
else:
cor = 'semcor'
return cor
rgbmax_e = definir_rgbmax('esq')
rgbmax_d = definir_rgbmax('dir')
ce = cor('esq')
cd = cor('dir')
sound.beep()
sleep(1)
if ce == cd:
steering_pair.on_for_seconds(0, 10, 2)
sound.speak('arrived')
sleep(7)
sound.beep()
sleep(1)
while cor('esq') == cor('dir'):
steering_pair.on(0, 10)
else:
steering_pair.off()
sound.speak('stop')
sleep(7)
sound.beep()
sleep(1)
while cor('esq') == 'branco':
sleep(0.01) # Wait 0.01 second
# def girar(lado,angulo):
# if lado == 'esq':
# steering_pair.on_for_degrees(-60,10,angulo*3.5)
# #global pos #só pode alterar se for 90 graus
# #pos = pos - 1
# elif lado == 'dir':
# steering_pair.on_for_degrees(60,10,angulo*3.5)
# #globa l pos
# #pos = pos + 1
# buscar_novo_cano = False
# primeira_curva = True
steering_pair.on_for_seconds(0, 60, 100)
# while buscar_novo_cano:
# if primeira_curva:
# girar('dir',90)
# global primeira_curva
# primeira_curva = False
# while usf.distance_centimeters > 12 and (cor('esq')=='azul' or cor('esq')=='verde') and (cor('dir')=='azul' or cor('dir')=='verde'):
# steering_pair.on(0,15)
# else:
# steering_pair.off()
# if (cor('esq')!='branco' or cor('esq') != 'verde' or cor('esq')!='azul') and (cor('dir')!='branco' or cor('dir') != 'verde' or cor('dir')!='azul'):
# girar('dir',90)
# else:
# if (cor('dir')=='branco' and cor('esq')=='branco'):
# steering_pair.on_for_degrees(0,15,150)
# create an object for the color sensor on input 2
colorLeft = ColorSensor(INPUT_2)
# create an object for the motors on output b and c
steering_drive = MoveSteering(OUTPUT_B, OUTPUT_C)
# set the direction for straight
direction = 0
# turn the motors on at speed 20
steering_drive.on(direction, 20)
# continuously check the color until the sensor detects pure green
while True:
if colorLeft.rgb[0] < 60 and colorLeft.rgb[1] > 75 and colorLeft.rgb[
2] < 40:
print('Left RGB: ' + str(colorLeft.rgb))
sleep(0.01)
# Explicitly stop motors at end of program
steering_drive.off()
break
sleep(3)
sound.speak('Commence drawing a regular pentagon')
for x in range(5):
steering_drive.on_for_seconds(steering=0, speed=20, seconds=3)
steering_drive.on_for_degrees(steering=-100, speed=20, degrees=160)
steering_drive.off()
class SecondStage:
def __init__(self):
self.mvFollowLine = MVFollowLine()
self.steeringDrive = MoveSteering(OUTPUT_B, OUTPUT_C)
self.moveTank = MoveTank(OUTPUT_B, OUTPUT_C)
self.mediumMotor = MediumMotor(OUTPUT_D)
self.mvInfrared = MVInfraredSensor()
def start(self):
# reach line
#self.goUntilDistanceFromWall(27)
self.mvFollowLine.lookForLine()
self.steeringDrive.on_for_seconds(0, SpeedPercent(-40), 0.6)
# turn left
self.moveTank.on_for_rotations(SpeedPercent(40), SpeedPercent(-40), 1.4)
# push button on left
self.goUntilDistanceFromWall(17)
# go back wee bit
self.moveTank.on_for_rotations(SpeedPercent(40), SpeedPercent(40), 2.8)
# turn left
self.moveTank.on_for_rotations(SpeedPercent(40), SpeedPercent(-40), 1.33)
# go to the ramp
#self.goUntilDistanceFromWall(25)
self.mvFollowLine.lookForLine()
self.steeringDrive.on_for_seconds(0, SpeedPercent(-40), 0.4)
# turn left
self.moveTank.on_for_rotations(SpeedPercent(40), SpeedPercent(-40), 1.35)
# go up
self.mvFollowLine.lookForLine()
self.moveTank.on_for_rotations(SpeedPercent(-100), SpeedPercent(-100), 10.5)
timer = time()
while time() - timer < 5:
self.mvFollowLine._followLine(0)
self.moveTank.on_for_rotations(SpeedPercent(20), SpeedPercent(-20), 0.1)
self.moveTank.on_for_rotations(SpeedPercent(-100), SpeedPercent(-100), 6)
self.mvFollowLine.lookForLine()
self.moveTank.on_for_rotations(SpeedPercent(40), SpeedPercent(-40), 2.5)
self.moveTank.on_for_rotations(SpeedPercent(40), SpeedPercent(40), 0.7)
self.mediumMotor.on_to_position(5, -80)
self.moveTank.on_for_rotations(SpeedPercent(-100), SpeedPercent(-100), 0.9)
self.moveTank.on_for_rotations(SpeedPercent(40), SpeedPercent(-40), 0.4)
self.moveTank.on_for_rotations(SpeedPercent(-100), SpeedPercent(-100), 4)
self.mvFollowLine.lookForLine()
self.mediumMotor.on_to_position(5, 0)
timer = time()
while time() - timer < 3:
self.mvFollowLine._followLine(0)
self.moveTank.on_for_rotations(SpeedPercent(-40), SpeedPercent(40), 0.15)
self.moveTank.on_for_rotations(SpeedPercent(-100), SpeedPercent(-100), 11)
self.goUntilDistanceFromWall(40)
self.moveTank.on_for_rotations(SpeedPercent(-40), SpeedPercent(40), 1.3)
self.mvFollowLine.lookForLine()
self.moveTank.on_for_rotations(SpeedPercent(40), SpeedPercent(40), 1.0)
self.moveTank.on_for_rotations(SpeedPercent(-100), SpeedPercent(100), 10)
self.mvFollowLine._followLine(0)
def goUntilDistanceFromWall(self, distance, speed=-40):
while True:
self.steeringDrive.on(0, SpeedPercent(speed))
print(self.mvInfrared.getDistance())
if self.mvInfrared.getDistance() < distance:
self.steeringDrive.off()
break
self.steeringDrive.on_for_seconds(0, SpeedPercent(speed/2), 0.5)
return
#!/usr/bin/env python3
from ev3dev2.motor import MoveSteering, OUTPUT_B, OUTPUT_C
from ev3dev2.sensor.lego import GyroSensor
from sys import stderr
from time import sleep
steer_pair = MoveSteering(OUTPUT_B, OUTPUT_C)
gyro = GyroSensor()
steer_pair.on_for_seconds(steering=100, speed=20, seconds=6, block=False)
for i in range(15):
print('Angle and Rate: ' + str(gyro.angle_and_rate), file=stderr)
sleep(0.5)
right_motor = LargeMotor(OUTPUT_A)
left_motor = LargeMotor(OUTPUT_B)
steer_pair = MoveSteering(OUTPUT_A, OUTPUT_B, motor_class=LargeMotor)
time = 0.03
cl = ColorSensor()
last_move = ''
while True:
color = cl.color_name
print(color)
if (color != "Black"):
if (last_move == ''):
if (random.randint(1, 3) == 1):
last_move == 'right'
else:
last_move = 'left'
if (last_move == 'right'):
right_motor.on_for_seconds(speed=-40, seconds=time * 1.5)
left_motor.on_for_seconds(speed=40, seconds=time * 2)
last_move = 'left'
if (last_move == 'left'):
left_motor.on_for_seconds(speed=-40, seconds=time * 1.5)
right_motor.on_for_seconds(speed=40, seconds=time * 2)
last_move = 'right'
else:
steer_pair.on_for_seconds(steering=0, speed=50, seconds=time)
last_move = ''
# else:
# steer_pair.on_for_seconds(steering=0, speed=50, seconds=time)
def Robotrun1():
robot = MoveSteering(OUTPUT_A, OUTPUT_B)
colorLeft = ColorSensor(INPUT_1)
colorRight = ColorSensor(INPUT_3)
motorA = LargeMotor(OUTPUT_A)
motorD = LargeMotor(OUTPUT_D)
motorC = LargeMotor(OUTPUT_C)
motorC.off(brake=True)
motorD.off(brake=True)
Constants.STOP = False
GyroDrift() #check gyro drift at the start of every robot run
show_text("Robot Run 1")
#Wall square and move forward till first line intersection
acceleration(degrees=DistanceToDegree(70), finalSpeed=50, steering=2)
while colorLeft.reflected_light_intensity > 10 and False == Constants.STOP:
robot.on(steering=1, speed=20)
robot.off()
#Move forward towards step counter
acceleration(degrees=DistanceToDegree(13), finalSpeed=20, steering=2)
#Move back and forth until the left sensor encounters white
while colorLeft.reflected_light_intensity < Constants.WHITE and False == Constants.STOP:
#robot.on_for_degrees(speed=20, steering = 0, degrees = DistanceToDegree(2))
#print("RobotRun2 stop=" + str(Constants.STOP), file=stderr)
MoveForwardWhite(distanceInCm=3)
if colorLeft.reflected_light_intensity >= Constants.WHITE:
break
robot.on_for_degrees(degrees=DistanceToDegree(1.5),
steering=-1,
speed=-8)
robot.off()
#Move back and forth until the left sensor encounters black
while colorLeft.reflected_light_intensity > Constants.BLACK and False == Constants.STOP:
#robot.on_for_degrees(speed=20, steering = 0, degrees = DistanceToDegree(2))
#print("RobotRun2 stop=" + str(Constants.STOP), file=stderr)
MoveForwardBlack(distanceInCm=3)
if colorLeft.reflected_light_intensity <= Constants.BLACK:
break
robot.on_for_degrees(degrees=DistanceToDegree(1.5),
steering=-1,
speed=-8)
robot.off()
#counter = 0
#while counter < 5 and False == Constants.STOP:
# robot.on_for_degrees(speed=20, steering = 0, degrees = DistanceToDegree(2))
# robot.on_for_degrees(degrees=DistanceToDegree(0.75), steering=-1, speed=-15)
# counter += 1
#robot.off()
#Series of movements to turn left after step counter mission and then wall square to align with pullup bar
accelerationMoveBackward(degrees=DistanceToDegree(12),
steering=-15,
finalSpeed=-20)
GyroTurn(steering=-100, angle=40)
acceleration(degrees=DistanceToDegree(10.5), finalSpeed=20)
while colorRight.reflected_light_intensity < Constants.WHITE and False == Constants.STOP:
robot.on(speed=10, steering=-1)
robot.off()
acceleration(degrees=DistanceToDegree(2), finalSpeed=20)
GyroTurn(steering=-100, angle=60)
# wall square
robot.on_for_seconds(steering=0, speed=-5, seconds=2, brake=False)
#acceleration(degrees=DistanceToDegree(5), finalSpeed=20, steering=0)
#lineSquare()
#Go under pullup bar and then line square
acceleration(degrees=DistanceToDegree(56), finalSpeed=40, steering=-1)
#lineFollowPID(degrees=DistanceToDegree(40), kp=1.25, ki=0.01, kd=5, color=ColorSensor(INPUT_3))
lineSquare()
#doing bociaa mission
acceleration(degrees=DistanceToDegree(22), finalSpeed=30, steering=0.5)
motorD.on_for_seconds(speed=-25, seconds=0.5, brake=False)
motorD.on_for_seconds(speed=15, seconds=0.25, brake=False)
motorD.on_for_seconds(speed=-25, seconds=0.25, brake=False)
GyroTurn(steering=50, angle=5)
motorC.on_for_seconds(speed=-25, seconds=0.5, brake=False)
motorC.on_for_seconds(speed=15, seconds=0.25, brake=True)
motorC.on_for_seconds(speed=-35, seconds=0.20, brake=False)
motorC.on_for_seconds(speed=15, seconds=0.5, brake=True)
GyroTurn(steering=-50, angle=5)
#motorD.on_for_degrees(speed=30, degrees=15, brake=True)
#Go backward after Boccia and then line square again
accelerationMoveBackward(degrees=DistanceToDegree(22), finalSpeed=30)
lineSquare()
#Turn towards slide and line follow until next intersection. Slide person will become dead by Bobby attachment
GyroTurn(steering=-45, angle=85)
lineFollowPID(degrees=DistanceToDegree(15),
kp=1.25,
ki=0.01,
kd=5,
color=ColorSensor(INPUT_1))
acceleration(degrees=DistanceToDegree(5), finalSpeed=20)
#Turn towards next line and follow the line, then square on the line near intersection
GyroTurn(steering=50, angle=20)
#motorD.on_for_degrees(speed=30, degrees=15, brake=True)
lineFollowPID(degrees=DistanceToDegree(11),
kp=1.25,
ki=0.01,
kd=5,
color=ColorSensor(INPUT_1))
lineSquare()
acceleration(degrees=DistanceToDegree(5), finalSpeed=20, steering=5)
lineFollowPID(degrees=DistanceToDegree(25),
kp=1.25,
ki=0.01,
kd=5,
color=ColorSensor(INPUT_1))
#Turn towards basketball
GyroTurn(steering=100, angle=40)
acceleration(degrees=DistanceToDegree(3), finalSpeed=20, steering=5)
#Lift the basket using right side arm attachment
motorD.on_for_seconds(speed=26, seconds=0.4, brake=True)
motorD.on_for_seconds(speed=-25, seconds=0.5, brake=False)
#Turn towards bench and flatten the bench using left side arm attachement
GyroTurn(steering=-100, angle=90)
#acceleration(degrees=DistanceToDegree(5), finalSpeed=50, steering=0)
motorC.on_for_degrees(speed=-10, degrees=50, brake=True)
GyroTurn(steering=100, angle=5)
motorC.on_for_degrees(speed=10, degrees=50, brake=True)
#Turn towards home and move at 100 speed
GyroTurn(steering=100, angle=35)
acceleration(degrees=DistanceToDegree(70), finalSpeed=100, steering=0)
motorC.off(brake=False)
motorD.off(brake=False)
sound = Sound()
print("Running")
sound.beep()
while True:
ucc = getpass('Scan a UCC: ')
ucc = ucc.lower().strip().replace('\t', '').replace('\n', '')
command = ""
for codeid, codedata in codedict.items():
barcode = codedata["barcode"]
if barcode == ucc:
command = codedata["command"]
if command == "":
sound.speak("oopsy!")
else:
# print(command)
sound.speak(command)
if command == "Forward":
drive.on_for_seconds(0, SpeedPercent(50), 1.5)
elif command == "Backward":
drive.on_for_seconds(0, SpeedPercent(-50), 1.5)
elif command == "Left":
drive.on_for_seconds(-100, SpeedPercent(50), 0.5)
elif command == "Right":
drive.on_for_seconds(100, SpeedPercent(50), 0.5)
elif command == "Do it":
sound.speak("Dude, do what?")
#print('**********************')
#print('Device Capabilities:')
#print(dev.capabilities(verbose=True))
#print('**********************')
print('Ready...')
for event in dev.read_loop():
if event.type == ecodes.EV_KEY:
if event.code == BUTTON_A_1 or event.code == BUTTON_B_1 or event.code == BUTTON_RB_1:
continue
elif event.code == BUTTON_A_2:
print('A ', end='')
if event.value == PRESS or event.value == HOLD:
print('pressed')
steering_drive.on_for_seconds(TURN_LEFT,SpeedPercent(SPEED_PCT),TIME_TURN)
while dev.read_one() != None:
pass
elif event.code == BUTTON_B_2:
print('B ', end='')
if event.value == PRESS or event.value == HOLD:
print('pressed')
steering_drive.on_for_seconds(TURN_RIGHT,SpeedPercent(SPEED_PCT),TIME_TURN)
sleep(TIME_TURN)
while dev.read_one() != None:
pass
elif event.code == BUTTON_RB_2:
print('RB ', end='')
if event.value == PRESS or event.value == HOLD:
print('pressed')
steering_drive.on_for_seconds(FORWARD,SpeedPercent(SPEED_PCT),TIME_WALK)
from ev3dev2.sound import Sound
from ev3dev2.motor import MoveSteering
from ev3dev2.motor import OUTPUT_A, OUTPUT_B, OUTPUT_C, OUTPUT_D
rob = MoveSteering(OUTPUT_D, OUTPUT_B)
mySnd = Sound()
mySnd.speak("Turning right in place")
rob.on_for_seconds(50, -50, 2)
mySnd.speak("Spiraling")
rob.on_for_seconds(20, 50, 2)
rob.off()
# control drivetrain motors usinf Sterring Drive.
medium_motor = MediumMotor(OUTPUT_A)
# control the medium motor of victim intake mechanics.
drivetrain.on(steering=0, speed=20)
while ultrasonic_sensor_front.distance_centimeters <= 2.0:
drivetrain.on(steering=0, speed=0)
#stop robot if something is at front.
if color_sensor.color == 5:
# set this color to victim color;
medium_motor.on_for_degrees(speed=-10, degrees=90)
# lower arm;
drivetrain.on_for_seconds(steering=0, speed=-20, seconds=2)
# drive back for 2 seconds;
medium_motor.on_for_degrees(speed=10, degrees=90)
# raise arm.
drivetrain.on(steering = 0, speed = -20)
drivetrain.on_for_seconds(steering = 100, speed = 20)
gyro.wait_until_angle_changed_by(360)
#rotate and check if victim is picked up (for 1 rotation).
while drivetrain.on:
if color_sensor == 5:
# set this color to victim color;
medium_motor.on_for_degrees(speed=-10, degrees=90)
drivetrain.on_for_seconds(steering=0, speed=-20, seconds=2)
#!/usr/bin/env python3
from ev3dev2.motor import LargeMotor, MoveSteering, OUTPUT_A, OUTPUT_B, OUTPUT_C, SpeedPercent, MoveTank
from ev3dev2.sensor import INPUT_1
from ev3dev2.sensor.lego import TouchSensor
from ev3dev2.led import Leds
ts = TouchSensor()
leds = Leds()
lm = LargeMotor(OUTPUT_B)
rm = LargeMotor(OUTPUT_C)
steer_pair = MoveSteering(OUTPUT_B, OUTPUT_C)
while True:
if ts.is_pressed:
steer_pair.on_for_seconds(steering=100, speed=100, seconds=1)
#!/usr/bin/env python3
from ev3dev2.motor import MoveTank, OUTPUT_B, OUTPUT_C, MoveSteering
from ev3dev2.sensor.lego import TouchSensor, UltrasonicSensor
from ev3dev2.sound import Sound
#from ev3dev2.led import Leds
from time import sleep
from ev3dev.ev3 import *
us = UltrasonicSensor()
us.mode = 'US-DIST-CM'
ts = TouchSensor()
sound = Sound()
leds = Leds()
steer_pair = MoveSteering(OUTPUT_B, OUTPUT_C)
steer_pair.on(steering=0, speed=50)
while not ts.is_pressed: # while touch sensor is not pressed
sleep(0.01)
steer_pair.off()
sleep(1)
#leds.set_color('LEFT', 'RED')
#leds.animate_flash('AMBER', sleeptime=0.75, duration=10)
#leds.animate_police_lights('RED', 'GREEN', sleeptime=0.75, duration=5)
#leds.animate_police_lights('RED', 'GREEN', sleeptime=0.75)
leds.set(Leds.LEFT, brightness_pct=1, trigger='timer')
leds.set_color(Leds.LEFT, Leds.RED)
steer_pair.on_for_seconds(steering=0,
speed=-20,
seconds=3,
brake=True,
block=True)
