def test_single_motor(output):
motor = LargeMotor(output)
# motor.command = LargeMotor.COMMAND_RUN_FOREVER
# for command in motor.commands:
# print('Motor at {} set to {}'.format(output, command))
# motor.command = command
motor.on_for_seconds(SpeedPercent(100), 5)
# print_and_wait(motor)
motor.on_for_rotations(SpeedPercent(30), 0.5)
# print_and_wait(motor)
motor.on_for_degrees(SpeedPercent(30), 45)
# print_and_wait(motor)
motor.on_to_position(SpeedPercent(30), 5)
# Make the robot turn so the compass reads the correct angle
# Start turning clockwise very slowly.
while True:
compass_angle = compass.value()
if degrees - 1 <= compass_angle <= degrees + 1:
break
# We also need to be careful when degrees is 0. A compass angle of 359 is super close,
# and so we need to check this case separately
elif degrees == 0 and compass_angle >= 359:
break
difference = compass_angle - degrees
if difference > 180:
difference = difference - 360
elif difference < -180:
difference = difference + 360
# Now difference is in between -180 and 180.
# If it's negative, we need to turn clockwise
if difference < 0:
# Motors are more powerful when difference is large
m_l.on((difference - 20) / 5)
m_r.on(-(difference - 20) / 5)
else:
# Motors are more powerful when difference is large
m_l.on((difference + 20) / 5)
m_r.on(-(difference + 20) / 5)
wait_for_tick()
# Go forwards
m_l.on_for_seconds(50, distance / robot_speed, block=False)
m_r.on_for_seconds(50, distance / robot_speed)
x = x + 1
#!/usr/bin/env python3 from ev3dev2.motor import LargeMotor, OUTPUT_C, OUTPUT_B, follow_for_ms from ev3dev2.motor import SpeedDPS, SpeedRPM, SpeedRPS, SpeedDPM, MoveTank, MoveSteering, SpeedPercent from time import sleep from ev3dev2.sensor.lego import ColorSensor lmB = LargeMotor(OUTPUT_B) lmC = LargeMotor(OUTPUT_C) lmB.on_for_seconds(90, 1, True, False) lmC.on_for_seconds(90, 1)
if irProxVal < 50:
print("Obstacle Detected! Forward motion stopped.")
if spd > 0:
spd = 0
if pilot_mode < 0:
# stop motors
mL.on(0, brake=False)
mR.on(0, brake=False)
print("Auto-pilot collision avoidance - backing up")
# backup at speed 5 with equal speed applied to left and right motors
spd = -5
# do so for 3 seconds
mL.on(speed=spd, brake=False)
mR.on_for_seconds(speed=spd,
seconds=3,
brake=False,
block=True)
# stop motors
mL.on(0, brake=False)
mR.on(0, brake=False)
print("Auto-pilot collision avoidance - turning")
spd = 5
if turnRatio >= 0: # if previously going straight or turning left, turn hard right
turnRatio = -0.5
mLspd = spd
mRspd = spd * (1 + turnRatio)
if turnRatio < 0: # if previously turning right, turn hard left
turnRatio = 0.5
mRspd = spd
mLspd = spd * (1 - turnRatio)
# proceed forward for 4 seconds
#!/usr/bin/env python3
from ev3dev2.motor import OUTPUT_A, SpeedPercent, LargeMotor
from ev3dev2.sensor.lego import TouchSensor
from ev3dev2.sensor import INPUT_1
from random import randint
wheel_motor = LargeMotor(OUTPUT_A)
start_button = TouchSensor(INPUT_1)
speed_dictionary = [(0.1, 25), (0.1, 50), (0.1, 75), (1, 100), (1, 75),
(1, 50), (1, 25), (1, 10)]
while True:
start_button.wait_for_pressed()
multiplier = float(randint(75, 125)) / 100.0
for speed_info in speed_dictionary:
time_to_run = speed_info[0] * multiplier
wheel_motor.on_for_seconds(SpeedPercent(speed_info[1]), time_to_run)
wheel_motor.off()
#!/usr/bin/env micropython
from ev3dev2.motor import LargeMotor, OUTPUT_B
from ev3dev2.sensor.lego import InfraredSensor
from ev3dev2.sensor import INPUT_4
from time import sleep
LARGE_MOTOR = LargeMotor(address=OUTPUT_B)
IR_SENSOR = InfraredSensor(address=INPUT_4)
while True:
LARGE_MOTOR.on_for_seconds(speed=100.0,
seconds=3.0,
block=True,
brake=True)
LARGE_MOTOR.on_for_seconds(speed=-100.0,
seconds=3.0,
block=True,
brake=True)
if IR_SENSOR.proximity <= 30:
LARGE_MOTOR.off(brake=True)
sleep(6)
class Rollers:
"""Rollers class witch allow managing paper. """
def __init__(self, power=30, prevent_paper_blocking=False):
_debug(self, "Creating Rollers instance")
self._default_power = power
self._delta_in = 0
self._delta_out = 0
self._in = LargeMotor(OUTPUT_A)
self._in.polarity = LargeMotor.POLARITY_NORMAL
self._out = LargeMotor(OUTPUT_D)
self._out.polarity = LargeMotor.POLARITY_INVERSED
self._col = ColorSensor()
self._col.mode = ColorSensor.MODE_COL_COLOR
self._paper_taken = self._col.color == 6
self.reset(prevent_paper_blocking)
def reset(self, prevent_paper_blocking=False, power=None):
"""Eject paper if present and prevent paper blocking
:param prevent_paper_blocking: if true, roller will move to avoid paper blocking
:param power: Power used to move rollers
"""
if power is None:
power = self._default_power
if self._paper_taken:
self.eject_paper()
elif prevent_paper_blocking:
self._in.on_for_rotations(power, 3, block=False)
self._out.on_for_rotations(power, 3)
def up(self, power=None):
"""Move paper to the 'up'
:param power: Power of the rotation
"""
if power is None:
power = self._default_power
self._in.on(power)
self._out.on(power)
def down(self, power=None):
"""Move paper to the 'down'
:param power: Power of the rotation
"""
if power is None:
power = self._default_power
self._in.on(-power)
self._out.on(-power)
def stop(self):
""" Stop moving rollers
"""
self._in.off()
self._out.off()
def save_energy(self):
"""Save energy and release motor's holding state"""
self._in.off(False)
self._out.off(False)
@property
def has_paper(self):
""" Get the paper state
:return True if paper present"""
return self._paper_taken
@property
def position(self):
""" Get rollers position
:return: rollers position
"""
if not self.has_paper:
return None
return self._in.position - self._delta_in, self._out.position - self._delta_out
@position.setter
def position(self, value):
""" Set Rollers position
:param value: position reached"""
self.go_to(value)
def go_to(self, position, power=None, block=True, override=False):
"""Go to absolute position `position`
:param position: Position Reached
:param power: Power used to move
:param block: If True, fonction will end at the end of the rotation
:param override: if true, bypass limits"""
if not self.has_paper:
raise ValueError("There is no paper.")
if power is None:
power = self._default_power
target_in = self._delta_in + position
target_out = self._delta_out + position
_debug(self, "Reached position is {}".format(position))
_debug(self, "Target In {}".format(target_in))
_debug(self, "Target Out {}".format(target_out))
if (not override) and (not 0 <= position <= 515):
raise ValueError("Position is out of reachable bounds.")
self._in.on_to_position(power, target_in, block=False)
self._out.on_to_position(power, target_out, block=block)
def move(self, value, power=None, block=True):
"""Move rollers (and paper if present) of `value` degrees
:param value: Degrees to move
:param power; Power used to move
:param block: If True, fonction will end at the end of the rotation"""
if power is None:
power = self._default_power
self._in.on_to_position(power, self._in.position + value, block=False)
self._out.on_to_position(power, self._out.position + value, block=block)
def up_limit(self, power=None):
"""Go to paper up limit
:param power: Power used to move"""
self.go_to(0, power)
def down_limit(self, power=None):
"""Go to paper down limit
:param power: Power used to move"""
self.go_to(515, power)
def take_paper(self, power=None, power_grip=15):
""" Take paper into printer and stretch it
:param power: Power used to take paper
:param power_grip: Power used to stretch paper
"""
self.up(power)
while self._col.color != 6:
sleep(0.1)
self.stop()
self._out.on_for_seconds(power_grip, 1)
self._paper_taken = self._col.color == 6
self.move(-130)
sleep(0.2)
self._delta_in = self._in.position
self._delta_out = self._out.position
def eject_paper(self, power=None):
""" Eject paper
:param power: Power used to eject paper
"""
self.up(power)
sleep(0.5)
while self._col.color == 6:
sleep(0.1)
sleep(0.5)
self.stop()
self._paper_taken = False
self._delta_in = 0
self._delta_out = 0
@property
def default_power(self):
return self._default_power
@default_power.setter
def default_power(self, value):
self._default_power = value
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)
lineFollowTillIntersectionPID(kp=1.25,
ki=0.01,
kd=5,
color=ColorSensor(INPUT_3),
color2=ColorSensor(INPUT_1))
lineFollowPID(degrees=DistanceToDegree(30),
kp=1.25,
ki=0.01,
kd=5,
color=ColorSensor(INPUT_3))
lineFollowTillIntersectionPID(kp=1.25,
ki=0.01,
kd=5,
color=ColorSensor(INPUT_3),
color2=ColorSensor(INPUT_1))
accelerationMoveBackward(degrees=DistanceToDegree(5),
finalSpeed=50,
steering=0)
acceleration(degrees=DistanceToDegree(26), finalSpeed=50, steering=3)
motorB.on_for_seconds(speed=15, seconds=10)
accelerationMoveBackward(degrees=DistanceToDegree(10),
finalSpeed=20,
steering=0)
accelerationMoveBackward(degrees=DistanceToDegree(200),
finalSpeed=100,
steering=1)
# Set a variable for your right large motor, connected to port C r_motor = LargeMotor(OUTPUT_C) # 1. Move the motor with on() and sleep() methods # a. turning it on at speed 70 # b. telling the robot to wait 1 second # c. turning the robot off l_motor.on(70) sleep(1) l_motor.off() r_motor.on(70) sleep(1) r_motor.off() # 2. Move the motors with the on_for_seconds() method # - Speed 70% for 1 second r_motor.on_for_seconds(SpeedPercent(70), 1) l_motor.on_for_seconds(SpeedPercent(70), 1) # 3. Move the motors with the on_for_rotations() method # - Speed 70% for 2 wheel rotations l_motor.on_for_rotations(SpeedPercent(70), 2) r_motor.on_for_rotations(SpeedPercent(70), 2) # 3. Move the motors with the on_for_degrees() method # - Speed 70% 2 times 360 degrees (1 wheel rotation) r_motor.on_for_degrees(SpeedPercent(70), (360 * 2)) l_motor.on_for_degrees(SpeedPercent(70), (360 * 2))
#!/usr/bin/env micropython
from ev3dev2.motor import LargeMotor, OUTPUT_B
from random import randint
LARGE_MOTOR = LargeMotor(address=OUTPUT_B)
LARGE_MOTOR.on_for_seconds(speed=randint(0, 100),
seconds=randint(1, 5),
block=True,
brake=True)
while True:
LARGE_MOTOR.on_for_seconds(speed=randint(-100, 100),
seconds=randint(1, 5),
block=True,
brake=True)
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)
right_motor = LargeMotor(OUTPUT_A)
left_motor = LargeMotor(OUTPUT_B)
steer_pair = MoveSteering(OUTPUT_A, OUTPUT_B, motor_class=LargeMotor)
time = 0.03
count = 0
cl = ColorSensor()
last_move = ''
while True:
color = cl.color_name
print(color)
if (color != "Black"):
if (last_move == 'right' or last_move == ''):
if (count > 2):
left_motor.on_for_seconds(speed=40, seconds=time * (count + 1))
else:
left_motor.on_for_seconds(speed=40, seconds=time)
last_move = 'left'
count += 1
if (last_move == 'left'):
if (count > 2):
right_motor.on_for_seconds(speed=40,
seconds=time * (count + 1))
else:
right_motor.on_for_seconds(speed=40, seconds=time)
right_motor.on_for_seconds(speed=40, seconds=time)
last_move = 'right'
count += 1
if (color == 'Black'):
steer_pair.on_for_seconds(steering=0, speed=50, seconds=time)
#!/usr/bin/env python3 from ev3dev2.motor import LargeMotor from ev3dev2.motor import SpeedDPS, SpeedRPM, SpeedRPS, SpeedDPM from time import sleep lm = LargeMotor() ''' This will run the large motor at 50% of its rated maximum speed of 1050 deg/s. 50% x 1050 = 525 deg/s ''' lm.on_for_seconds(speed=50, seconds=3) sleep(1) ''' speed and seconds are both POSITIONAL arguments which means you don't have to include the parameter names as long as you put the arguments in this order (speed then seconds) so this is the same as the previous command: ''' lm.on_for_seconds(50, 3) sleep(1) ''' This will run at 500 degrees per second (DPS). You should be able to hear that the motor runs a little slower than before. ''' lm.on_for_seconds(speed=SpeedDPS(500), seconds=3) sleep(1)
#!/usr/bin/env micropython
from ev3dev2.motor import LargeMotor, OUTPUT_D
from ev3dev2.sound import Sound
LARGE_MOTOR = LargeMotor(address=OUTPUT_D)
SPEAKER = Sound()
LARGE_MOTOR.on_for_seconds(speed=40, seconds=1, brake=True, block=True)
LARGE_MOTOR.on_for_degrees(speed=-75, degrees=220, brake=True, block=True)
SPEAKER.play_file(wav_file='/home/robot/sound/Blip 3.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
LARGE_MOTOR.on_for_seconds(speed=-100, seconds=1, block=True, brake=True)
LARGE_MOTOR.on_for_seconds(
speed=100, # 40 too weak
seconds=1,
block=True,
brake=True)
MEDIUM_MOTOR.on_for_seconds(
speed=50,
seconds=1,
block=True,
brake=True)
MEDIUM_MOTOR.on_for_seconds(
speed=-50,
seconds=0.3,
block=True,
brake=True)
STING_MOTOR.on_for_seconds(
speed=40,
seconds=1,
brake=True,
block=True)
GO_MOTOR.on(
speed=-50,
block=False,
brake=False)
SPEAKER.play_file(
wav_file='/home/robot/sound/Blip 2.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
while (INFRARED_SENSOR.distance(channel=1) is None) or (INFRARED_SENSOR.distance(channel=1) >= 30):
pass
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)
{
"obj": {
"name": "Circle",
"fill": "#00ff00"
if abs(m1Speed) + abs(m2Speed) > 100 else "#ff0000",
"radius": 3,
"stroke": None,
"position": [15, 0],
"zPos": 20,
},
"key": "ball",
"life": None,
"on_bot": True,
},
)
lm1.on_for_seconds(m1Speed, current_step_wait, block=False)
lm2.on_for_seconds(m2Speed, current_step_wait, block=False)
movement_queue.append({
"motor1Speed": m1Speed,
"motor2Speed": m2Speed,
"wait_time": current_step_wait,
})
solving_white = False
if time.time() - last_print_time > PRINT_TIME:
# Print sensor values.
last_print_time = time.time()
# We add each line to a string so that we can print the lines all at
# once, instead of one line at a time
message = "Sensor Values\n"
message += "=============\n"
from time import sleep
MEDIUM_MOTOR = MediumMotor(address=OUTPUT_A)
TAIL_MOTOR = LargeMotor(address=OUTPUT_B)
CHEST_MOTOR = LargeMotor(address=OUTPUT_D)
IR_SENSOR = InfraredSensor(address=INPUT_4)
LIGHTS = Leds()
SPEAKER = Sound()
CHEST_MOTOR.on_for_seconds(
speed=-30,
seconds=1,
brake=True,
block=True)
while True:
if IR_SENSOR.proximity < 30:
LIGHTS.set_color(
group=Leds.LEFT,
color=Leds.RED,
pct=1)
LIGHTS.set_color(
group=Leds.RIGHT,
color=Leds.RED,
pct=1)
simDuration = 15
totalSteps = int(simDuration / timeStep)
initial_angle = 0
final_angle = 720
ramp_up_down_left = int(rampup * 1000 * leftMotor.max_speed /
leftMotor.speed_sp)
ramp_up_down_right = int(rampup * 1000 * rightMotor.max_speed /
rightMotor.speed_sp)
leftMotor.ramp_up_sp = ramp_up_down_left
leftMotor.ramp_down_sp = ramp_up_down_left
rightMotor.ramp_up_sp = ramp_up_down_right
rightMotor.ramp_down_sp = ramp_up_down_right
startTime = time.time()
leftMotor.on_for_seconds(SpeedPercent(spValue), simDuration, block=False)
rightMotor.on_for_seconds(SpeedPercent(spValue), simDuration, block=True)
stopTime = time.time()
duration = stopTime - startTime
print('Traveled for {0:0.2f} seconds'.format(duration))
leftMotor.reset()
rightMotor.reset()
# pos = range(initial_angle, final_angle, int(final_angle/totalSteps))
# #leftMotor.max_speed
# time.sleep(20)
# print("Slept")
cs = Sensor(address=INPUT_2, driver_name="ht-nxt-compass") sound.beep() value = c.value() print(value) #cm = us.distance_centimeters_ping #print(cm) sleep(1) ''' This will run the large motor at 50% of its rated maximum speed of 1050 deg/s. 50% x 1050 = 525 deg/s ''' sound.beep() lm1.on_for_seconds(speed=-60, seconds=2) lm2.on_for_seconds(speed=60, seconds=2) value = c.value() print(value) sleep(1) ''' speed and seconds are both POSITIONAL arguments which means you don't have to include the parameter names as long as you put the arguments in this order (speed then seconds) so this is the same as the previous command: ''' sound.beep() lm1.on_for_seconds(50, 2) lm2.on_for_seconds(-50, 2)
from ev3dev2.motor import MediumMotor, LargeMotor, OUTPUT_A, OUTPUT_B, OUTPUT_C mm = MediumMotor(OUTPUT_A) lmr = LargeMotor(OUTPUT_B) lml = LargeMotor(OUTPUT_C) #mm.on_for_seconds(speed=10, seconds=0.2) lml.on_for_seconds(speed=-10, seconds=0.2) lmr.on_for_seconds(speed=-10, seconds=0.2)
item_lista = 0
# Começo
while waiting:
if btn.any():
sound.beep()
global waiting
global meeting_area
waiting = False
meeting_area = True
else:
sleep(0.01) # Wait 0.01 second
rgbmax_e = definir_rgbmax('esq')
rgbmax_d = definir_rgbmax('dir')
garra_g.on_for_seconds(10, 1.5)
garra_m.on_for_seconds(10, 1)
mapadecores = ['vermelho', 'amarelo', 'azul']
while True:
while meeting_area: #começa aleatório, termina virado pro preto
while cor('esq') == 'branco' and cor('dir') == 'branco':
log = open('log.txt', 'a')
log.write('Sensores no branco, indo pra frente\n')
log.close()
steering_pair.on(0, 20)
else:
log = open('log.txt', 'a')
log.write('Algum sensor saiu do branco, para.\n')
log.close()
steering_pair.off()
class MindstormsGadget(AlexaGadget):
"""
A Mindstorms gadget that performs movement based on voice commands.
Two types of commands are supported, directional movement and preset.
"""
def __init__(self):
"""
Performs Alexa Gadget initialization routines and ev3dev resource allocation.
"""
super().__init__()
# Ev3dev initialization
self.leds = Leds()
self.sound = Sound()
self.drive = LargeMotor(OUTPUT_B)
self.tail = MediumMotor(OUTPUT_A)
def on_connected(self, device_addr):
"""
Gadget connected to the paired Echo device.
:param device_addr: the address of the device we connected to
"""
self.leds.set_color("LEFT", "GREEN")
self.leds.set_color("RIGHT", "GREEN")
logger.info("{} connected to Echo device".format(self.friendly_name))
def on_disconnected(self, device_addr):
"""
Gadget disconnected from the paired Echo device.
:param device_addr: the address of the device we disconnected from
"""
self.leds.set_color("LEFT", "BLACK")
self.leds.set_color("RIGHT", "BLACK")
logger.info("{} disconnected from Echo device".format(
self.friendly_name))
def on_custom_mindstorms_gadget_control(self, directive):
"""
Handles the Custom.Mindstorms.Gadget control directive.
:param directive: the custom directive with the matching namespace and name
"""
try:
payload = json.loads(directive.payload.decode("utf-8"))
print("Control payload: {}".format(payload), file=sys.stderr)
control_type = payload["type"]
if control_type == "move":
# Expected params: [direction, duration, speed]
self._move(payload["direction"], int(payload["duration"]),
int(payload["speed"]))
if control_type == "command":
# Expected params: [command]
self._activate(payload["command"])
except KeyError:
print("Missing expected parameters: {}".format(directive),
file=sys.stderr)
def _move(self, direction, duration: int, speed: int, is_blocking=False):
"""
Handles move commands from the directive.
Right and left movement can under or over turn depending on the surface type.
:param direction: the move direction
:param duration: the duration in seconds
:param speed: the speed percentage as an integer
:param is_blocking: if set, motor run until duration expired before accepting another command
"""
print("Move command: ({}, {}, {}, {})".format(direction, speed,
duration, is_blocking),
file=sys.stderr)
if direction in Direction.FORWARD.value:
self.drive.on_for_seconds(SpeedPercent(speed),
duration,
block=is_blocking)
if direction in Direction.BACKWARD.value:
self.drive.on_for_seconds(SpeedPercent(-speed),
duration,
block=is_blocking)
if direction in Direction.STOP.value:
self.drive.off()
def _activate(self, command, speed=50):
"""
Handles preset commands.
:param command: the preset command
:param speed: the speed if applicable
"""
print("Activate command: ({}, {})".format(command, speed),
file=sys.stderr)
if command in Command.Tail_Down.value:
self.tail.on_for_rotations(SpeedPercent(100), 3)
if command in Command.Tail_Up.value:
self.tail.on_for_rotations(SpeedPercent(-100), 3)
class R3ptar:
def __init__(self,
turn_motor_port: str = OUTPUT_A,
move_motor_port: str = OUTPUT_B,
scare_motor_port: str = OUTPUT_D,
touch_sensor_port: str = INPUT_1,
color_sensor_port: str = INPUT_3,
ir_sensor_port: str = INPUT_4,
ir_beacon_channel: int = 1):
self.turn_motor = MediumMotor(address=turn_motor_port)
self.move_motor = LargeMotor(address=move_motor_port)
self.scare_motor = LargeMotor(address=scare_motor_port)
self.touch_sensor = TouchSensor(address=touch_sensor_port)
self.color_sensor = ColorSensor(address=color_sensor_port)
self.ir_sensor = InfraredSensor(address=ir_sensor_port)
self.ir_beacon_channel = ir_beacon_channel
self.noise = Sound()
def keep_driving_by_ir_beacon(self, speed: float = 100):
while True:
if self.ir_sensor.top_left(channel=self.ir_beacon_channel) and \
self.ir_sensor.top_right(channel=self.ir_beacon_channel):
self.move_motor.on(speed=speed, brake=False, block=False)
elif self.ir_sensor.bottom_left(channel=self.ir_beacon_channel) and \
self.ir_sensor.bottom_right(channel=self.ir_beacon_channel):
self.move_motor.on(speed=-speed, brake=False, block=False)
elif self.ir_sensor.top_left(channel=self.ir_beacon_channel):
self.turn_motor.on(speed=-50, brake=False, block=False)
self.move_motor.on(speed=speed, brake=False, block=False)
elif self.ir_sensor.top_right(channel=self.ir_beacon_channel):
self.turn_motor.on(speed=50, brake=False, block=False)
self.move_motor.on(speed=speed, brake=False, block=False)
elif self.ir_sensor.bottom_left(channel=self.ir_beacon_channel):
self.turn_motor.on(speed=-50, brake=False, block=False)
self.move_motor.on(speed=-speed, brake=False, block=False)
elif self.ir_sensor.bottom_right(channel=self.ir_beacon_channel):
self.turn_motor.on(speed=50, brake=False, block=False)
self.move_motor.on(speed=-speed, brake=False, block=False)
else:
self.turn_motor.off(brake=True)
self.move_motor.off(brake=False)
def bite_by_ir_beacon(self, speed: float = 100):
while True:
if self.ir_sensor.beacon(channel=self.ir_beacon_channel):
self.scare_motor.on_for_seconds(speed=speed,
seconds=1,
brake=True,
block=False)
self.noise.play_file(
wav_file='/home/robot/sound/Snake hiss.wav',
volume=100,
play_type=Sound.PLAY_NO_WAIT_FOR_COMPLETE)
self.scare_motor.on_for_seconds(speed=-speed,
seconds=1,
brake=True,
block=True)
while self.ir_sensor.beacon(channel=self.ir_beacon_channel):
pass
def run_away_if_chased(self):
while True:
if self.color_sensor.reflected_light_intensity > 30:
self.move_motor.on_for_seconds(speed=50,
seconds=4,
brake=True,
block=False)
for i in range(2):
self.turn_motor.on_for_seconds(speed=50,
seconds=1,
brake=False,
block=True)
self.turn_motor.on_for_seconds(speed=-50,
seconds=1,
brake=False,
block=True)
def bite_if_touched(self):
while True:
if self.touch_sensor.is_pressed:
self.scare_motor.on_for_seconds(speed=100,
seconds=1,
brake=True,
block=False)
self.noise.play_file(
wav_file='/home/robot/sound/Snake hiss.wav',
volume=100,
play_type=Sound.PLAY_NO_WAIT_FOR_COMPLETE)
self.scare_motor.on_for_seconds(speed=-10,
seconds=10,
brake=True,
block=True)
def main(self, speed: float = 100):
Thread(target=self.bite_by_ir_beacon).start()
Thread(target=self.bite_if_touched).start()
Thread(target=self.run_away_if_chased).start()
self.keep_driving_by_ir_beacon(speed=speed)
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)
acceleration(degrees=DistanceToDegree(5), finalSpeed=10)
accelerationMoveBackward(degrees=DistanceToDegree(1.5), finalSpeed=10)
motorC.on_for_seconds(speed=10, seconds=0.5, brake=True)
acceleration(degrees=DistanceToDegree(2), finalSpeed=10)
motorC.on_for_seconds(speed=10, seconds=0.2, brake=False)
acceleration(degrees=DistanceToDegree(7), finalSpeed=10)
#!/usr/bin/env python3 from ev3dev2.motor import LargeMotor from time import sleep lm = LargeMotor() lm.on(speed=50, brake=True, block=False) sleep(1) lm.off() sleep(1) lm.on_for_seconds(speed=50, seconds=2, brake=True, block=True) sleep(1) lm.on_for_rotations(50, 3) sleep(1) lm.on_for_degrees(50, 90) sleep(1) lm.on_to_position(50, 180) sleep(1)
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. The views and conclusions contained in the software and documentation are those of the authors and should not be interpreted as representing official policies, either expressed or implied, of the FLL Robot Framework project. -------------------------------------------------------------------------------- ''' from ev3dev2.motor import MediumMotor, LargeMotor, OUTPUT_B, OUTPUT_C largeMotor_Left = LargeMotor(OUTPUT_B) largeMotor_Right = LargeMotor(OUTPUT_C) mediumMotor = MediumMotor() # run these in parallel largeMotor_Left.on_for_seconds(speed=50, seconds=2, brake=True) largeMotor_Right.on_for_seconds(speed=50, seconds=4, brake=True) # run this after the previous have completed mediumMotor.on_for_seconds(speed=10, seconds=6)
class Spik3r:
def __init__(self,
claw_motor_port: str = OUTPUT_A,
move_motor_port: str = OUTPUT_B,
sting_motor_port: str = OUTPUT_D,
touch_sensor_port: str = INPUT_1,
ir_sensor_port: str = INPUT_4,
ir_beacon_channel: int = 1):
self.claw_motor = MediumMotor(address=claw_motor_port)
self.move_motor = LargeMotor(address=move_motor_port)
self.sting_motor = LargeMotor(address=sting_motor_port)
self.ir_sensor = InfraredSensor(address=ir_sensor_port)
self.ir_beacon_channel = ir_beacon_channel
self.touch_sensor = TouchSensor(address=touch_sensor_port)
self.speaker = Sound()
def snap_claw_if_touched(self):
if self.touch_sensor.is_pressed:
self.claw_motor.on_for_seconds(speed=50,
seconds=1,
brake=True,
block=True)
self.claw_motor.on_for_seconds(speed=-50,
seconds=0.3,
brake=True,
block=True)
def move_by_ir_beacon(self):
if self.ir_sensor.top_left(channel=self.ir_beacon_channel) and \
self.ir_sensor.top_right(channel=self.ir_beacon_channel):
self.move_motor.on(speed=100, block=False, brake=False)
elif self.ir_sensor.top_right(channel=self.ir_beacon_channel):
self.move_motor.on(speed=-100, brake=False, block=False)
else:
self.move_motor.off(brake=False)
def sting_by_ir_beacon(self):
if self.ir_sensor.beacon(channel=self.ir_beacon_channel):
self.sting_motor.on_for_degrees(speed=-75,
degrees=220,
brake=True,
block=False)
self.speaker.play_file(wav_file='Blip 3.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
self.sting_motor.on_for_seconds(speed=-100,
seconds=1,
brake=True,
block=True)
self.sting_motor.on_for_seconds(speed=40,
seconds=1,
brake=True,
block=True)
while self.ir_sensor.beacon(channel=self.ir_beacon_channel):
pass
def main(self):
while True:
self.snap_claw_if_touched()
self.move_by_ir_beacon()
self.sting_by_ir_beacon()
def Robotrun3():
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 each run
show_text("Robot Run 3")
#Turn left and move forward to align with line outside the base
GyroTurn(steering=-50, angle=45)
acceleration(degrees=DistanceToDegree(17), finalSpeed=20)
#Follow the line up to intersection
lineFollowPID(degrees=DistanceToDegree(20),
kp=1.25,
ki=0.01,
kd=5,
color=ColorSensor(INPUT_3))
lineFollowTillIntersectionPID(kp=1.25,
ki=0.01,
kd=5,
color=ColorSensor(INPUT_3),
color2=ColorSensor(INPUT_1))
#left turn to align with line, then line follow till next intersection
GyroTurn(steering=-50, angle=65)
lineFollowTillIntersectionPID(kp=1.25,
ki=0.01,
kd=5,
color=ColorSensor(INPUT_3),
color2=ColorSensor(INPUT_1))
#Line follow some more for intersection near Boccia share mission
lineFollowPID(degrees=DistanceToDegree(20),
kp=1.25,
ki=0.01,
kd=5,
color=ColorSensor(INPUT_3))
lineFollowTillIntersectionPID(kp=1.25,
ki=0.01,
kd=5,
color=ColorSensor(INPUT_3),
color2=ColorSensor(INPUT_1))
lineFollowPID(degrees=DistanceToDegree(18),
kp=1.25,
ki=0.01,
kd=5,
color=ColorSensor(INPUT_3))
#lineFollowTillIntersectionPID(kp=1.25, ki=0.01, kd=5, color=ColorSensor(INPUT_3), color2=ColorSensor(INPUT_1))
#Move left arm to send Boccia ball accross. Move right arm if we want to use different color
#accelerationMoveBackward(degrees=DistanceToDegree(5), finalSpeed=20)
motorC.on_for_seconds(speed=20, seconds=1, brake=True)
#Turn right and move to Boccia target region
GyroTurn(steering=100, angle=60)
acceleration(degrees=DistanceToDegree(20), finalSpeed=20)
#Drop the Boccia balls in target region
#motorD.on_for_seconds(speed=-25, seconds=0.5, brake=False)
motorD.on_for_seconds(speed=20, seconds=1, brake=False)
#Move backward and start robot dance
#accelerationMoveBackward(degrees=DistanceToDegree(10), finalSpeed=30)
while Constants.STOP == False:
acceleration(degrees=DistanceToDegree(3), finalSpeed=31, steering=0)
accelerationMoveBackward(degrees=DistanceToDegree(3),
finalSpeed=30,
steering=0)
