class Robot:
def __init__(self,leftMotor,rightMotor,lightSensor,gyroSensor):
self.drivebase = DriveBase(left,rightMotor,56,105)
self.lightSensor = lightSensor
def driveForward(self,time):
self.drivebase.drive_time(300,0,time*100)
def driveTillBlack(self,speed)
from pybricks.hubs import EV3Brick from pybricks.ev3devices import Motor from pybricks.parameters import Port, Stop, Direction, Button, Color from pybricks.tools import wait, StopWatch, DataLog from pybricks.robotics import DriveBase # SETUP SECTION # Initialize the EV3 Brick. # We'll call "brick" every time we want the brick to do something brick = EV3Brick() brick.speaker.beep() # Initialize the motors. left_motor = Motor(Port.B) right_motor = Motor(Port.C) # Initialize the drive base. # The DriveBase function will set up the driving mechanic to move both wheels together # We just need to say which motors we want to use as well as the wheels and the axle track # We'll call "robot" every time we want the robot to move robot = DriveBase(left_motor, right_motor, wheel_diameter=56, axle_track=114) # START ROBOT SECTION # Now that we're all set up, let's tell the robot what to do! # Let's make it beep, wait 2 seconds, and then beep again so we know it's ready wait(100) brick.speaker.beep() robot.drive_time(1000) robot.straight(999999)
#!/usr/bin/env pybricks-micropython
from pybricks import ev3brick as brick
from pybricks.ev3devices import (Motor, TouchSensor, ColorSensor,
InfraredSensor, UltrasonicSensor, GyroSensor)
from pybricks.parameters import (Port, Stop, Direction, Button, Color,
SoundFile, ImageFile, Align)
from pybricks.tools import print, wait, StopWatch
from pybricks.robotics import DriveBase
# Write your program here
brick.sound.beep()
left = Motor(Port.B)
right = Motor(Port.C)
robot = DriveBase(left, right, 56, 114)
while True:
robot.drive_time(500, 0, 10000)
robot.drive_time(500, 90, 5000)
robot.drive_time(500, 90, 4000)
robot.drive_time(500, 90, 5000)
robot.drive_time(500, -90, 5000)
class Robot:
def __init__(self):
# micro controller
ev3 = EV3Brick()
ev3.speaker.beep()
# sensors
# low value = registers black tape
# high value = aluminum
self.sensorYellow = ColorSensor(Port.S1)
self.sensorRed = ColorSensor(Port.S3)
self.sensorBlue = ColorSensor(Port.S2)
# motor
left_motor = Motor(Port.A, gears=[40, 24])
right_motor = Motor(Port.B, gears=[40, 24])
axle_track = 205
wheel_diameter = 35
self.motors = DriveBase(left_motor, right_motor,
wheel_diameter, axle_track)
# constants
# intersection detection of side sensors
self.thresholdBlueSensor = 30
# value for making turns
self.thresholdSideSensors = 15
# timer
self.watch = StopWatch()
self.timer = 0
def drive(self, directions):
i = 0
while i < len(directions):
self.timer = self.watch.time()
if self.timer % 100 == 0:
print(self.timer)
self.correctPath()
if self.senseIntersection() == True and self.timer >= 500:
print('intersection')
self.motors.drive_time(0, 0, 1000) # reduce this when done
self.executeCommand(directions[i])
i += 1
self.motors.drive(-125, 0)
def executeCommand(self, cmd):
if cmd == 0:
print('straight')
self.driveStraight()
if cmd == 1:
print('right')
self.turnRight()
if cmd == 2:
print('left')
self.turnLeft()
if cmd == 3:
print('reverse')
self.reverse()
if cmd == 4:
print('stop')
# turning behaviours at intersection
def turnLeft(self):
self.motors.drive_time(-30, 44, 2000)
self.watch.reset()
def turnRight(self):
self.motors.drive_time(-30, -46, 2000)
self.watch.reset()
def driveStraight(self):
self.motors.drive_time(-60, 0, 1800)
self.watch.reset()
def reverse(self):
self.motors.drive_time(60, 0, 1800)
self.motors.drive_time(0, 94, 2000)
self.motors.drive_time(-60, 0, 800)
# intersection detection
def senseIntersection(self):
if self.sensorRed.reflection() < 2 or self.sensorYellow.reflection() < 2:
return True
# path correction
# completely aluminum = 23
# completely black tape = 1
def correctPath(self):
if self.sensorBlue.reflection() < 8:
self.adjustLeft()
if self.sensorBlue.reflection() > 16:
self.adjustRight()
# default: -125, angle
def adjustLeft(self):
angle = 12 - min(self.sensorBlue.reflection(), 10)
step = 125 + (12 - min(self.sensorBlue.reflection(), 10))
self.motors.drive(-step, angle)
def adjustRight(self):
angle = max(self.sensorBlue.reflection(), 14) -12
step = 125 + (max(self.sensorBlue.reflection(), 14) -12)
self.motors.drive(-step, -angle)
from pybricks.parameters import (Port, Stop, Direction, Button, Color,
SoundFile, ImageFile, Align)
from pybricks.tools import print, wait, StopWatch
from pybricks.robotics import DriveBase
# Write your program here
brick.sound.beep()
# Initialize two motors with default settings on Port B and Port C.
left_motor = Motor(Port.B)
right_motor = Motor(Port.C)
# The wheel diameter of the Robot Educator is 56 millimeters.
# The distance between wheels (axle_track) is 114 millimeters.
wheel_diameter = 56
axle_track = 114
# Create a DriveBase object. The wheel_diameter and axle_track values are
# needed to move robot correct speed/distance when you give drive commands.
robot = DriveBase(left_motor, right_motor, wheel_diameter, axle_track)
# This drives at 100 mm/sec straight
# drive(speed, steering)
#robot.drive (1, 0)
# This drives straight backwards at 500 mm/sec for 2 seconds
#robot.drive_time(10, 0, 2000)
# Drive forward at 100 mm/s for two seconds
robot.drive_time(100, 45, 2000)
# Turn at 45 deg/s for three seconds
#robot.drive_time(0, 45, 3000)
brick.sound.beep()
InfraredSensor, UltrasonicSensor, GyroSensor)
from pybricks.parameters import (Port, Stop, Direction, Button, Color,
SoundFile, ImageFile, Align)
from pybricks.tools import print, wait, StopWatch
from pybricks.robotics import DriveBase
# Write your program here
motorA = Motor(Port.A)
motorC = Motor(Port.C)
robot = DriveBase(motorA, motorC, 56, 114)
gs = GyroSensor(Port.S4)
x = 0
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)
else:
small.run(-75)
'''
#print("Light Sensor is ", onTable)
#print("Right Side is ", r_sideOn)
#print("Left Side is ", l_sideOn)
if onTable == True:
if (ultra.distance() <300):
robot.drive(200,0)
else:
robot.drive(100,0)
elif onTable == False:
robot.drive_time(-100,70,2000)
'''
#In the case that only the left limit switch runs off (shallow angle of approach)
if (l_sideOn == False):
#brick.sound.beep()
if (onTable == True):
left_motor.run_target(300,-1200)
else:
right_motor.run(0)
left_motor.run_time(-180,2000,Stop.COAST, True)
#In the case that only the right limit switch runs off (shallow angle of approach)
from pybricks import ev3brick as brick
from pybricks.ev3devices import Motor, UltrasonicSensor, ColorSensor, TouchSensor
from pybricks.parameters import Port, Color
from pybricks.tools import wait
from pybricks.robotics import DriveBase
left_motor = Motor(Port.B)
right_motor = Motor(Port.C)
robot = DriveBase(left_motor, right_motor, 56, 160)
button = TouchSensor(Port.S1)
# Create a walled circle around robot, with opening
# Attach touch button to front of robot
# Escape the Walls
while True:
robot.drive(100, 0)
if button.pressed():
robot.drive_time(-100, 0, 2000)
robot.drive_time(100, 180, 1000)
#!/usr/bin/env pybricks-micropython
from pybricks import ev3brick as brick
from pybricks.ev3devices import (Motor, TouchSensor, ColorSensor,
InfraredSensor, UltrasonicSensor, GyroSensor)
from pybricks.parameters import (Port, Stop, Direction, Button, Color,
SoundFile, ImageFile, Align)
from pybricks.tools import print, wait, StopWatch
from pybricks.robotics import DriveBase
# Write your program here
left = Motor(Port.B)
right = Motor(Port.C)
robot = DriveBase(left, right, 56, 114)
#drive_time(speed:mm/s, steering:deg/s, time:ms)
#Drive 25cm - 2.5 seconds at 100 speed
robot.drive_time(100, 0, 2500)
robot.stop()
if color_sensor.color() == myColor:
break
# start/continue driving ..
robot.drive(drive_speed, 0)
wait(100)
# .. eventually make a turn
make_turn()
# stop and grab an item
robot.stop()
close_grabber()
# move away from pick-up zone
robot.drive_time((-1*drive_speed), 0, 4000)
robot.drive_time(50, -90, 2000)
loaded = True
# search for drop zone and drop the item
while loaded == True:
# drive around and look for drop zone
while True:
collision_avoidance()
if color_sensor.color() != calibration_surface:
robot.stop()
# if zone is detacted stop driving around
if color_sensor.color() == dropZoneColor:
break
# start/continue driving ..
#!/usr/bin/env pybricks-micropython
from pybricks import ev3brick as brick
from pybricks.ev3devices import (Motor, TouchSensor, ColorSensor,
InfraredSensor, UltrasonicSensor, GyroSensor)
from pybricks.parameters import (Port, Stop, Direction, Button, Color,
SoundFile, ImageFile, Align)
from pybricks.tools import print, wait, StopWatch
from pybricks.robotics import DriveBase
# Initialize Motors
motorLeft = Motor(Port.A)
motorRight = Motor(Port.B)
robot = DriveBase(motorLeft, motorRight, 56, 114)
# Initialize Color Sensor
colorSensor = ColorSensor(Port.S1)
# Set Base Color
baseColor = colorSensor.color()
while True:
robot.drive(200,0)
while baseColor != colorSensor.color():
robot.drive_time(0,45,1)
# Button is released before continuing.
while any(brick.buttons()):
wait(10)
# Wait 2 seconds and then play a sound to indicate that the robot is
# about to drive.
wait(2000)
brick.sound.file(SoundFile.GO)
wait(1000)
# Now drive the robot using the list of stored commands. This is done
# by going over each command in the list in a loop.
for drive_command in drive_command_list:
# The robot turns 90 degrees to the left.
if drive_command == Button.LEFT:
robot.drive_time(100, -90, 1000)
# The robot turns 90 degrees to the right.
elif drive_command == Button.RIGHT:
robot.drive_time(100, 90, 1000)
# The robot drives straight forward 30 cm.
elif drive_command == Button.UP:
robot.drive_time(100, 0, 3000)
# The robot drives straight backward 30 cm.
elif drive_command == Button.DOWN:
robot.drive_time(-100, 0, 3000)
# Play a sound to indicate that it is finished.
brick.sound.file(SoundFile.GAME_OVER)
axle_track = 120
wheel_diameter = 55
robot = DriveBase(left_motor, right_motor, wheel_diameter, axle_track)
# Write your program here.
ev3.speaker.beep()
# Select target from right to left side of plate
target = 4
if target == 1:
# turn right 50 degrees
robot.drive_time(0, 48, 1000)
# go forward
robot.drive_time(2000, 0, 2000)
# turn left 85 degrees
robot.drive_time(0, -85, 1000)
elif target == 2:
# turn right
robot.drive_time(0, 16, 1000)
# go forward
robot.drive_time(2000, 0, 3000)
right_stick_x = value
if ev_type == 3 and code == 1:
right_stick_y = value
if ev_type == 1 and code == 307 and value == 1:
weapon.run_angle(100, 30, Stop.COAST, False)
if ev_type == 1 and code == 308 and value == 1:
weapon.run_time(720, 5000, Stop.COAST, False)
if ev_type == 1 and code == 305 and value == 1:
invert = invert * -1
if ev_type == 1 and code == 304 and value == 1:
while (True):
print(cs.color())
if cs.color() == None:
next
elif cs.color() > 2:
robot.drive_time(50, 80, 300)
else:
robot.drive_time(50, -30, 300)
if Button.LEFT in brick.buttons():
break
# Scale stick positions to -100,100
forward = scale(right_stick_y, (0, 255), (200, -200)) * invert
left = scale(right_stick_x, (0, 255), (200, -200))
# Set motor voltages. If we're steering left, the left motor
# must run backwards so it has a -left component
# It has a forward component for going forward too.
left_motor.dc(forward - left)
right_motor.dc(forward + left)
dr = UltrasonicSensor(Port.S2)
lev_kol = Motor(Port.D)
pr_kol = Motor(Port.A)
mb = Motor(Port.B)
mc = Motor(Port.C)
robot = DriveBase(lev_kol, pr_kol, 69, 127)
skr = list()
skk = list()
for i in range(3):
robot.drive(100, 0)
while not (dcl.color() == Color.BLACK and dcp.color() == Color.BLACK):
wait(10)
robot.drive_time(50, 0, 330)
if i == 0:
mc.run_time(-700, 2100)
sh_code()
# robot.drive_time(150, 0, 870)
nch_hr()
for j in range(2):
mb.track_target(360)
wait(1300)
mb.stop()
wait(300)
# mc.run_time(-300, 1000)
for i in range(2):
robot.drive(100, 0)
while dr.distance() > 45:
wait(10)
calibration_ramp = color_sensor_ramp.color()
while ball_count < 4:
global last_direction_change
collision_avoidance()
check_ball()
if check_container_full():
break
# run every 1s
if watch.time() - last_direction_change > random_direction_change_interval:
last_direction_change = watch.time()
random_direction = random.randint(0, 91)
robot.drive_time(drive_speed,
random_negate() * rotation_speed,
(random_direction / rotation_speed) * 1000)
brick.display.clear()
robot.drive(drive_speed, 0)
# brick.display.clear()
# brick.display.text(ultrasonic.presence(), (0, 20))
# wait(200)
# brick.display.text(ultrasonic.distance(), (0, 40))
# brick.display.text(color_sensor_floor.rgb(), (0,10))
# brick.display.text(color_sensor_floor.reflection(), (0,20))
# brick.display.text(color_sensor_floor.color(), (0,30))
# print(ultrasonic.presence())
# print(ultrasonic.distance())
# ultrasonic2.distance()
# wait(100)
#!/usr/bin/env pybricks-micropython
from pybricks import ev3brick as brick
from pybricks.ev3devices import (Motor, TouchSensor, ColorSensor,
InfraredSensor, UltrasonicSensor, GyroSensor)
from pybricks.parameters import (Port, Stop, Direction, Button, Color,
SoundFile, ImageFile, Align)
from pybricks.tools import print, wait, StopWatch
from pybricks.robotics import DriveBase
# Write your program here
left = Motor(Port.B)
right = Motor(Port.C)
robot = DriveBase(left, right, 56, 114)
#drive_time(speed:mm/s, steering:deg/s, time:ms)
robot.drive_time(100, 0, 3600) #Drive forward 36cm
robot.drive_time(0, -55, 1000) #Turn left
robot.drive_time(100, 0, 2500) #Drive forward 25cm
robot.stop()
#You need to perform the same actions in reverse to complete challenge
#!/usr/bin/env pybricks-micropython from pybricks.ev3devices import Motor from pybricks.parameters import Port, Stop from pybricks.robotics import DriveBase left_motor = Motor(Port.B) right_motor = Motor(Port.C) wheel_diameter = 56 axle_track = 123 robot = DriveBase(left_motor, right_motor, wheel_diameter, axle_track) speed = [100, -200, 300] robot.drive_time(speed[0], 0, 1000) robot.drive_time(speed[1], 0, 1000) robot.drive_time(speed[2], 0, 1000)
obstacle_sensor = UltrasonicSensor(Port.S4)
# Initialize two motors with default settings on Port B and Port C.
# These will be the left and right motors of the drive base.
left_motor = Motor(Port.B)
right_motor = Motor(Port.C)
# The wheel diameter of the Robot Educator is 56 millimeters.
wheel_diameter = 56
# The axle track is the distance between the centers of each of the wheels.
# For the Robot Educator this is 114 millimeters.
axle_track = 114
# The DriveBase is composed of two motors, with a wheel on each motor.
# The wheel_diameter and axle_track values are used to make the motors
# move at the correct speed when you give a motor command.
robot = DriveBase(left_motor, right_motor, wheel_diameter, axle_track)
# The following loop makes the robot drive forward until it detects an
# obstacle. Then it backs up and turns around. It keeps on doing this
# until you stop the program.
while True:
# Begin driving forward at 200 millimeters per second.
robot.drive(200, 0)
# Wait until an obstacle is detected. This is done by repeatedly
# doing nothing (waiting for 10 milliseconds) while the measured
# distance is still greater than 300 mm.
while obstacle_sensor.distance() > 300:
wait(10)
# Drive backward at 100 millimeters per second. Keep going for 2 seconds.
robot.drive_time(-100, 0, 2000)
# Turn around at 60 degrees per second, around the midpoint between
# the wheels. Keep going for 2 seconds.
robot.drive_time(0, 60, 2000)
beepPlz()
t += 1
pass
if (numberOfTouches == 0):
routineBlue()
elif (numberOfTouches < 5):
routineYellow()
elif (numberOfTouches < 10):
routineGreen()
else:
routineRed()
beepPlz()
# initVariables()
# beepPlz()
# display()
# wait(1000)
# routineRed()
# wait(1000)
# routineGreen()
# wait(1000)
# checkForTouch()
robot.drive_time(100, 90, 3000)
wait(100)
robot.stop()
#foundvictim()
#leftturn()
#brick.sound.beep()
#MA.backward(2000)
#brick.sound.beep()
#MA.rightturn()
#brick.sound.beep()
#MA.leftturn()
#brick.sound.beep()
#colourchecker()
#Testing
#foundvictim()
robot.drive_time(-1000, 0, 1500)
wait(1000)
main()
'''
while True:
if Button.UP in brick.buttons():
brick.sound.beep()
forward(200)
elif Button.DOWN in brick.buttons():
brick.sound.beep()
backwardtest(200)
elif Button.LEFT in brick.buttons():
brick.sound.beep()
leftturn()
elif Button.RIGHT in brick.buttons():
brick.sound.beep()
from pybricks.tools import print, wait, StopWatch
from pybricks.robotics import DriveBase
from pybricks.ev3devices import Motor
# Write your program here
brick.sound.beep()
gs = GyroSensor(Port.S3)
motorA = Motor(Port.A)
motorD = Motor(Port.D)
robot = DriveBase(motorA, motorD, 56, 114)
#Go forward for one seconds
#speed 500 mm/s - forward speed
#steering 0 deg/s - Turn rate of the robot
#time 1000 ms - duration
robot.drive_time(500, 0, 1000)
robot.stop(Stop.BRAKE)
wait(500)
#Reset Gyro Sensor angle to zero
gs.reset_angle(0)
print("Gyro Angle :", gs.angle())
#Run motor A at 30 degrees per second
motorA.run(300)
motorD.run(-300)
#wait(5000)
while gs.angle() <= 80:
pi = 3.14159265359 # roughly
pi2 = pi * 2.0 # roughly
angB = 0
angC = 0
oc = 0
waitBC() # make sure motors are not moving
while oc < 4:
oc += 1
cycles = 0
while (cycles < 2):
cycles += 1
print("Cycles: %d,%d" % (oc,cycles))
t1 = watch.time() / 1000
robot.drive_time(100, 45, 8000)
t2 = watch.time() / 1000
driveTime = t2-t1
print("CW drive time: %5.3f" % (driveTime))
DTFlag = True
sleep(1) # just in case not quite done
mB.stop(Stop.HOLD)
mC.stop(Stop.HOLD)
waitBC()
while (cycles < 4):
cycles += 1
print("Cycles: %d,%d" % (oc,cycles))
t1 = watch.time() / 1000
robot.drive_time(100, -45, 8000)
t2 = watch.time() / 1000
import time
# plug in
# A = left motor
# D = right motor
#
# S4 = ultrasonic sensor
left = Motor(Port.A)
right = Motor(Port.D)
dist = UltrasonicSensor(Port.S4)
wheel_dia = 56
wheel_spacing = 114
car = DriveBase(left, right, wheel_dia, wheel_spacing)
car.drive_time(speed=20, steering=90, time=2000)
wait(2000)
car.drive(20, 90)
wait(200)
car.stop(Stop.COAST) #or COAST, BRAKE, or HOLD
brick.sound.beep()
brick.display.clear()
while not any(brick.buttons()):
measured = dist.distance()
brick.display.clear()
brick.display.text(str(measured), (0, 60))
if measured < 2000:
speed = dist.distance() - 100
brick.display.text(str(speed))
car.drive(speed, 0)
print("blue: " + str(sensorBlue.reflection()))
while True:
while sensorBlue.reflection() < 15: # Is motors on a path
motors.drive(200, 0)
# T intersection
if sensorRed.reflection() < 15 and sensorYellow.reflection() < 15:
sensorCheck()
print('crossroads')
choice = path[i]
#choice = random.randrange(0, 3)
if choice == 0:
print('straight')
motors.drive_time(speed_d, 0, speed_t)
i += 1
if choice == 1:
print('right')
turnRight()
if choice == 2:
print('left')
turnLeft()
# Y intersection to left
elif sensorRed.reflection() < 15:
sensorCheck()
print('angled left')
choice = path[i]
#choice = random.randrange(0, 2)
if choice == 0:
# 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)
# Make wings spin at full speed
motor3.run(400)
from pybricks.robotics import DriveBase # Create your objects here. ev3 = EV3Brick() # Initialize the Ultrasonic Sensors. obstacle_sensor = UltrasonicSensor(Port.S1) color_sensor = ColorSensor(Port.S4) # Initialize two motors. left_motor = Motor(Port.B) right_motor = Motor(Port.C) arm_motor = Motor(Port.D) # The DriveBase is composed of two motors, with a wheel on each motor. robot = DriveBase(left_motor, right_motor, wheel_diameter=55.5, axle_track=104) #drive_time(speed:mm/s, steering:deg/s, time:ms) robot.drive_time(100, 0, 1000) #Drive forward 10cm robot.stop() #run arm motor (speed mm/s, rotational angle) arm_motor.run_angle(-100, 60) #run time with wait as FALSE #run_time(speed deg/s, time ms, then=Stop.HOLD, wait=True) left_motor.run_time(-100, 1000, Stop.HOLD, False) right_motor.run_time(-100, 1000, Stop.HOLD, False) arm_motor.run_time(50, 1000, Stop.HOLD, False) wait(1000)
from pybricks import ev3brick as brick
from pybricks.ev3devices import (Motor, TouchSensor, ColorSensor,
InfraredSensor, UltrasonicSensor, GyroSensor)
from pybricks.parameters import (Port, Stop, Direction, Button, Color,
SoundFile, ImageFile, Align)
from pybricks.tools import print, wait, StopWatch
from pybricks.robotics import DriveBase
# Write your program here
LM = Motor(Port.B)
RM = Motor(Port.D)
WD = 56
AT = 114
Robot = DriveBase(LM, RM, WD, AT)
Eyes = UltrasonicSensor(Port.S3)
Col = ColorSensor(Port.S2)
while True:
Robot.drive(0, 90)
if Eyes.distance() < 350:
wait(10)
while Col.reflection() > 10:
Robot.drive(200, 0)
else:
Robot.drive_time(-250, 0, 1500)
#!/usr/bin/env pybricks-micropython from pybricks.ev3devices import Motor from pybricks.parameters import Port, Stop from pybricks.robotics import DriveBase left_motor = Motor(Port.B) right_motor = Motor(Port.C) wheel_diameter = 56 axle_track =123 robot = DriveBase(left_motor, right_motor, wheel_diameter, axle_track) robot.drive_time(200, 0, 2000)
SoundFile, ImageFile, Align)
from pybricks.tools import print, wait, StopWatch
from pybricks.robotics import DriveBase
# Write your program here
brick.sound.beep(500, 500)
print("Hallo Welt!")
# Motor an Port B
motor_m = Motor(Port.B)
motor_m.run_target(500, -80)
motor_l = Motor(Port.A)
motor_l.run_target(500, 360)
motor_r = Motor(Port.D)
motor_r.run_target(500, 360)
robot = DriveBase(motor_l, motor_r, 30, 160)
sensor = InfraredSensor(Port.S4)
dist = sensor.distance()
print("Abstand: ", dist)
while dist > 10:
robot.drive_time(50, 90, 500)
dist = sensor.distance()
print("Abstand: ", dist)
robot.stop()
brick.sound.beep(1500, 500)
brick.sound.beep(300, 500)
brick.sound.beep(100, 500)
