def slide(robot): robot.stop() motor_b, motor_c = Motor(Port.B, positive_direction=Direction.CLOCKWISE), Motor( Port.C, positive_direction=Direction.CLOCKWISE) robot = DriveBase(motor_b, motor_c, wheel_diameter=94.2, axle_track=95) robot.straight(220) wait(500) # robot.stop() while gyro.angle() < 265: robot.drive(-100, 80) dead_stop() motor_a.run_angle(1500, -1000, then=Stop.HOLD, wait=False) robot.straight(515) dead_stop() robot.turn(125) # 105 robot.stop() motor_b, motor_c = Motor( Port.B, positive_direction=Direction.COUNTERCLOCKWISE), Motor( Port.C, positive_direction=Direction.COUNTERCLOCKWISE) robot = DriveBase(motor_b, motor_c, wheel_diameter=94.2, axle_track=95) robot.straight(200) robot.turn(70) robot.turn(-60) LineFollow(100, 1.05, robot, 50) robot.straight(250)
def GreenMission(): # Green Run (Boccia Frame, Boccia Share, and Dance Mission) #!/usr/bin/env pybricks-micropython from pybricks.hubs import EV3Brick from pybricks.ev3devices import (Motor, TouchSensor, ColorSensor, InfraredSensor, UltrasonicSensor, GyroSensor) from pybricks.parameters import Port, Stop, Direction, Button, Color from pybricks.tools import wait, StopWatch, DataLog from pybricks.robotics import DriveBase from pybricks.media.ev3dev import SoundFile, ImageFile # This program requires LEGO EV3 MicroPython v2.0 or higher. # Click "Open user guide" on the EV3 extension tab for more information. # Create your objects here. ev3 = EV3Brick() left_motor = Motor(Port.C) right_motor = Motor(Port.B) medium_motor = Motor(Port.A) front_largeMotor = Motor(Port.D) wheel_diameter = 56 axle_track = 114.3 robot = DriveBase(left_motor, right_motor, wheel_diameter, axle_track) ## Write your code here: robot.settings(300) # Speed Change ## The robot goes straight until the Boccia Mission's target. robot.straight(1050) ## The robot moves the large motor down to drop the cubes into the target. front_largeMotor.run_angle(80, 110, then=Stop.HOLD, wait=True) ## BOCCIA SHARE !!! robot.straight(-220) robot.turn(-100) robot.straight(135) front_largeMotor.run_angle(-80, 105, then=Stop.HOLD, wait=True) robot.straight(-60) robot.turn(-100) robot.straight(-80) # This is the DANCE Mission! robot.turn(-100) robot.turn(100) robot.turn(-100) robot.turn(100) robot.turn(-100) robot.turn(100) robot.turn(-100) robot.turn(100) robot.stop(Stop.BRAKE)
def BlackMission(): # Black Run (Innovatice Architecture, Health Units, Hopscotch, Bringing Slide Figures back HOME) #!/usr/bin/env pybricks-micropython from pybricks.hubs import EV3Brick from pybricks.ev3devices import (Motor, TouchSensor, ColorSensor, InfraredSensor, UltrasonicSensor, GyroSensor) from pybricks.parameters import Port, Stop, Direction, Button, Color from pybricks.tools import wait, StopWatch, DataLog from pybricks.robotics import DriveBase from pybricks.media.ev3dev import SoundFile, ImageFile # This program requires LEGO EV3 MicroPython v2.0 or higher. # Click "Open user guide" on the EV3 extension tab for more information. # define your variables ev3 = EV3Brick() left_motor = Motor(Port.C) right_motor = Motor(Port.B) medium_motor = Motor(Port.A) large_motor = Motor(Port.D) wheel_diameter = 56 axle_track = 115 line_sensor = ColorSensor(Port.S2) line_sensor1 = ColorSensor(Port.S3) robot = DriveBase(left_motor, right_motor, wheel_diameter, axle_track) robot.settings(140) # To change the SPEED # Pushing our innovative architecture and the health units. robot.straight(350) robot.straight(-97) robot.turn(-40) robot.straight(40) # Dropping the cube into hopscotch area and returning back to base. large_motor.run_angle(30,50,then=Stop.HOLD, wait=True) ev3.speaker.beep(15) large_motor.run_angle(60,-180,then=Stop.HOLD, wait=False) robot.turn(30) robot.straight(-300) # (In base) Wait block for attachment change. wait(6000) # Bringing slide figures to base. robot.stop(Stop.BRAKE) robot.settings(240) # Speed change ev3.speaker.beep(20) robot.straight(390) ev3.speaker.beep(300) large_motor.run_angle(60,130) robot.straight(-90) large_motor.run_angle(60,40,then=Stop.HOLD, wait=True) robot.straight(-500) large_motor.run_angle(60,-100,then=Stop.HOLD, wait=True) robot.stop(Stop.BRAKE)
def return_home(): # Initialize two motors and a drive base left = Motor(Port.B) right = Motor(Port.C) robot = DriveBase(left, right, 56, 114) # Initialize a sensor sensor = UltrasonicSensor(Port.S4) # Drive forward until an object is detected robot.drive(100, 0) while sensor.distance() > 500: wait(10) robot.stop()
def BlackMission(): #!/usr/bin/env pybricks-micropython from pybricks.hubs import EV3Brick from pybricks.ev3devices import (Motor, TouchSensor, ColorSensor, InfraredSensor, UltrasonicSensor, GyroSensor) from pybricks.parameters import Port, Stop, Direction, Button, Color from pybricks.tools import wait, StopWatch, DataLog from pybricks.robotics import DriveBase from pybricks.media.ev3dev import SoundFile, ImageFile # This program requires LEGO EV3 MicroPython v2.0 or higher. # Click "Open user guide" on the EV3 extension tab for more information. #define your variables ev3 = EV3Brick() left_motor = Motor(Port.C) right_motor = Motor(Port.B) medium_motor = Motor(Port.A) large_motor = Motor(Port.D) wheel_diameter = 56 axle_track = 115 line_sensor = ColorSensor(Port.S2) line_sensor1 = ColorSensor(Port.S3) robot = DriveBase(left_motor, right_motor, wheel_diameter, axle_track) robot.settings(140) robot.straight(350) robot.straight(-97) robot.turn(-40) large_motor.run_angle(30,50,then=Stop.HOLD, wait=True) ev3.speaker.beep(15) large_motor.run_angle(60,-180,then=Stop.HOLD, wait=False) robot.straight(-300) wait(10000) robot.stop(Stop.BRAKE) robot.settings(240) ev3.speaker.beep(20) robot.straight(390) ev3.speaker.beep(300) large_motor.run_angle(60,130) robot.straight(-90) large_motor.run_angle(60,40,then=Stop.HOLD, wait=True) robot.straight(-500) # test straight after beep and see if it works... robot.stop(Stop.BRAKE)
def RedMission(): # Red Run (Bench Mission (including backrest removal)) #!/usr/bin/env pybricks-micropython from pybricks.hubs import EV3Brick from pybricks.ev3devices import (Motor, TouchSensor, ColorSensor, InfraredSensor, UltrasonicSensor, GyroSensor) from pybricks.parameters import Port, Stop, Direction, Button, Color from pybricks.tools import wait, StopWatch, DataLog from pybricks.robotics import DriveBase from pybricks.media.ev3dev import SoundFile, ImageFile # This program requires LEGO EV3 MicroPython v2.0 or higher. # Click "Open user guide" on the EV3 extension tab for more information. # Create your objects here. ev3 = EV3Brick() left_motor = Motor(Port.C) right_motor = Motor(Port.B) wheel_diameter = 56 axle_track = 115 robot = DriveBase(left_motor, right_motor, wheel_diameter, axle_track) Medium_Motor = Motor(Port.A) Large_Motor = Motor(Port.D) leftcolorsensor = ColorSensor(Port.S3) rightcolorsensor = ColorSensor(Port.S2) robot.settings(300) # Speed change # Starts off from base and approaches the bench model. robot.straight(200) robot.turn(-115) # Removes backrest and flattens the bench. Medium_Motor.run_angle(300, 135, then=Stop.HOLD, wait=True) robot.stop(Stop.BRAKE) robot.settings(500) robot.turn(-60) # Returns to base. robot.straight(400) Large_Motor.run_angle(80, 95, then=Stop.HOLD, wait=True) robot.stop(Stop.BRAKE)
class Driver(): def __init__(self, leftMotor, rightMotor, diameter, axle): self.driver = DriveBase(leftMotor, rightMotor, diameter, axle) self.x = 0 self.y = 0 self.speed = 0 self.steering = 0 def drive(self, speed, steering): self.speed = speed self.steering = steering if self.speed == 0: self.driver.stop() else: self.driver.drive(self.speed, self.steering)
def init_robot(): #####Initialization########################################################################### logging.info("####################################") logging.info("Initializing the robot.") #Define Global Variables global Left_Motor global Right_Motor global Med_Motor_1 global Med_Motor_2 global Right_Color_Sensor global Left_Color_Sensor global Gyro global Touch_Sensor global Robot global Max_Speed global Target_Reflection Target_Reflection = 35 #initialize Motors Left_Motor = Motor(Port.C) Right_Motor = Motor(Port.D) Med_Motor_1 = Motor(Port.A) Med_Motor_2 = Motor(Port.B) #Left_Motor.set_run_settings(1000, 100) #Right_Motor.set_run_settings(1000, 100) #Initialize Sensors Left_Color_Sensor = ColorSensor(Port.S2) Right_Color_Sensor = ColorSensor(Port.S3) #Set Wheel Diameters and Axle Length WheelDiameter = 55 #42 # diameter of the wheel in mm AxleLength = 128 #112 # distance between the middle of the two wheels in mm #####The drivebase function helps to drive the robot. This is initialization of the drivebase Robot = DriveBase(Left_Motor, Right_Motor, WheelDiameter, AxleLength) Max_Speed = 70 Robot.stop(0) brick.sound.file('/home/robot/FLL2019/boing_spring.wav') logging.info("Initializing complete.") logging.info("####################################")
def Treadmill(robot): moveTank(-300, 95, -130) robot.turn(105) robot.stop() motor_b, motor_c = Motor( Port.B, positive_direction=Direction.COUNTERCLOCKWISE), Motor( Port.C, positive_direction=Direction.COUNTERCLOCKWISE) robot = DriveBase(motor_b, motor_c, wheel_diameter=94.2, axle_track=95) LineFollow(70, 1.05, robot, 200) robot.turn(28) robot.straight(180) robot.turn(-28) motor_d.run_time(-500, 1000, then=Stop.COAST, wait=False) robot.straight(70) wait(1000) motor_d.run_time(-200, 10000, then=Stop.COAST, wait=True) robot.stop()
def GreenMission(): # Green Run (Boccia Frame, Boccia Share, and Dance Mission) # RIGHT BUTTON #!/usr/bin/env pybricks-micropython from pybricks.hubs import EV3Brick from pybricks.ev3devices import (Motor, TouchSensor, ColorSensor, InfraredSensor, UltrasonicSensor, GyroSensor) from pybricks.parameters import Port, Stop, Direction, Button, Color from pybricks.tools import wait, StopWatch, DataLog from pybricks.robotics import DriveBase from pybricks.media.ev3dev import SoundFile, ImageFile # This program requires LEGO EV3 MicroPython v2.0 or higher. # Click "Open user guide" on the EV3 extension tab for more information. # Create your objects here. ev3 = EV3Brick() left_motor = Motor(Port.C) right_motor = Motor(Port.B) medium_motor = Motor(Port.A) front_largeMotor = Motor(Port.D) wheel_diameter = 56 axle_track = 114.3 robot = DriveBase(left_motor, right_motor, wheel_diameter, axle_track) robot.settings(300) robot.straight(1050) front_largeMotor.run_angle(80, 110, then=Stop.HOLD, wait=True) front_largeMotor.run_angle(80, -110, then=Stop.HOLD, wait=False) robot.straight(-1100) wait(7000) robot.straight(380) front_largeMotor.run_angle(60,90) robot.straight(-150) front_largeMotor.run_angle(60,40,then=Stop.HOLD, wait=True) robot.straight(-500) front_largeMotor.run_angle(60,-130,then=Stop.HOLD, wait=True) ev3.speaker.beep(7000) robot.stop(Stop.BRAKE)
def BlackMission( ): # Black Run (Innovatice Architecture, Health Units, Hopscotch, Bringing Slide Figures back HOME) #!/usr/bin/env pybricks-micropython from pybricks.hubs import EV3Brick from pybricks.ev3devices import (Motor, TouchSensor, ColorSensor, InfraredSensor, UltrasonicSensor, GyroSensor) from pybricks.parameters import Port, Stop, Direction, Button, Color from pybricks.tools import wait, StopWatch, DataLog from pybricks.robotics import DriveBase from pybricks.media.ev3dev import SoundFile, ImageFile # This program requires LEGO EV3 MicroPython v2.0 or higher. # Click "Open user guide" on the EV3 extension tab for more information. # define your variables ev3 = EV3Brick() left_motor = Motor(Port.C) right_motor = Motor(Port.B) medium_motor = Motor(Port.A) large_motor = Motor(Port.D) wheel_diameter = 56 axle_track = 115 line_sensor = ColorSensor(Port.S2) line_sensor1 = ColorSensor(Port.S3) robot = DriveBase(left_motor, right_motor, wheel_diameter, axle_track) robot.settings(500) # To change the SPEED # Pushing our innovative architecture and the health units. robot.straight(-350) robot.straight(50) robot.turn(-15) robot.straight(-70) robot.turn(-206) robot.straight(15) large_motor.run_angle(60, 80, then=Stop.HOLD, wait=True) robot.stop(Stop.BRAKE) robot.straight(-340) robot.stop(Stop.BRAKE)
def erstes(): ev3.speaker.beep() m_r = Motor(Port.C, Direction.COUNTERCLOCKWISE) m_l = Motor(Port.B, Direction.COUNTERCLOCKWISE) db = DriveBase(m_l, m_r, wheel_diameter=30, axle_track=140) db.straight(distance=50) db.turn(90) db.straight(distance=-50) # play some sound and get angry #im = Image('./Angry.bmp') im = ImageFile.ANGRY ev3.screen.load_image(im) ev3.speaker.play_file(SoundFile.CAT_PURR) # drive up to a distance of 100 mm db.drive(speed=10, turn_rate=0) # start driving while abs(db.distance()) < 100: time.sleep(0.1) # wait 100 msec before querying distance again db.stop()
class Ev3rstorm(EV3Brick): WHEEL_DIAMETER = 26 # milimeters AXLE_TRACK = 102 # milimeters def __init__(self, left_foot_motor_port: Port = Port.B, right_foot_motor_port: Port = Port.C, bazooka_blast_motor_port: Port = Port.A, touch_sensor_port: Port = Port.S1, color_sensor_port: Port = Port.S3, ir_sensor_port: Port = Port.S4, ir_beacon_channel: int = 1): self.drive_base = DriveBase( left_motor=Motor(port=left_foot_motor_port, positive_direction=Direction.CLOCKWISE), right_motor=Motor(port=right_foot_motor_port, positive_direction=Direction.CLOCKWISE), wheel_diameter=self.WHEEL_DIAMETER, axle_track=self.AXLE_TRACK) self.bazooka_blast_motor = Motor( port=bazooka_blast_motor_port, positive_direction=Direction.CLOCKWISE) self.touch_sensor = TouchSensor(port=touch_sensor_port) self.color_sensor = ColorSensor(port=color_sensor_port) self.ir_sensor = InfraredSensor(port=ir_sensor_port) self.ir_beacon_channel = ir_beacon_channel def drive_once_by_ir_beacon( self, speed: float = 1000, # mm/s turn_rate: float = 90 # rotational speed deg/s ): ir_beacon_button_pressed = set( self.ir_sensor.buttons(channel=self.ir_beacon_channel)) # forward if ir_beacon_button_pressed == {Button.LEFT_UP, Button.RIGHT_UP}: self.drive_base.drive(speed=speed, turn_rate=0) # backward elif ir_beacon_button_pressed == {Button.LEFT_DOWN, Button.RIGHT_DOWN}: self.drive_base.drive(speed=-speed, turn_rate=0) # turn left on the spot elif ir_beacon_button_pressed == {Button.LEFT_UP, Button.RIGHT_DOWN}: self.drive_base.drive(speed=0, turn_rate=-turn_rate) # turn right on the spot elif ir_beacon_button_pressed == {Button.RIGHT_UP, Button.LEFT_DOWN}: self.drive_base.drive(speed=0, turn_rate=turn_rate) # turn left forward elif ir_beacon_button_pressed == {Button.LEFT_UP}: self.drive_base.drive(speed=speed, turn_rate=-turn_rate) # turn right forward elif ir_beacon_button_pressed == {Button.RIGHT_UP}: self.drive_base.drive(speed=speed, turn_rate=turn_rate) # turn left backward elif ir_beacon_button_pressed == {Button.LEFT_DOWN}: self.drive_base.drive(speed=-speed, turn_rate=turn_rate) # turn right backward elif ir_beacon_button_pressed == {Button.RIGHT_DOWN}: self.drive_base.drive(speed=-speed, turn_rate=-turn_rate) # otherwise stop else: self.drive_base.stop() def keep_driving_by_ir_beacon( self, speed: float = 1000, # mm/s turn_rate: float = 90 # rotational speed deg/s ): while True: self.drive_once_by_ir_beacon(speed=speed, turn_rate=turn_rate) def dance_whenever_ir_beacon_pressed(self): while True: while Button.BEACON in self.ir_sensor.buttons( channel=self.ir_beacon_channel): self.drive_base.turn(angle=randint(-360, 360)) def keep_detecting_objects_by_ir_sensor(self): while True: if self.ir_sensor.distance() < 25: self.light.on(color=Color.RED) self.speaker.play_file(file=SoundFile.OBJECT) self.speaker.play_file(file=SoundFile.DETECTED) self.speaker.play_file(file=SoundFile.ERROR_ALARM) else: self.light.off() def blast_bazooka_whenever_touched(self): MEDIUM_MOTOR_N_ROTATIONS_PER_BLAST = 3 MEDIUM_MOTOR_ROTATIONAL_DEGREES_PER_BLAST = MEDIUM_MOTOR_N_ROTATIONS_PER_BLAST * 360 while True: if self.touch_sensor.pressed(): if self.color_sensor.ambient() < 5: # 15 not dark enough self.speaker.play_file(file=SoundFile.UP) self.bazooka_blast_motor.run_angle( speed=2 * MEDIUM_MOTOR_ROTATIONAL_DEGREES_PER_BLAST, # shoot quickly in half a second rotation_angle= -MEDIUM_MOTOR_ROTATIONAL_DEGREES_PER_BLAST, then=Stop.HOLD, wait=True) self.speaker.play_file(file=SoundFile.LAUGHING_1) else: self.speaker.play_file(file=SoundFile.DOWN) self.bazooka_blast_motor.run_angle( speed=2 * MEDIUM_MOTOR_ROTATIONAL_DEGREES_PER_BLAST, # shoot quickly in half a second rotation_angle= MEDIUM_MOTOR_ROTATIONAL_DEGREES_PER_BLAST, then=Stop.HOLD, wait=True) self.speaker.play_file(file=SoundFile.LAUGHING_2) def main( self, driving_speed: float = 1000 # mm/s ): self.screen.load_image(ImageFile.TARGET) # FIXME: following thread seems to fail to run Thread(target=self.dance_whenever_ir_beacon_pressed).start() # DON'T use IR Sensor in 2 different modes in the same program / loop # - https://github.com/pybricks/support/issues/62 # - https://github.com/ev3dev/ev3dev/issues/1401 # Thread(target=self.keep_detecting_objects_by_ir_sensor).start() Thread(target=self.blast_bazooka_whenever_touched).start() self.keep_driving_by_ir_beacon(speed=driving_speed)
def YellowMission(): #!/usr/bin/env pybricks-micropython from pybricks.hubs import EV3Brick from pybricks.ev3devices import (Motor, TouchSensor, ColorSensor, InfraredSensor, UltrasonicSensor, GyroSensor) from pybricks.parameters import Port, Stop, Direction, Button, Color from pybricks.tools import wait, StopWatch, DataLog from pybricks.robotics import DriveBase from pybricks.media.ev3dev import SoundFile, ImageFile # This program requires LEGO EV3 MicroPython v2.0 or higher. # Click "Open user guide" on the EV3 extension tab for more information. # Create your objects here. ev3 = EV3Brick() left_motor = Motor(Port.C) right_motor = Motor(Port.B) medium_motor = Motor(Port.A) front_largeMotor = Motor(Port.D) wheel_diameter = 56 axle_track = 115 robot = DriveBase(left_motor, right_motor, wheel_diameter, axle_track) # Initialize the color sensor. line_sensor = ColorSensor(Port.S2) line_sensor2 = ColorSensor(Port.S3) robot.straight(110) # Calculate the light threshold. Choose values based on your measurements. BLACK = 9 WHITE = 85 threshold = (BLACK + WHITE) / 2 # Set the drive speed at 100 millimeters per second. DRIVE_SPEED = 100 # Set the gain of the proportional line controller. This means that for every # percentage point of light deviating from the threshold, we set the turn # rate of the drivebase to 1.2 degrees per second. # For example, if the light value deviates from the threshold by 10, the robot # steers at 10*1.2 = 12 degrees per second. PROPORTIONAL_GAIN = 1.2 runWhile = True # Start following the line endlessly. while runWhile: # Calculate the deviation from the threshold. deviation = line_sensor.reflection() - threshold # Calculate the turn rate. turn_rate = PROPORTIONAL_GAIN * deviation # Set the drive base speed and turn rate. robot.drive(DRIVE_SPEED, turn_rate) if robot.distance() == 800: runWhile = False robot.stop(Stop.BRAKE) robot.drive(100, 0) if line_sensor2 and cl.Color() == Color.BLACK: robot.stop(Stop.BRAKE) # robot stops after finishing up line following code robot.stop(Stop.BRAKE) # robot turns after finishing up line following code robot.turn(-103.5) # robot goes straight as it heads towards the mission robot.straight(138) # robot turns right for 90 degrees robot.turn(80) # robot goes straight towards the mission to line the attachment to the wheel robot.straight(97) # large motor attachment goes down to trap the wheel in front_largeMotor.run_angle(60, 162) # robot moves backwards to bring wheel outside of the large circle robot.straight(-115) # large motor releases the trapped tire front_largeMotor.run_angle(60, -148) # robot moves straight to get closer the wheel robot.straight(38) # robot turns so the wheel can get into the smaller target robot.turn(-40) robot.stop(Stop.BRAKE) # robot goes backwards to leave the target and the wheel inside of it robot.straight(-110) # robot turns towards the weight machine robot.turn(-30) # going straight from row machine to weight machine robot.straight(505) # stopping for accuracy. robot.stop(Stop.BRAKE) # turning towards the weight machine. robot.turn(30) # robot goes straight to get closer to the weight machine robot.straight(145) # large motor going down to complete mission (weight machine). front_largeMotor.run_angle(120, 130) # going backwards away from the weight machine robot.straight(-120) # large motor goes back up # front_largeMotor.run_angle(50, -100) ## The robot is turning away from the Weight Machine and towards the Boccia. robot.turn(-127) ## The robot is moving straight towards the Boccia Mission. robot.straight(290) # the robot turns right to turn the aim boccia with the yellow axle on the bottom of the bot. robot.turn(60) # robot.straight(-10) # robot.turn(15) # front_largeMotor.run_angle(50, 60) # robot.straight(55) # the large motor goes up to push the yellow cube down into the target area. front_largeMotor.run_angle(50, -50) robot.straight(-100) robot.turn(-45) robot.straight(900) robot.turn(25) robot.straight(700)
def RedMission1(): #!/usr/bin/env pybricks-micropython from pybricks.hubs import EV3Brick from pybricks.ev3devices import (Motor, TouchSensor, ColorSensor, InfraredSensor, UltrasonicSensor, GyroSensor) from pybricks.parameters import Port, Stop, Direction, Button, Color from pybricks.tools import wait, StopWatch, DataLog from pybricks.robotics import DriveBase from pybricks.media.ev3dev import SoundFile, ImageFile # This program requires LEGO EV3 MicroPython v2.0 or higher. # Click "Open user guide" on the EV3 extension tab for more information. # Create your objects here. ev3 = EV3Brick() left_motor = Motor(Port.C) right_motor = Motor(Port.B) wheel_diameter = 56 axle_track = 115 robot = DriveBase(left_motor, right_motor, wheel_diameter, axle_track) Medium_Motor = Motor(Port.A) Large_Motor = Motor(Port.D) leftcolorsensor = ColorSensor(Port.S3) rightcolorsensor = ColorSensor(Port.S2) ##### BLACK = 9 WHITE = 85 threshold = (BLACK + WHITE) / 2 ###### robot.straight(320) robot.turn(110) while True: robot.drive(90, 0) if leftcolorsensor.reflection() <= 9: robot.stop(Stop.BRAKE) break robot.turn(-110) robot.straight(200) # Calculate the light threshold. Choose values based on your measurements. BLACK = 6 WHITE = 85 threshold = (BLACK + WHITE) / 2 # Set the drive speed at 100 millimeters per second. DRIVE_SPEED = 110 # Set the gain of the proportional line controller. This means that for every # percentage point of light deviating from the threshold, we set the turn # rate of the drivebase to 1.2 degrees per second. # For example, if the light value deviates from the threshold by 10, the robot # steers at 10*1.2 = 12 degrees per second. PROPORTIONAL_GAIN = 1.2 runWhile = True # Start following the line endlessly. while runWhile: # Calculate the deviation from the threshold. deviation = rightcolorsensor.reflection() - threshold # Calculate the turn rate. turn_rate = PROPORTIONAL_GAIN * deviation # Set the drive base speed and turn rate. robot.drive(DRIVE_SPEED, turn_rate) if robot.distance() == 1000: runWhile = False # robot stops after finishing up line following code robot.stop(Stop.BRAKE) robot.straight(-40) robot.turn(-50) robot.straight(145) Large_Motor.run_angle(50, 90, then=Stop.HOLD, wait=True) #robot continues run, to do Boccia mission while True: robot.drive(-80, 0) if leftcolorsensor.reflection() <= 10: robot.stop(Stop.BRAKE) break robot.straight(80) robot.turn(60) robot.straight(100) Large_Motor.run_angle(-50, 150, then=Stop.HOLD, wait=True) robot.straight(-40) Large_Motor.run_angle(50, 150, then=Stop.HOLD, wait=True) robot.straight(-40) while True: robot.drive(-80, 0) if leftcolorsensor.reflection() <= 9: robot.stop(Stop.BRAKE) break robot.straight(40) robot.turn(-85) robot.straight(340) robot.turn(165) robot.straight(55) Large_Motor.run_angle(-50, 150, then=Stop.HOLD, wait=True) robot.straight(20) Medium_Motor.run_angle(150, 250, then=Stop.HOLD, wait=True) robot.turn(70) Medium_Motor.run_angle(-150, 250, then=Stop.HOLD, wait=True) robot.turn(-20) robot.straight(-35) Medium_Motor.run_angle(150, 250, then=Stop.HOLD, wait=True) robot.turn(30) robot.straight(-130)
def BlueMission(): #!/usr/bin/env pybricks-micropython from pybricks.hubs import EV3Brick from pybricks.ev3devices import (Motor, TouchSensor, ColorSensor, InfraredSensor, UltrasonicSensor, GyroSensor) from pybricks.parameters import Port, Stop, Direction, Button, Color from pybricks.tools import wait, StopWatch, DataLog from pybricks.robotics import DriveBase from pybricks.media.ev3dev import SoundFile, ImageFile # This program requires LEGO EV3 MicroPython v2.0 or higher. # Click "Open user guide" on the EV3 extension tab for more information. #define your variables ev3 = EV3Brick() left_motor = Motor(Port.C) right_motor = Motor(Port.B) medium_motor = Motor(Port.A) large_motor = Motor(Port.D) wheel_diameter = 56 axle_track = 115 line_sensor = ColorSensor(Port.S2) line_sensor1 = ColorSensor(Port.S3) robot = DriveBase(left_motor, right_motor, wheel_diameter, axle_track) #go front towards the step counter robot.straight(650) robot.stop(Stop.BRAKE) wait(20) #makes the robot go slower robot.settings(40) #slowly pushes the step counter by going back and front 2 times robot.straight(140) robot.stop(Stop.BRAKE) robot.straight(-45) robot.stop(Stop.BRAKE) robot.straight(120) robot.stop(Stop.BRAKE) robot.settings(100) robot.straight(-30) robot.stop(Stop.BRAKE) #the robot then turns and goes backwards robot.turn(45) robot.straight(-100) # the robot then goes back until the right color sensor detects back while True: robot.drive(-30, 0) if line_sensor.color() == Color.BLACK: robot.stop(Stop.BRAKE) break #the large motor attatchment comes down at the same time the robot takes a turn towards the black line underneath the pull up bar large_motor.run_angle(50, 170, then=Stop.HOLD, wait=False) left_motor.run_angle(50, -300, then=Stop.HOLD, wait=True) #the robot then goes straight towards that line robot.straight(120) robot.stop(Stop.BRAKE) #robot continues to go forwards until the left color sensor detects black while True: robot.drive(30, 0) if line_sensor.color() == Color.BLACK: robot.stop(Stop.BRAKE) break right_motor.run_angle(50, 150, then=Stop.HOLD, wait=True) #the robot then turns with the right motor until it detects black while True: right_motor.run(85) if line_sensor.color() == Color.BLACK: robot.stop(Stop.BRAKE) break #follows the line underneath the pull up bar until the leftsensor detects black BLACK = 9 WHITE = 85 threshold = (BLACK + WHITE) / 2 # Set the drive speed at 100 millimeters per second. DRIVE_SPEED = 100 # Set the gain of the proportional line controller. This means that for every PROPORTIONAL_GAIN = 1.2 runWhile = True robot.reset() while True: # Calculate the deviation from the threshold. deviation = line_sensor.reflection() - threshold # Calculate the turn rate. turn_rate = PROPORTIONAL_GAIN * deviation # Set the drive base speed and turn rate. robot.drive(DRIVE_SPEED, turn_rate) wait(10) print(line_sensor.color()) if line_sensor1.color() == Color.BLACK: robot.stop(Stop.BRAKE) break #the robot then turns towards the boccia aim and moves straight to push it towards the target and finishes the misison robot.straight(100) #after line following, it goes straight for 100 mm robot.turn(50) robot.straight(100) robot.straight(-30) large_motor.run_angle(100, -65) robot.straight(-60) #the robot then takes a turn (at the same time bringing the attatchment down) towards the slide mission and completes the mission large_motor.run_angle(50, 80, then=Stop.HOLD, wait=False) robot.turn(-195) robot.straight(165) large_motor.run_angle(300, -120, then=Stop.HOLD, wait=True) robot.straight(-30) large_motor.run_angle(200, 120, then=Stop.HOLD, wait=True) ## The robot moves straight towards the mission, getting ready to attempt to push the slide figures off once more. (In case it didn't work before.) robot.straight(30) large_motor.run_angle(300, -120, then=Stop.HOLD, wait=True) robot.straight(-50) '''
def BlackandGreen(): #!/usr/bin/env pybricks-micropython from pybricks.hubs import EV3Brick from pybricks.ev3devices import (Motor, TouchSensor, ColorSensor, InfraredSensor, UltrasonicSensor, GyroSensor) from pybricks.parameters import Port, Stop, Direction, Button, Color from pybricks.tools import wait, StopWatch, DataLog from pybricks.robotics import DriveBase from pybricks.media.ev3dev import SoundFile, ImageFile # This program requires LEGO EV3 MicroPython v2.0 or higher. # Click "Open user guide" on the EV3 extension tab for more information. #define your variables ev3 = EV3Brick() left_motor = Motor(Port.C) right_motor = Motor(Port.B) medium_motor = Motor(Port.A) large_motor = Motor(Port.D) wheel_diameter = 56 axle_track = 115 line_sensor = ColorSensor(Port.S2) line_sensor1 = ColorSensor(Port.S3) robot = DriveBase(left_motor, right_motor, wheel_diameter, axle_track) #follows the line underneath the pull up bar until the leftsensor detects black BLACK = 9 WHITE = 85 threshold = (BLACK + WHITE) / 2 # Set the drive speed at 100 millimeters per second. DRIVE_SPEED = 100 # Set the gain of the proportional line controller. This means that for every PROPORTIONAL_GAIN = 1.2 runWhile = True #goes straight to get ready for line following then resets the distance robot.straight(250) robot.reset() #starts to follow the line towards the replay logo while True: # Calculate the deviation from the threshold. deviation = line_sensor.reflection() - threshold # Calculate the turn rate. turn_rate = PROPORTIONAL_GAIN * deviation # Set the drive base speed and turn rate. robot.drive(DRIVE_SPEED, turn_rate) wait(10) print(robot.distance()) if (robot.distance() >= 450): robot.stop(Stop.BRAKE) break #the robot pushes the phone into the replay logo and moves back to get ready to drop the health units into the replay logo robot.straight(-75) robot.stop(Stop.BRAKE) #the robot then turns so it is going to be perfectly into the replay logo robot.turn(-35) #the robot drops the health units large_motor.run_angle(100, 150) #then turns to an angle to go back to base robot.turn(50) robot.straight(-1000) wait(50) #!/usr/bin/env pybricks-micropython from pybricks.hubs import EV3Brick from pybricks.ev3devices import (Motor, TouchSensor, ColorSensor, InfraredSensor, UltrasonicSensor, GyroSensor) from pybricks.parameters import Port, Stop, Direction, Button, Color from pybricks.tools import wait, StopWatch, DataLog from pybricks.robotics import DriveBase from pybricks.media.ev3dev import SoundFile, ImageFile # This program requires LEGO EV3 MicroPython v2.0 or higher. # Click "Open user guide" on the EV3 extension tab for more information. # Create your objects here. ev3 = EV3Brick() left_motor = Motor(Port.C) right_motor = Motor(Port.B) medium_motor = Motor(Port.A) front_largeMotor = Motor(Port.D) wheel_diameter = 56 axle_track = 114.3 robot = DriveBase(left_motor, right_motor, wheel_diameter, axle_track) ## Write your code here: ## The robot goes straight until the Boccia Mission's target. robot.straight(1060) ## The robot moves the large motor down to drop the cubes in the target. front_largeMotor.run_angle(80, 70, then=Stop.HOLD, wait=True) front_largeMotor.run_angle(-80, 70, then=Stop.HOLD, wait=True) ## Dance Mission ## The robot moves backwards to reach the Dance Floor so it can Dance as the last mission. robot.straight(-185) robot.turn(-70) robot.straight(138) ## The following code is all the dance moves we do for the Dance Mission. robot.turn(160) robot.turn(-160) robot.straight(60) front_largeMotor.run_target(500, 60) front_largeMotor.run_target(500, -40) robot.straight(-60) robot.turn(260) robot.turn(-260) robot.turn(100) robot.straight(40) robot.turn(100) front_largeMotor.run_angle(500, 30)
while x < 2: print("Side 1") robot.drive_time(500, 0, 2000) motorA.run(250) motorC.run(-250) gs.reset_angle(0) while gs.angle() >= -75: wait(50) print("Gyro Angle :", gs.angle()) if gs.angle() <= -75: robot.stop(Stop.BRAKE) robot.stop(Stop.BRAKE) robot.drive_time(500, 0, 3500) print("side 2") motorA.run(250) motorC.run(-250) gs.reset_angle(0) while gs.angle() <= 75 or gs.angle() >= -75: wait(50) print("Gyro Angle :", gs.angle())
wait(200) ## turn back then turn some more onMat = color.reflection() #onMat = color.color() ford.drive(-15, 0) go = 'false' while go != 'true': go = get_from_system_link('Start19', ROGERS) print(go) #send_to_system_link('Start19', "BOOLEAN", 'true', ROGERS) #wait(1000) #go = get_from_system_link('Start19', ROGERS) #print(go) dinoFlag4 = get_from_system_link('dino4', STRONG) print('dinoFlag is', dinoFlag4) while dinoFlag4 == '0': driveCar() wait(100) dinoFlag4 = get_from_system_link('dino4', STRONG) print('dinoFlag is', dinoFlag4) if touch.pressed() == True: dinoFlag4 = '1' ford.stop() print("DONE!") send_to_system_link('Start20', 'BOOLEAN', 'true', ROGERS) send_to_system_link('Start19', 'BOOLEAN', 'false', ROGERS)
def RedMission(): # Red Run (Bench Mission (including backrest removal)) # UP BUTTON #!/usr/bin/env pybricks-micropython from pybricks.hubs import EV3Brick from pybricks.ev3devices import (Motor, TouchSensor, ColorSensor, InfraredSensor, UltrasonicSensor, GyroSensor) from pybricks.parameters import Port, Stop, Direction, Button, Color from pybricks.tools import wait, StopWatch, DataLog from pybricks.robotics import DriveBase from pybricks.media.ev3dev import SoundFile, ImageFile # This program requires LEGO EV3 MicroPython v2.0 or higher. # Click "Open user guide" on the EV3 extension tab for more information. # Create your objects here. ev3 = EV3Brick() left_motor = Motor(Port.C) right_motor = Motor(Port.B) wheel_diameter = 56 axle_track = 115 robot = DriveBase(left_motor, right_motor, wheel_diameter, axle_track) Medium_Motor = Motor(Port.A) Large_Motor = Motor(Port.D) leftcolorsensor = ColorSensor(Port.S3) rightcolorsensor = ColorSensor(Port.S2) robot.settings(500) robot.straight(290) robot.stop(Stop.BRAKE) robot.settings(700,400,700,400) robot.turn(110) robot.stop(Stop.BRAKE) while True: robot.drive(200,0) if leftcolorsensor.color() == Color.BLACK: robot.stop(Stop.BRAKE) break robot.stop(Stop.BRAKE) ev3.speaker.beep(3) robot.turn(-110) robot.straight(80) BLACK = 9 WHITE = 85 threshold = (BLACK + WHITE) / 2 # Set the drive speed at 100 millimeters per second. DRIVE_SPEED = 100 # Set the gain of the proportional line controller. This means that for every PROPORTIONAL_GAIN = 1.2 runWhile = True robot.reset() ev3.speaker.beep() while True: # Calculate the deviation from the threshold. deviation = rightcolorsensor.reflection() - threshold # Calculate the turn rate. turn_rate = PROPORTIONAL_GAIN * deviation # Set the drive base speed and turn rate. robot.drive(DRIVE_SPEED, turn_rate) wait(10) print(rightcolorsensor.color()) if robot.distance() >= 100: robot.stop(Stop.BRAKE) break robot.stop(Stop.BRAKE) BLACK = 9 WHITE = 85 threshold = (BLACK + WHITE) / 2 # Set the drive speed at 100 millimeters per second. DRIVE_SPEED = 100 # Set the gain of the proportional line controller. This means that for every PROPORTIONAL_GAIN = 1.2 runWhile = True robot.reset() while True: # Calculate the deviation from the threshold. deviation = rightcolorsensor.reflection() - threshold # Calculate the turn rate. turn_rate = PROPORTIONAL_GAIN * deviation # Set the drive base speed and turn rate. robot.drive(DRIVE_SPEED, turn_rate) wait(10) print(rightcolorsensor.color()) if leftcolorsensor.color() == Color.BLACK: robot.stop(Stop.BRAKE) break robot.turn(-25) robot.straight(230) Large_Motor.run_angle(50,100,then = Stop.HOLD, wait = True) robot.straight(-60) robot.turn(35) robot.straight(-10) Large_Motor.run_angle(50,-50,then = Stop.HOLD, wait = True) robot.straight(-85) robot.turn(-85) robot.straight(500) robot.turn(-20) robot.straight(250) Large_Motor.run_angle(50,-70,then = Stop.HOLD, wait = False) robot.turn(110) robot.stop(Stop.BRAKE)
wheel_diameter=26, axle_track=115) DRIVE_BASE.settings( straight_speed=750, # milimeters per second straight_acceleration=750, turn_rate=90, # degrees per second turn_acceleration=90) IR_SENSOR = InfraredSensor(port=Port.S4) MEDIUM_MOTOR.run_time(speed=-500, time=1000, then=Stop.COAST, wait=True) while IR_SENSOR.distance() >= 25: DRIVE_BASE.drive(speed=750, turn_rate=0) DRIVE_BASE.stop() EV3_BRICK.speaker.play_file(file=SoundFile.AIRBRAKE) MEDIUM_MOTOR.run_time(speed=500, time=1000, then=Stop.COAST, wait=True) DRIVE_BASE.turn(angle=180) while IR_SENSOR.distance() >= 25: DRIVE_BASE.drive(speed=750, turn_rate=0) DRIVE_BASE.stop() MEDIUM_MOTOR.run(speed=-500) EV3_BRICK.speaker.play_file(file=SoundFile.AIR_RELEASE)
class Bobb3e: WHEEL_DIAMETER = 24 # milimeters AXLE_TRACK = 100 # milimeters def __init__(self, left_motor_port: str = Port.B, right_motor_port: str = Port.C, lift_motor_port: str = Port.A, ir_sensor_port: str = Port.S4, ir_beacon_channel: int = 1): self.ev3_brick = EV3Brick() left_motor = Motor(port=left_motor_port, positive_direction=Direction.COUNTERCLOCKWISE) right_motor = Motor(port=right_motor_port, positive_direction=Direction.COUNTERCLOCKWISE) self.drive_base = DriveBase(left_motor=left_motor, right_motor=right_motor, wheel_diameter=self.WHEEL_DIAMETER, axle_track=self.AXLE_TRACK) self.lift_motor = Motor(port=lift_motor_port, positive_direction=Direction.CLOCKWISE) self.ir_sensor = InfraredSensor(port=ir_sensor_port) self.ir_beacon_channel = ir_beacon_channel self.reversing = False def drive_or_operate_forks_by_ir_beacon( self, driving_speed: float = 1000, # mm/s turn_rate: float = 90 # rotational speed deg/s ): """ Read the commands from the remote control and convert them into actions such as go forward, lift and turn. """ while True: ir_beacon_button_pressed = \ set(self.ir_sensor.buttons(channel=self.ir_beacon_channel)) # lower the forks if ir_beacon_button_pressed == {Button.LEFT_UP, Button.LEFT_DOWN}: self.reversing = False self.drive_base.stop() self.lift_motor.run(speed=100) # raise the forks elif ir_beacon_button_pressed == \ {Button.RIGHT_UP, Button.RIGHT_DOWN}: self.reversing = False self.drive_base.stop() self.lift_motor.run(speed=-100) # forward elif ir_beacon_button_pressed == {Button.LEFT_UP, Button.RIGHT_UP}: self.reversing = False self.drive_base.drive(speed=driving_speed, turn_rate=0) self.lift_motor.hold() # backward elif ir_beacon_button_pressed == \ {Button.LEFT_DOWN, Button.RIGHT_DOWN}: self.reversing = True self.drive_base.drive(speed=-driving_speed, turn_rate=0) self.lift_motor.hold() # turn left on the spot elif ir_beacon_button_pressed == \ {Button.LEFT_UP, Button.RIGHT_DOWN}: self.reversing = False self.drive_base.drive(speed=0, turn_rate=-turn_rate) self.lift_motor.hold() # turn right on the spot elif ir_beacon_button_pressed == \ {Button.RIGHT_UP, Button.LEFT_DOWN}: self.reversing = False self.drive_base.drive(speed=0, turn_rate=turn_rate) self.lift_motor.hold() # turn left forward elif ir_beacon_button_pressed == {Button.LEFT_UP}: self.reversing = False self.drive_base.drive(speed=driving_speed, turn_rate=-turn_rate) self.lift_motor.hold() # turn right forward elif ir_beacon_button_pressed == {Button.RIGHT_UP}: self.reversing = False self.drive_base.drive(speed=driving_speed, turn_rate=turn_rate) self.lift_motor.hold() # turn left backward elif ir_beacon_button_pressed == {Button.LEFT_DOWN}: self.reversing = True self.drive_base.drive(speed=-driving_speed, turn_rate=turn_rate) self.lift_motor.hold() # turn right backward elif ir_beacon_button_pressed == {Button.RIGHT_DOWN}: self.reversing = True self.drive_base.drive(speed=-driving_speed, turn_rate=-turn_rate) self.lift_motor.hold() # otherwise stop else: self.reversing = False self.drive_base.stop() self.lift_motor.hold() wait(10) def sound_alarm_whenever_reversing(self): while True: if self.reversing: self.ev3_brick.speaker.play_file(file=SoundFile.BACKING_ALERT) wait(10)
# Print ' 'Run.' ' near the middle of the screen brick.display.text("Run.", (60, 50)) # Print ' 'You Better Run' ' a little bit underneath it brick.display.text("You Better Run", (60, 70)) # Have the robot continue the loop for a certain number of times. while i > 0: # Spin Wings at full speed for 2 seconds motor3.run(400) # Have the robot drive at full speed until it senses something, and then stop right before it while sensor.distance() > 150: wait(10) robot.drive(400, 0) robot.stop(stop_type = Stop.BRAKE) # Have the robot play a laughing sound when it runs into something brick.sound.file(SoundFile.LAUGHING_1, 100) robot.drive_time(-200, 0, 1000) # Have the back wheel lift up motor4.run_time(100, 500) # Have the robot rotate robot.drive_time(0, 360, 1000) # Put the back wheel back on the ground motor4.run_time(-100, 500) #Have the robot stop going through that loop a certain number of times i = i-1 #Lift up the back wheel motor4.run_time(100, 500)
class Gripp3r(EV3Brick): WHEEL_DIAMETER = 26 AXLE_TRACK = 115 def __init__(self, left_motor_port: Port = Port.B, right_motor_port: Port = Port.C, grip_motor_port: Port = Port.A, touch_sensor_port: Port = Port.S1, ir_sensor_port: Port = Port.S4, ir_beacon_channel: int = 1): self.drive_base = DriveBase( left_motor=Motor(port=left_motor_port, positive_direction=Direction.CLOCKWISE), right_motor=Motor(port=right_motor_port, positive_direction=Direction.CLOCKWISE), wheel_diameter=self.WHEEL_DIAMETER, axle_track=self.AXLE_TRACK) self.drive_base.settings( straight_speed=750, # milimeters per second straight_acceleration=750, turn_rate=90, # degrees per second turn_acceleration=90) self.grip_motor = Motor(port=grip_motor_port, positive_direction=Direction.CLOCKWISE) self.touch_sensor = TouchSensor(port=touch_sensor_port) self.ir_sensor = InfraredSensor(port=ir_sensor_port) self.ir_beacon_channel = ir_beacon_channel def keep_driving_by_ir_beacon( self, channel: int = 1, speed: float = 1000 # milimeters per second ): while True: ir_beacon_buttons_pressed = set( self.ir_sensor.buttons(channel=channel)) # forward if ir_beacon_buttons_pressed == {Button.LEFT_UP, Button.RIGHT_UP}: self.drive_base.drive( speed=speed, turn_rate=0 # degrees per second ) # backward elif ir_beacon_buttons_pressed == { Button.LEFT_DOWN, Button.RIGHT_DOWN }: self.drive_base.drive( speed=-speed, turn_rate=0 # degrees per second ) # turn left on the spot elif ir_beacon_buttons_pressed == { Button.LEFT_UP, Button.RIGHT_DOWN }: self.drive_base.drive( speed=0, turn_rate=-90 # degrees per second ) # turn right on the spot elif ir_beacon_buttons_pressed == { Button.LEFT_DOWN, Button.RIGHT_UP }: self.drive_base.drive( speed=0, turn_rate=90 # degrees per second ) # turn left forward elif ir_beacon_buttons_pressed == {Button.LEFT_UP}: self.drive_base.drive( speed=speed, turn_rate=-90 # degrees per second ) # turn right forward elif ir_beacon_buttons_pressed == {Button.RIGHT_UP}: self.drive_base.drive( speed=speed, turn_rate=90 # degrees per second ) # turn left backward elif ir_beacon_buttons_pressed == {Button.LEFT_DOWN}: self.drive_base.drive( speed=-speed, turn_rate=90 # degrees per second ) # turn right backward elif ir_beacon_buttons_pressed == {Button.RIGHT_DOWN}: self.drive_base.drive( speed=-speed, turn_rate=-90 # degrees per second ) # otherwise stop else: self.drive_base.stop() def grip_or_release_by_ir_beacon(self, speed: float = 500): while True: if Button.BEACON in self.ir_sensor.buttons( channel=self.ir_beacon_channel): if self.touch_sensor.pressed(): self.speaker.play_file(file=SoundFile.AIR_RELEASE) self.grip_motor.run_time(speed=speed, time=1000, then=Stop.BRAKE, wait=True) else: self.speaker.play_file(file=SoundFile.AIRBRAKE) self.grip_motor.run(speed=-speed) while not self.touch_sensor.pressed(): pass self.grip_motor.stop() while Button.BEACON in self.ir_sensor.buttons( channel=self.ir_beacon_channel): pass def main(self, speed: float = 1000): self.grip_motor.run_time(speed=-500, time=1000, then=Stop.BRAKE, wait=True) Thread(target=self.grip_or_release_by_ir_beacon).start() self.keep_driving_by_ir_beacon(speed=speed)
def GreenMission(): #!/usr/bin/env pybricks-micropython from pybricks.hubs import EV3Brick from pybricks.ev3devices import (Motor, TouchSensor, ColorSensor, InfraredSensor, UltrasonicSensor, GyroSensor) from pybricks.parameters import Port, Stop, Direction, Button, Color from pybricks.tools import wait, StopWatch, DataLog from pybricks.robotics import DriveBase from pybricks.media.ev3dev import SoundFile, ImageFile # This program requires LEGO EV3 MicroPython v2.0 or higher. # Click "Open user guide" on the EV3 extension tab for more information. # Create your objects here. ev3 = EV3Brick() left_motor = Motor(Port.C) right_motor = Motor(Port.B) medium_motor = Motor(Port.A) front_largeMotor = Motor(Port.D) wheel_diameter = 56 axle_track = 114.3 robot = DriveBase(left_motor, right_motor, wheel_diameter, axle_track) ## Write your code here: robot.settings(300) ## The robot goes straight until the Boccia Mission's target. robot.straight(1050) ## The robot moves the large motor down to drop the cubes in the target. front_largeMotor.run_angle(80, 110, then=Stop.HOLD, wait=True) ## BOCCIA SHARE !!! robot.straight(-200) robot.turn(-100) robot.straight(130) front_largeMotor.run_angle(-80, 105, then=Stop.HOLD, wait=True) robot.straight(-30) robot.turn(-100) robot.straight(-80) robot.turn(-100) robot.turn(100) robot.turn(-100) robot.turn(100) robot.turn(-100) robot.turn(100) robot.turn(-100) robot.turn(100) ## Dance Mission ''' #The robot moves backwards to reach the Dance Floor so it can Dance as the last mission. robot.straight(-185) robot.turn(-80) robot.straight(110) ## The following code is all the dance moves we do for the Dance Mission. robot.turn(-75) robot.straight(50) front_largeMotor.run_angle(60, 50) robot.straight(40) front_largeMotor.run_angle(60, -50) robot.straight(-40) front_largeMotor.run_angle(60, 50) robot.straight(+30) front_largeMotor.run_angle(60, -50) robot.straight(-45) robot.turn(-500) robot.turn(500) front_largeMotor.run_angle(60, 50) robot.straight(92) front_largeMotor.run_angle(60, -50) robot.straight(-20) robot.straight(35) front_largeMotor.run_angle(60, -50) robot.straight(-60) robot.turn(100) robot.turn(-80) robot.turn(120) robot.turn(-400) large_motor.run_angle(20, -10) robot.straight(-30) robot.turn(-160) robot.straight(60) robot.straight(-60) robot.turn(260) robot.turn(-260) robot.turn(100) robot.straight(40) robot.turn(100) robot.straight(-25) ''' robot.stop(Stop.BRAKE)
class Robot: def __init__(self): """Class that represents the robot """ try: self.state = "Port 1: Right Color" self.right_color = ColorSensor(Port.S1) self.state = "Port 2: Center Color" self.center_color = ColorSensor(Port.S2) self.state = "Port 3: Left Color" self.left_color = ColorSensor(Port.S3) self.state = "Port 4: Gyro" self.gyro = GyroSensor(Port.S4, Direction.COUNTERCLOCKWISE) self.state = "Port A: Left Motor" self.left_motor = Motor(Port.A) self.state = "Port B: Right Motor" self.right_motor = Motor(Port.B) self.state = "Port C: Linear Gear" self.linear_attachment_motor = Motor(Port.C) self.state = "Port D: Block Dropper" self.dropper_attachment_motor = Motor(Port.D) self.wheel_diameter = 55 self.axle_track = 123 self.drive_base = DriveBase(self.left_motor, self.right_motor, self.wheel_diameter, self.axle_track) self.state = "OK" self.clock = StopWatch() self.dance_clock = 0 self.sign = 1 except: brick.screen.clear() big_font = Font(size=18) brick.screen.set_font(big_font) brick.screen.draw_text(0, 20, "Error!") brick.screen.draw_text(0, 40, self.state) def display_sensor_values(self): """Displays sensor values """ gyro_value = "Gyro : {}".format(self.gyro.angle()) left_color_value = "Left Color : {}".format( self.left_color.reflection()) right_color_value = "Right Color : {}".format( self.right_color.reflection()) center_color_value = "Center Color : {}".format( self.center_color.reflection()) big_font = Font(size=18) brick.screen.set_font(big_font) brick.screen.clear() brick.screen.draw_text(0, 20, gyro_value) brick.screen.draw_text(0, 40, left_color_value) brick.screen.draw_text(0, 60, right_color_value) brick.screen.draw_text(0, 80, center_color_value) def is_ok(self): """Tells if all sensors are plugged in :return: Checks the state of the sensors :rtype: Boolean """ return self.state == "OK" def beep(self, is_down=False): """Plays a series of beeps :param is_down: Tells if to play series downwards, defaults to False :type is_down: bool, optional """ beep_counts = range(1, 7) if not is_down else range(6, 0, -1) for beep_count in beep_counts: brick.speaker.beep(400 * beep_count, 100) wait(20) def drift_check(self): brick.speaker.beep(1200, 500) wait(100) brick.speaker.beep(1200, 500) drift = False start_gyro = self.gyro.angle() brick.screen.clear() big_font = Font(size=18) brick.screen.set_font(big_font) brick.screen.draw_text(0, 20, "Checking Gyro drift...") wait(2000) if start_gyro != self.gyro.angle(): brick.screen.draw_text(0, 60, "Error!") brick.screen.draw_text(0, 80, "Gyro drift") drift = True return drift def print_sensor_values(self): """Display robot sensor values. For debugging only """ print("Gyro: ", self.gyro.angle()) print("Left Color: ", self.left_color.reflection()) print("Right Color: ", self.right_color.reflection()) print("Center Color: ", self.center_color.reflection()) def stop_motors(self): """ Stops all motors """ self.left_motor.stop(Stop.BRAKE) self.right_motor.stop(Stop.BRAKE) self.linear_attachment_motor.stop(Stop.BRAKE) def drive(self, pid, speed, target_angle, duration): """Drives the robot using a gyro to a specific angle :param pid: Uses Pid instance with parameters set beforehand :type pid: Class :param speed: Speed of the robot :type speed: Number :param target_angle: Angle to drive the robot at :type target_angle: Number :param duration: Duration the function is run :type duration: Number """ # Inititialize values pid.reset() while pid.clock.time() < duration: # Calculatr error actual_angle = self.gyro.angle() error = (target_angle - actual_angle) % 360 error = error - (360 * int(error / 180)) # Calculate steering output steering = pid.compute_steering(error) # Drive the motors self.drive_base.drive(speed, steering) self.print_sensor_values # Stop motors self.drive_base.stop(Stop.BRAKE) def drive_dead_reckon(self, speed, duration, steering=0): self.drive_base.drive(speed, steering) wait(duration) self.drive_base.stop(Stop.BRAKE) def turn(self, pid, target_angle, tolerance=1): """Turns the robot to a specific angle. :param pid: Uses Pid instance with parameters set beforehand :type pid: Number :param target_angle: Angle the robot turns to :type target_angle: Number :param tolerance: How close to the target angle you want the robot to be :type tolerance: Number """ # Inititialize values pid.reset() error = tolerance + 1 min_speed = 50 while abs(error) > tolerance: # Calculate error actual_angle = self.gyro.angle() error = (target_angle - actual_angle) % 360 error = error - (360 * int(error / 180)) # Call Pid compute_steering steering = pid.compute_steering(error) * -1 # Set speed using a min_speed right_speed = max(min_speed, abs(steering)) if steering < 0: right_speed = -1 * right_speed left_speed = -1 * right_speed # Run motors self.left_motor.run(left_speed) self.right_motor.run(right_speed) # Stop motors self.left_motor.stop() self.right_motor.stop() def follow_line(self, pid, speed, duration, which_sensor, which_edge): """Follows the line using a color sensor. :param pid: Uses Pid instance with parameters set beforehand :type pid: Pid :param speed: Speed of the Robot :type speed: Number :param duration: Duration of the function :type duration: Number :param which_sensor: The sensor the robot uses to follow the line :type which_sensor: LineSensor :param which_edge: Which side the white is on relative to the robot :type which_edge: LineEdge """ # Inititialize values pid.reset() while pid.clock.time() < duration: # Selecting which sensor to use using an Enum if which_sensor == LineSensor.RIGHT: error = 50 - self.right_color.reflection() if which_sensor == LineSensor.LEFT: error = 50 - self.left_color.reflection() if which_sensor == LineSensor.CENTER: error = 50 - self.center_color.reflection() # Selecting which edge of the line to use if which_edge == LineEdge.RIGHT: pass else: error = error * -1 # Calculate steering steering = pid.compute_steering(error) # Run motors self.drive_base.drive(speed, steering) self.drive_base.stop(Stop.BRAKE) def stop_on_white(self, pid, speed, target_angle, which_sensor, color_value=80): """ Gyro drives until given color sensor is on white :param pid: PID setting of drive :type pid: Number :param speed: The speed the robot moves at :type speed: Number :param target_angle: the angle the gyro drives at :type target_angle: :param which_sensor: Chooses which color sensor to use :type which_sensor: Enum :param color_value: The value of color that the robot stops at :type color_value: Number """ # Inititialize values sensor = 0 pid.reset() target_angle = target_angle % 360 if which_sensor == LineSensor.LEFT: sensor = self.left_color elif which_sensor == LineSensor.RIGHT: sensor = self.right_color else: sensor = self.center_color while sensor.reflection() < color_value: # Calculate error actual_angle = self.gyro.angle() error = (target_angle - actual_angle) % 360 error = error - (360 * int(error / 180)) # Calculate steering output steering = pid.compute_steering(error) # Drive the motors self.drive_base.drive(speed, steering) self.print_sensor_values # Stop motors self.drive_base.stop(Stop.BRAKE) def stop_on_black(self, pid, speed, target_angle, which_sensor, color_value=15): """ Gyro drives until given color sensor is on black :param pid: PID setting of drive :type pid: Number :param speed: The speed the robot moves at :type speed: Number :param target_angle: the angle the gyro drives at :type target_angle: :param which_sensor: Chooses which color sensor to use :type which_sensor: Enum :param color_value: The value of color that the robot stops at :type color_value: Number """ # Inititialize values sensor = 0 pid.reset() target_angle = target_angle % 360 if which_sensor == LineSensor.LEFT: sensor = self.left_color elif which_sensor == LineSensor.RIGHT: sensor = self.right_color else: sensor = self.center_color while sensor.reflection() > color_value: # Calculate error actual_angle = self.gyro.angle() error = (target_angle - actual_angle) % 360 error = error - (360 * int(error / 180)) # Calculate steering output steering = pid.compute_steering(error) # Drive the motors self.drive_base.drive(speed, steering) self.print_sensor_values # Stop motors self.drive_base.stop(Stop.BRAKE) def align(self, speed, sensor1, sensor2): """Aligns using color sensors on black line :param speed: The speed the robot moves at :type speed: Number :param sensor1: The first sensor the robot uses to align :type sensor1: Enum :param sensor2: The second sensor the robot uses to align :type sensor2: Enum """ self.left_motor.run(speed) self.right_motor.run(speed) first_sensor = 0 second_sensor = 0 if sensor1 == LineSensor.LEFT: first_sensor = self.left_color elif sensor1 == LineSensor.RIGHT: first_sensor = self.right_color else: first_sensor = self.center_color if sensor2 == LineSensor.LEFT: second_sensor = self.left_color elif sensor2 == LineSensor.RIGHT: second_sensor = self.right_color else: second_sensor = self.center_color while True: first = False second = False if first_sensor.reflection() <= 10: self.left_motor.hold() first = True if second_sensor.reflection() <= 10: self.right_motor.hold() second = True if first and second == True: break def reset_sensors(self, reset_angle=0): """Reset the robot's sensor values :param reset_angle: inital angle for the gyro, defaults to 0 :type reset_angle: int, optional """ # Resets the gyro self.gyro.reset_angle(reset_angle) def run_linear(self, speed, time, wait=True): """Runs linear gear :param speed: The speed the linear gear moves at :type speed: Number :param time: How long the linear gear runs for :type time: Number :param wait: Wait for action to complete before next step :type wait: Boolean """ self.stop_motors() self.linear_attachment_motor.run_time(speed, time, Stop.BRAKE, wait) def move_linear(self, speed, rotations, wait=True): """Will calculate the ratio of the gears and then move the linear gear to a specific angle :param speed: The speed the linear gear moves at :type speed: Number :param rotations: How much the linear gear moves by in rotations :type rotations: Number :param wait: Wait for action to complete before next step :type wait: Boolean """ self.stop_motors() target_angle = rotations * 360 self.linear_attachment_motor.run_angle(speed, target_angle, Stop.BRAKE, wait) def run_dropper(self, speed, time, wait=True): """Runs block dropper :param speed: The speed the yeeter moves at :type speed: Number :param time: How long the yeeter runs for :type time: Number :param wait: Wait for action to complete before next step :type wait: Boolean """ self.stop_motors() self.dropper_attachment_motor.run_time(speed, time, Stop.BRAKE, wait) def move_dropper(self, speed, degrees, wait=True): """Will calculate the ratio of the gears and then move the block dropper to a specific angle :param speed: The speed the yeeter moves at :type speed: Number :param degrees: How much the yeeter moves by in degrees :type degrees: Number :param wait: Wait for action to complete before next step :type wait: Boolean """ self.stop_motors() self.dropper_attachment_motor.run_angle(speed, degrees, Stop.BRAKE, wait) def dance(self, speed, duration): if self.dance_clock == 0: self.dance_clock = self.clock.time() self.left_motor.run(speed * self.sign * -1) self.right_motor.run(speed * self.sign) if self.clock.time() - self.dance_clock > duration: self.sign *= -1 self.left_motor.run(speed * self.sign * -1) self.right_motor.run(speed * self.sign) self.dance_clock = self.clock.time() return True return False
def BlueMission(): # Blue Run (Step Counter, Pull-Up Bar, Boccia Aim, Slide, Health Unit - 1) # DOWN BUTTON #!/usr/bin/env pybricks-micropython from pybricks.hubs import EV3Brick from pybricks.ev3devices import (Motor, TouchSensor, ColorSensor, InfraredSensor, UltrasonicSensor, GyroSensor) from pybricks.parameters import Port, Stop, Direction, Button, Color from pybricks.tools import wait, StopWatch, DataLog from pybricks.robotics import DriveBase from pybricks.media.ev3dev import SoundFile, ImageFile # This program requires LEGO EV3 MicroPython v2.0 or higher. # Click "Open user guide" on the EV3 extension tab for more information. #define your variables ev3 = EV3Brick() left_motor = Motor(Port.C) right_motor = Motor(Port.B) medium_motor = Motor(Port.A) large_motor = Motor(Port.D) wheel_diameter = 56 axle_track = 115 line_sensor = ColorSensor(Port.S2) line_sensor1 = ColorSensor(Port.S3) robot = DriveBase(left_motor, right_motor, wheel_diameter, axle_track) # Go towards the step counter mission from base robot.settings(800) # Speed Change robot.straight(650) robot.stop(Stop.BRAKE) wait(20) # Slow the robot down to succesfully push the step counter. robot.settings(200) # Slowly pushes the step counter by going backward and forward a couple times to increase reliability. robot.straight(230) robot.straight(-20) robot.straight(50) robot.stop(Stop.BRAKE) #robot.straight(-45) #robot.stop(Stop.BRAKE) #robot.straight(120) #robot.stop(Stop.BRAKE) robot.straight(-60) robot.stop(Stop.BRAKE) # The robot then turns and goes backwards until the right color sensor detects black. #robot.settings(250,300,250,300) robot.turn(45) robot.straight(-100) while True: robot.drive(-100,0) if line_sensor.color() == Color.BLACK: robot.stop(Stop.BRAKE) break #The large motor attatchment comes down at the same time the robot takes a turn towards #the black line underneath the pull up bar left_motor.run_angle(50,-300,then=Stop.HOLD, wait=True) # The robot then goes straight towards the line under the pull-up bar. robot.straight(120) robot.stop(Stop.BRAKE) # Robot continues to go forwards until the left color sensor detects black. while True: robot.drive(115,0) if line_sensor.color() == Color.BLACK: robot.stop(Stop.BRAKE) break right_motor.run_angle(100,150,then=Stop.HOLD, wait=True) # The robot turns using the right motor until it detects black. while True: right_motor.run(100) if line_sensor.color() == Color.BLACK: robot.stop(Stop.BRAKE) break robot.straight(-90) large_motor.run_angle(100,150,then=Stop.HOLD, wait=True) robot.stop(Stop.BRAKE) robot.stop(Stop.BRAKE) while True: right_motor.run(40) if line_sensor.color() == Color.BLACK: robot.stop(Stop.BRAKE) break robot.stop(Stop.BRAKE) ev3.speaker.beep() BLACK = 9 WHITE = 85 threshold = (BLACK + WHITE) / 2 # Set the drive speed at 100 millimeters per second. DRIVE_SPEED = 100 # Set the gain of the proportional line controller. This means that for every PROPORTIONAL_GAIN = 1.2 runWhile = True robot.reset() ev3.speaker.beep() while True: # Calculate the deviation from the threshold. deviation = line_sensor.reflection() - threshold # Calculate the turn rate. turn_rate = PROPORTIONAL_GAIN * deviation # Set the drive base speed and turn rate. robot.drive(DRIVE_SPEED, turn_rate) wait(10) print(line_sensor1.color()) if line_sensor1.color() == Color.BLACK: robot.stop(Stop.BRAKE) break robot.stop(Stop.BRAKE) robot.stop(Stop.BRAKE) large_motor.run_angle(-150, 150, then=Stop.HOLD, wait=False) robot.turn(20) robot.stop(Stop.BRAKE) robot.settings(800) robot.straight(280) ev3.speaker.beep(3) while True: robot.drive(-115,0) if line_sensor.color() == Color.BLACK: ev3.speaker.beep(10) robot.stop(Stop.BRAKE) break robot.stop(Stop.BRAKE) # robot.straight(-10) robot.stop(Stop.BRAKE) robot.turn(50) # left_motor.run_angle(100, 150) ''' large_motor.run_angle(30,-20,then=Stop.HOLD, wait=False) robot.turn(10) robot.stop(Stop.BRAKE) large_motor.run_angle(100, -50, then=Stop.HOLD, wait=False) robot.turn(90) robot.stop(Stop.BRAKE) ''' BLACK = 9 WHITE = 85 threshold = (BLACK + WHITE) / 2 # Set the drive speed at 100 millimeters per second. DRIVE_SPEED = 100 # Set the gain of the proportional line controller. This means that for every PROPORTIONAL_GAIN = 1.2 runWhile = True robot.reset() ev3.speaker.beep() while True: # Calculate the deviation from the threshold. deviation = line_sensor.reflection() - threshold # Calculate the turn rate. turn_rate = PROPORTIONAL_GAIN * deviation # Set the drive base speed and turn rate. robot.drive(DRIVE_SPEED, turn_rate) wait(10) print(line_sensor.color()) if robot.distance() >= 500: robot.stop(Stop.BRAKE) break ev3.speaker.beep(3) while True: robot.drive(40,0) if line_sensor1.color() == Color.BLACK: robot.stop(Stop.BRAKE) break robot.stop(Stop.BRAKE) ev3.speaker.beep() robot.straight(30) robot.turn(-100) robot.straight(70) large_motor.run_angle(600,150,then=Stop.HOLD, wait=True) while True: robot.drive(-50, 0) if line_sensor1.color() == Color.BLACK: robot.stop(Stop.BRAKE) break robot.stop(Stop.BRAKE) right_motor.run_angle(600,500,then=Stop.HOLD,wait=True) robot.straight(20) BLACK = 9 WHITE = 85 threshold = (BLACK + WHITE) / 2 # Set the drive speed at 100 millimeters per second. DRIVE_SPEED = 100 # Set the gain of the proportional line controller. This means that for every PROPORTIONAL_GAIN = 1.2 runWhile = True robot.reset() ev3.speaker.beep() while True: # Calculate the deviation from the threshold. deviation = line_sensor1.reflection() - threshold # Calculate the turn rate. turn_rate = PROPORTIONAL_GAIN * deviation # Set the drive base speed and turn rate. robot.drive(DRIVE_SPEED, turn_rate) wait(10) print(line_sensor1.color()) if robot.distance() >= 580: robot.stop(Stop.BRAKE) break robot.stop(Stop.BRAKE) while True: robot.drive(50, 0) if line_sensor.color() == Color.BLACK: robot.stop(Stop.BRAKE) break robot.stop(Stop.BRAKE) ev3.speaker.beep(3) robot.turn(-45) robot.stop(Stop.BRAKE) robot.straight(30) large_motor.run_angle(1000,-150,then=Stop.HOLD, wait=True) robot.straight(-40) large_motor.run_angle(1000,150,then=Stop.HOLD, wait=True) robot.straight(40) large_motor.run_angle(1000,-150,then=Stop.HOLD, wait=True) robot.straight(-115) robot.turn(95) robot.straight(420) robot.turn(-100) robot.turn(100) robot.turn(-100) robot.turn(100) robot.turn(-100) robot.turn(100) robot.turn(-100) robot.turn(100) robot.turn(-100) robot.turn(100) robot.turn(-100) robot.turn(100) robot.turn(-100) robot.turn(100) robot.turn(-100) robot.turn(100) robot.turn(-100) robot.turn(100) robot.turn(-100) robot.turn(100) robot.turn(-100) robot.turn(100) robot.turn(-100) robot.turn(100) robot.turn(-100) robot.turn(100) robot.turn(-100) robot.turn(100) robot.turn(-100) robot.turn(100) robot.turn(-100) robot.turn(100)
class Rac3Truck: WHEEL_DIAMETER = 30 # milimeters AXLE_TRACK = 120 # milimeters def __init__( self, left_motor_port: str = Port.B, right_motor_port: str = Port.C, polarity: str = 'inversed', steer_motor_port: str = Port.A, ir_sensor_port: str = Port.S4, ir_beacon_channel: int = 1): if polarity == 'normal': self.left_motor = Motor(port=left_motor_port, positive_direction=Direction.CLOCKWISE) self.right_motor = Motor(port=right_motor_port, positive_direction=Direction.CLOCKWISE) else: self.left_motor = \ Motor(port=left_motor_port, positive_direction=Direction.COUNTERCLOCKWISE) self.right_motor = \ Motor(port=right_motor_port, positive_direction=Direction.COUNTERCLOCKWISE) self.driver = DriveBase(left_motor=self.left_motor, right_motor=self.right_motor, wheel_diameter=self.WHEEL_DIAMETER, axle_track=self.AXLE_TRACK) self.steer_motor = Motor(port=steer_motor_port, positive_direction=Direction.CLOCKWISE) self.ir_sensor = InfraredSensor(port=ir_sensor_port) self.ir_beacon_channel = ir_beacon_channel def reset(self): self.steer_motor.run_time( speed=300, time=1500, then=Stop.COAST, wait=True) self.steer_motor.run_angle( speed=-500, rotation_angle=120, then=Stop.HOLD, wait=True) self.steer_motor.reset_angle(angle=0) def steer_left(self): if self.steer_motor.angle() > -65: self.steer_motor.run_target( speed=-200, target_angle=-65, then=Stop.HOLD, wait=True) else: self.steer_motor.hold() def steer_right(self): if self.steer_motor.angle() < 65: self.steer_motor.run_target( speed=200, target_angle=65, then=Stop.HOLD, wait=True) else: self.steer_motor.hold() def steer_center(self): if self.steer_motor.angle() < -7: self.steer_motor.run_target( speed=200, target_angle=4, then=Stop.HOLD, wait=True) elif self.steer_motor.angle() > 7: self.steer_motor.run_target( speed=-200, target_angle=-4, then=Stop.HOLD, wait=True) self.steer_motor.hold() wait(100) def drive_by_ir_beacon(self): ir_beacon_button_pressed = \ set(self.ir_sensor.buttons(channel=self.ir_beacon_channel)) # forward if ir_beacon_button_pressed == {Button.LEFT_UP, Button.RIGHT_UP}: self.driver.drive( speed=800, turn_rate=0) self.steer_center() # backward elif ir_beacon_button_pressed == {Button.LEFT_DOWN, Button.RIGHT_DOWN}: self.driver.drive( speed=-800, turn_rate=0) self.steer_center() # turn left forward elif ir_beacon_button_pressed == {Button.LEFT_UP}: self.left_motor.run(speed=600) self.right_motor.run(speed=1000) self.steer_left() # turn right forward elif ir_beacon_button_pressed == {Button.RIGHT_UP}: self.left_motor.run(speed=1000) self.right_motor.run(speed=600) self.steer_right() # turn left backward elif ir_beacon_button_pressed == {Button.LEFT_DOWN}: self.left_motor.run(speed=-600) self.right_motor.run(speed=-1000) self.steer_left() # turn right backward elif ir_beacon_button_pressed == {Button.RIGHT_DOWN}: self.left_motor.run(speed=-1000) self.right_motor.run(speed=-600) self.steer_right() # otherwise stop else: self.driver.stop() self.steer_center()
# Initialize the drive base. robot = DriveBase(left_motor, right_motor, wheel_diameter=55.5, axle_track=104) ev3.screen.draw_text(50, 60, "Pigeons!") ev3.speaker.beep() robot.settings(1000 ,250 ,150 ,100) robot.straight(950) robot.turn(87) robot.straight(400) robot.turn(90) robot.straight(780) ev3.speaker.beep() robot.turn(-93) robot.straight(350) robot.turn(-90) robot.straight(1500) robot.stop() robot.settings(1000 ,1000 ,1000000 ,100000) ev3.scren.draw_text(50, 60, "Pigeons!")
def BlueMission(): #!/usr/bin/env pybricks-micropython from pybricks.hubs import EV3Brick from pybricks.ev3devices import (Motor, TouchSensor, ColorSensor, InfraredSensor, UltrasonicSensor, GyroSensor) from pybricks.parameters import Port, Stop, Direction, Button, Color from pybricks.tools import wait, StopWatch, DataLog from pybricks.robotics import DriveBase from pybricks.media.ev3dev import SoundFile, ImageFile # This program requires LEGO EV3 MicroPython v2.0 or higher. # Click "Open user guide" on the EV3 extension tab for more information. #define your variables ev3 = EV3Brick() left_motor = Motor(Port.C) right_motor = Motor(Port.B) medium_motor = Motor(Port.A) large_motor = Motor(Port.D) wheel_diameter = 56 axle_track = 115 line_sensor = ColorSensor(Port.S2) line_sensor1 = ColorSensor(Port.S3) robot = DriveBase(left_motor, right_motor, wheel_diameter, axle_track) #go front towards the step counter robot.settings(250) robot.straight(650) robot.stop(Stop.BRAKE) wait(20) #makes the robot go slower robot.settings(40) #slowly pushes the step counter by going back and front 2 times robot.straight(140) robot.stop(Stop.BRAKE) robot.straight(-45) robot.stop(Stop.BRAKE) robot.straight(120) robot.stop(Stop.BRAKE) robot.straight(-30) robot.stop(Stop.BRAKE) #the robot then turns and goes backwards robot.settings(250,500,250,500) robot.turn(45) robot.straight(-100) # the robot then goes back until the right color sensor detects back while True: robot.drive(-115,0) if line_sensor.color() == Color.BLACK: robot.stop(Stop.BRAKE) break #the large motor attatchment comes down at the same time the robot takes a turn towards the black line underneath the pull up bar large_motor.run_angle(50,200,then=Stop.HOLD, wait=False) left_motor.run_angle(50,-300,then=Stop.HOLD, wait=True) #the robot then goes straight towards that line robot.straight(120) robot.stop(Stop.BRAKE) #robot continues to go forwards until the left color sensor detects black while True: robot.drive(115,0) if line_sensor.color() == Color.BLACK: robot.stop(Stop.BRAKE) break right_motor.run_angle(50,150,then=Stop.HOLD, wait=True) #the robot then turns with the right motor until it detects black while True: right_motor.run(85) if line_sensor.color() == Color.BLACK: robot.stop(Stop.BRAKE) break #follows the line underneath the pull up bar until the leftsensor detects black #follows the line underneath the pull up bar until the leftsensor detects black BLACK = 9 WHITE = 85 threshold = (BLACK + WHITE) / 2 # Set the drive speed at 100 millimeters per second. DRIVE_SPEED = 100 # Set the gain of the proportional line controller. This means that for every PROPORTIONAL_GAIN = 1.2 runWhile = True robot.reset() while True: # Calculate the deviation from the threshold. deviation = line_sensor.reflection() - threshold # Calculate the turn rate. turn_rate = PROPORTIONAL_GAIN * deviation # Set the drive base speed and turn rate. robot.drive(DRIVE_SPEED, turn_rate) wait(10) print(line_sensor1.color()) if line_sensor1.color() == Color.BLACK: robot.stop(Stop.BRAKE) break #the robot then turns towards the boccia aim and moves straight to push it towards the target and finishes the misison robot.turn(25) robot.straight(250) robot.straight(-50) # this is importate kekekekee large_motor.run_angle(75,-65) robot.straight(-60) while True: robot.drive(-70,0) if line_sensor.color() == Color.BLACK: robot.stop(Stop.BRAKE) ev3.speaker.beep() break while True: left_motor.run(-50) if line_sensor1.color() == Color.BLACK: robot.stop(Stop.BRAKE) ev3.speaker.beep() break left_motor.run_angle(50, -20) right_motor.run_angle(50, 20) robot.settings(200) robot.straight(60) robot.turn(-137) #this is also importante jekeke large_motor.run_angle(50,80) robot.straight(143) large_motor.run_angle(550, -120) robot.straight(-40) large_motor.run_angle(550, 120) robot.straight(40) large_motor.run_angle(550, -120) large_motor.run_angle(300, 30, then=Stop.HOLD, wait=True) #robot.straight(40) large_motor.run_angle(300, -100, then=Stop.HOLD, wait=True) #goes to collect the health unit near the basketball (goes back to base) robot.straight(-200) robot.turn(40) robot.straight(556) robot.straight(50) robot.stop(Stop.BRAKE) while True: left_motor.run(50) if line_sensor1.color() == Color.BLACK: robot.stop(Stop.BRAKE) ev3.speaker.beep() break robot.stop(Stop.BRAKE) robot.reset() # Calculate the light threshold. Choose values based on your measurements. BLACK = 9 WHITE = 85 threshold = (BLACK + WHITE) / 2 # Set the drive speed at 100 millimeters per second. DRIVE_SPEED = 100 # Set the gain of the proportional line controller. This means that for every # percentage point of light deviating from the threshold, we set the turn # rate of the drivebase to 1.2 degrees per second. # For example, if the light value deviates from the threshold by 10, the robot # steers at 10*1.2 = 12 degrees per second. PROPORTIONAL_GAIN = 1.2 runWhile = True # Start following the line endlessly. while runWhile: # Calculate the deviation from the threshold. deviation = line_sensor1.reflection() - threshold # Calculate the turn rate. turn_rate = PROPORTIONAL_GAIN * deviation # Set the drive base speed and turn rate. robot.drive(DRIVE_SPEED, turn_rate) if robot.distance() >= 210: runWhile = False break robot.stop(Stop.BRAKE) robot.turn(5.244312) robot.straight(700) #the robot then goes back until the right color sensor detects back ''' while True: if line_sensor1.color() == Color.BLACK: robot.stop(Stop.BRAKE) break #robot.straight(980) ''' robot.stop(Stop.BRAKE)