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()
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)
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 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 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)
gyro_sensor = GyroSensor(Port.S3) # Initialize the color sensor. #line_sensor = ColorSensor(Port.S3) left_motor.reset_angle(0) right_motor.reset_angle(0) gyro_sensor.reset_angle(0) fudge=1 speed=100 angle=0 robot = DriveBase(left_motor, right_motor, wheel_diameter=30, axle_track=135) initial_distance = 0 robot.reset() while ((robot.distance() - initial_distance) < 350) : robot.drive(speed,angle) drift = gyro_sensor.angle() angle = (drift * fudge) * -1 wait(3) i=0 robot.stop() speed=50 while (i<2 ): fruit = gyro_sensor.angle() fruit = fruit * (-1) robot.drive(speed,fruit) wait(3) robot.drive((speed* (-1)),fruit) i = i + 1
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)
right_motor = Motor(Port.C) # Initialize the drive base. robot = DriveBase(left_motor, right_motor, wheel_diameter=54.6, axle_track=104.1) ################################################################################# ev3.screen.draw_text(50, 60, "Pigeons!") ev3.speaker.beep() # straight robot.reset() while robot.distance() < 700: robot.drive(300 ,0) # turn left robot.reset() while robot.distance() < 600: robot.drive(300 ,87) # straight robot.reset() while robot.distance() < 325: robot.drive(300 ,0) # turn right robot.reset() while robot.distance() < 600:
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)
# 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() == 1040: runWhile = False # robot stops after finishing up line following code robot.stop(Stop.BRAKE) Large_Motor.run_angle(-100, 100, then=Stop.HOLD, wait=True) robot.straight(-40)
# 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() == 1400: runWhile = False # 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 80 degrees robot.turn(90) # robot goes straight towards the mission to line the attachment to the wheel
wait(3) # need to wait until angle set to zero, then recalibrated # have not tested this... while abs(gyro.angle()) != 0 gyro.reset_angle(0) ev3.speaker.beep() ev3.speaker.beep() ################################################################################# ev3.screen.draw_text(50, 60, "Pigeons!") recalibrateGyro() while robot.distance() < 500: robot.drive(1000, 0) robot.reset() gyro.reset_angle(0) angle = gyro.angle() print ( "gyro1 " + str(angle) ) while abs(angle) < 160: print ( "gyro2 " + str(angle) ) print ( "drive " + str(robot.angle() ) ) robot.drive(10, -180) angle = gyro.angle() robot.reset() while robot.distance() < 500: robot.drive(1000, 0)
# Initialize the motors. left_motor = Motor(Port.B) right_motor = Motor(Port.C) left_motor.reset_angle(0) right_motor.reset_angle(0) # Initialize the drive base. robot = DriveBase(left_motor, right_motor, wheel_diameter=54.6, axle_track=104.1) ################################################################################# ev3.screen.draw_text(50, 60, "Pigeons!") x = 0 while x < 8: ### straight (if run motor faster, must adjust distance) robot.reset() while robot.distance() < 250: robot.drive(200, 0) ### turn (if run motor faster, must adjust angle) robot.reset() while abs(robot.angle()) < 90: print("angle: " + str(abs(robot.angle()))) robot.drive(200, 150) x = x + 1
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)
gyroSensor.reset_angle(0) oldstraight(400, 250) oldstraight(100, 150) wait(500) oldstraight(500, -500) while Button.CENTER not in ev3.buttons.pressed(): pass #ev3.speaker.say('Run 2b') #slide accangle = 0 gyroSensor.reset_angle(0) straight(550, 350, Kd=0.04) wait(1000) while robot.distance() > -100: robot.drive(-200, -2) while robot.distance() > -500: robot.drive(-250, 20) robot.stop() while Button.CENTER not in ev3.buttons.pressed(): pass #treadmill accangle = 0 gyroSensor.reset_angle(0) straight(270, 200) line_follow(rightcolor, 175, 1.6, 0.04, 0.1, 0.01, 1200) # arives at treadmill #turntoangle(0.01) robot.drive(95, -1.5) #80, -2
from pybricks.ev3devices import Motor from pybricks.parameters import Port from pybricks.robotics import DriveBase from pybricks.tools import wait # Initialize the EV3 Brick. ev3 = EV3Brick() # Initialize the motors. left_motor = Motor(Port.B) right_motor = Motor(Port.C) # Initialize the drive base. robot = DriveBase(left_motor, right_motor, wheel_diameter=54.6, axle_track=104.1) ################################################################################# ev3.screen.draw_text(50, 60, "Pigeons!") ev3.speaker.beep() #robot.settings(1000 ,250 ,150 ,100) robot.straight(700) while robot.distance() < 800: robot.drive(250, 180) robot.straight(700)
self.last_time = self.current_time self.last_error = error self.output = self.PTerm + (self.Ki * self.ITerm) + (self.Kd * self.DTerm) def setSampleTime(self, sample_time): """PID that should be updated at a regular interval. Based on a pre-determined sample time, the PID decides if it should compute or return immediately. """ self.sample_time = sample_time pid = PID(0.9, 1, 0.001) pid.setSampleTime(0.01) pid.SetPoint = (black + white) / 2 feedback = rightcolor.reflection() while robot.distance() < 260: pid.update(feedback) robot.drive(200, pid.output) feedback = rightcolor.reflection() #robot.turn(60) #robot.reset() #while robot.distance() < 500: # pid.update(feedback) # robot.drive(200, pid.output) # feedback = rightcolor.reflection() #robot.turn(80) #robot.straight(230) #robot.straight(-150)