def gameLoop(blocks_to_deliver):
global brick_state
leftMotor = Motor(Port.B)
rightMotor = Motor(Port.C)
wheels = DriveBase(Motor(Port.B), Motor(Port.C), 56, 114)
uSensor = UltrasonicSensor(Port.S4)
cSensor = ColorSensor(Port.S3)
gSensor = GyroSensor(Port.S2)
ts = TouchSensor(Port.S1)
while not ts.pressed():
# brick.sound.file(SoundFile.MOTOR_IDLE, 1000)
if blocks_delivered >= blocks_to_deliver:
brick_state = Status.WAIT
if brick_state == Status.WAIT:
return
elif brick_state == Status.SEARCHING:
print('STATE: SEARCHING')
t = threading.Thread(target=searchLuggage, args=(wheels, cSensor, gSensor))
t.start()
brick_state = Status.COMPUTING
elif brick_state == Status.CARRYING_LUGGAGE:
print('STATE: CARRYING_LUGGAGE')
t = threading.Thread(target=deliverLuggage, args=(wheels, cSensor, ))
t.start()
brick_state = Status.COMPUTING
elif brick_state == Status.PICKING_UP:
print('STATE: PICKING_UP')
t = threading.Thread(target=doLuggage, args=(wheels, cSensor, True, ))
t.start()
brick_state = Status.COMPUTING
elif brick_state == Status.DEPOSITING:
print('STATE: DEPOSITING')
t = threading.Thread(target=doLuggage, args=(wheels, cSensor,False, ))
t.start()
brick_state = Status.COMPUTING
def RedMission():
#!/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.straight(200)
robot.turn(-115)
Medium_Motor.run_angle(300, 135, then=Stop.HOLD, wait=True)
robot.stop(Stop.BRAKE)
robot.settings(200)
robot.turn(-60)
robot.straight(400)
robot.stop(Stop.BRAKE)
def BlackMission(): # Black Run (Innovatice Architecture, Health Units, Hopscotch, Bringing Slide Figures back HOME)
# LEFT 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)
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(-220)
large_motor.run_angle(60,80,then=Stop.HOLD, wait=True)
robot.stop(Stop.BRAKE)
robot.straight(-340)
large_motor.run_angle(60,-80,then=Stop.HOLD, wait=True)
robot.stop(Stop.BRAKE)
def __init__(self,
left_motor_output,
right_motor_output,
min_steering,
max_steering,
min_speed,
max_speed,
wheelDiameter,
axeDiameter,
steering_treshold=12,
prev_steering_size=10):
"""
Initializes a controller with two wheels.
:param left_motor_output: the output pin for the left motor
:param right_motor_output: the output pin for the right motor
:param min_steering: the minimum steering in [-100; 100]
:param max_steering: the maximum steering in [-100; 100]
:param min_speed: the minimum speed in [-100; 100]
:param max_speed: the maximum speed in [-100; 100]
"""
self._max_steering = max_steering
self._min_steering = min_steering
self._min_speed = min_speed
self._max_speed = max_speed
self._motor_left = Motor(left_motor_output)
self._motor_right = Motor(right_motor_output)
self._drive_base = DriveBase(self._motor_left, self._motor_right,
wheelDiameter, axeDiameter)
#internal variable to determine wich segment the robot is on currently
#self.prev_steering = numpy.zeros(shape = (20))
self.prev_steering = [0] * prev_steering_size
self.prev_angle = [0] * 10
self.action = 0
self.steering_treshold = steering_treshold
self.current_action = [
'going_straight', 'turning_right', 'turning_left'
]
self.current_angle = 0
def init_brick():
# Create your objects here.
ev3 = EV3Brick()
# Initilize our motors
left_motor = Motor(Port.A)
right_motor = Motor(Port.D)
front_motor_1 = Motor(Port.C)
front_motor_2 = Motor(Port.B)
left_motor.reset_angle(0)
right_motor.reset_angle(0)
front_motor_1.reset_angle(0)
front_motor_2.reset_angle(0)
# Initialize the color sensor.
left_sensor = ColorSensor(Port.S4)
right_sensor = ColorSensor(Port.S1)
# Speeds
right_sensor = ColorSensor(Port.S1)
left_sensor = ColorSensor(Port.S4)
ARM_MOTOR_SPEED = 400
WHEEL_DIAMETER = 92
AXLE_TRACK = 130
DRIVE_SPEED_FAST = 350
DRIVE_SPEED_NORMAL = 200
DRIVE_SPEED_SLOW = 100
DRIVE_EXTRA_SLOW = 30
CIRCUMFERENCE = 3.14 * WHEEL_DIAMETER # Diameter = 100mm, Circumference = 314.10mm = 1 rotation
# Initialize the Gyro sensor
gyro = GyroSensor(Port.S2)
gyro.reset_angle(0)
# All parameters are in millimeters
robot = DriveBase(left_motor, right_motor, wheel_diameter=config.WHEEL_DIAMETER, axle_track=config.AXLE_TRACK)
# Set the straight speed and turn rate
robot.settings(straight_speed=config.DRIVE_SPEED_NORMAL, turn_rate=config.TURN_RATE)
def doLuggage(wheels, cSensor, pickup=True):
global brick_state, blocks_delivered
if pickup:
stapler = Motor(Port.A, Direction.CLOCKWISE)
stapler.run_until_stalled(20, Stop.BRAKE)
brick.sound.file(SoundFile.HORN_1,1000)
brick_state = Status.CARRYING_LUGGAGE
else:
stapler = Motor(Port.A, Direction.COUNTERCLOCKWISE)
You_spin_me_right_round_baby_Right_round_like_a_record_baby_Right_round_round_round(wheels, 180)
stapler.run_angle(50, 100, Stop.BRAKE)
wheels.drive_time(-50, 0, 1000)
stapler.run_angle(50, 25, Stop.BRAKE)
wheels.drive_time(-113/3, 45/3, 1000*3)
wheels.drive_time(0,45/3,1000*3)
blocks_delivered += 1
brick_state = Status.SEARCHING
class Robot:
brick = EV3Brick()
left_wheel = Motor(Port.A)
right_wheel = Motor(Port.D)
wheel_diameter = 95
axle_track = 120
robot = DriveBase(left_wheel, right_wheel, wheel_diameter, axle_track)
def __init__(self, name, mood):
self.name = name
self.mood = mood
def tell_me_about_yourself(self):
print("The robot's name is " + self.name + ".")
print("This robot is " + self.mood + ".")
print("Wheel diameter is", self.wheel_diameter, ".")
print("Axle Track is", self.axle_track, ".")
print()
def move_forward(self, distance_mm):
print("Move forward", distance_mm, ".")
self.robot.straight(-distance_mm)
def turn(self, angle):
print("Turn", angle, "degrees.")
self.robot.turn(angle)
def beep(self, number_of_beeps):
print("Beep",number_of_beeps,"times.")
x = 1
while x <= number_of_beeps:
self.brick.speaker.beep()
wait(30)
x = x + 1
def move_backwards(self, distance_mm):
print("Move backwards",distance_mm,".")
self.robot.straight(distance_mm)
def __init__(self):
# Initialize all devices
self.ev3 = EV3Brick()
self.usb_motor = Motor(Port.D)
self.bt_motor = Motor(Port.C)
self.left_button_motor = Motor(Port.B)
self.right_button_motor = Motor(Port.A)
# Reset all motor to mechanical stop
self.usb_motor.run_until_stalled(-SPEED, duty_limit=50)
self.bt_motor.run_until_stalled(-SPEED, duty_limit=20)
self.left_button_motor.run_until_stalled(-SPEED, duty_limit=100)
self.right_button_motor.run_until_stalled(SPEED, duty_limit=30)
wait(500)
# Reset the angles
self.usb_motor.reset_angle(10)
self.bt_motor.reset_angle(-20)
self.left_button_motor.reset_angle(-25)
self.right_button_motor.reset_angle(20)
# Go to neutral position
self.reset()
def __init__(self):
# Sets up the brick
self.ev3 = EV3Brick()
# Identifies which motor is connected to which ports
self.left_leg_motor = Motor(Port.D, Direction.COUNTERCLOCKWISE)
self.right_leg_motor = Motor(Port.A, Direction.COUNTERCLOCKWISE)
# Sets up the gear ratio (automatically translates it to the correct angle)
self.head_motor = Motor(Port.C,
Direction.COUNTERCLOCKWISE,
gears=[[1, 24], [12, 36]])
# Sets up touch sensor
self.touch_sensor = TouchSensor(Port.S1)
# Sets up constants for the eye
self.eyes_timer_1 = StopWatch()
self.eyes_timer_1_end = 0
self.eyes_timer_2 = StopWatch()
self.eyes_timer_2_end = 0
self.eyes_closed = False
def connected_devices(self, print_output=False):
"""
Check what devices are connected to what ports
Args:
print_output (bool): It will display a message showing the devices that were found
Returns:
devices (dict): A dictionary with the sensors and motors that were found
"""
self.motors = {"Motor": [], "Port": []}
self.sensors = {"Sensor": [], "Port": []}
# Look for motor in every port
for port in self.motors_ports:
try:
self.motors["Motor"].append(type(Motor(port)).__name__)
self.motors["Port"].append(str(port))
except Exception:
pass
# look for sensors in every port
for sensor in self.available_sensors:
for port in self.sensors_ports:
try:
self.sensors["Sensor"].append(type(sensor(port)).__name__)
self.sensors["Port"].append(str(port))
except Exception:
pass
if print_output:
print("\nDevices Found:")
print("Motors:")
if len(self.motors["Motor"]) > 0:
for port in self.motors["Port"]:
print("Motor in", port)
else:
print("No motor found")
print("\nSensors:")
if len(self.sensors["Sensor"]) > 0:
for sensor, port in zip(self.sensors["Sensor"],
self.sensors["Port"]):
print(sensor, "in", port)
else:
print("No sensor found")
return {"Motors": self.motors, "Sensors": self.sensors}
def follow(self, number_of_seconds):
print('SKILLS - Follow the line for', number_of_seconds,'seconds')
y = 1
while y <= number_of_seconds:
left_motor = Motor(Port.A)
right_motor = Motor(Port.D)
color_sensor_left = ColorSensor(Port.S3)
color_sensor_right = ColorSensor(Port.S4)
robot = DriveBase(left_motor, right_motor, wheel_diameteR, axle_track)
BLACK = 9
WHITE = 85
threshold = (BLACK + WHITE) / 2
DRIVE_SPEED = 100
PROPORTIONAL_GAIN = 1.2
while True:
deviation = line_sensor.reflection() - threshold
turn_rate = PROPORTIONAL_GAIN * deviation
robot.drive(DRIVE_SPEED, turn_rate)
wait(10)
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 __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 __init__(self,
speed_initializing,
max_speed_execution,
solution,
black_ref=100,
white_ref=0,
robot_center_parameter=80,
robot_rotation_parameter=0,
orientation="N",
motor_rigth=Motor(Port.B),
motor_left=Motor(Port.C),
sensor_rigth=ColorSensor(Port.S2),
sensor_left=ColorSensor(Port.S1),
sensor_stop=ColorSensor(Port.S3),
sensor_gyro=GyroSensor(Port.S4),
Kp=5,
Ki=0,
Kd=0):
self.speed_initializing = speed_initializing
self.max_speed_execution = max_speed_execution
self.solution = solution
self.black_ref = black_ref
self.white_ref = white_ref
self.robot_center_parameter = robot_center_parameter
self.robot_rotation_parameter = robot_rotation_parameter
self.orientation = orientation
self.motor_rigth = motor_rigth
self.motor_left = motor_left
self.sensor_rigth = sensor_rigth
self.sensor_left = sensor_left
self.sensor_stop = sensor_stop
self.sensor_gyro = sensor_gyro
self.Kp = Kp
self.Ki = Ki
self.Kd = Kd
self.watch = StopWatch()
def __init__(
self,
left_leg_motor_port: Port = Port.B, right_leg_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):
super().__init__(
wheel_diameter=self.WHEEL_DIAMETER, axle_track=self.AXLE_TRACK,
left_motor_port=left_leg_motor_port, right_motor_port=right_leg_motor_port,
ir_sensor_port=ir_sensor_port, ir_beacon_channel=ir_beacon_channel)
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)
def __init__(self, arg_correction=None):
self.dict_head = {'ir': 0, 'touch': -110, 'color': 90}
self.datei = 'winkel.txt'
self.angle_ist = 0
if arg_correction is not None:
headmotor = Motor(Port.A, Direction.COUNTERCLOCKWISE)
if type(arg_correction) == str:
angle = -self.dict_head[arg_correction]
else:
angle = arg_correction
headmotor.run_target(speed=20, target_angle=angle)
else:
if self.datei in os.listdir(): # gibt es die Datei?
debug('lese')
self._lese_winkel()
debug('init ' + str(self.angle_ist))
def __init__(self,
left_track_motor_port: Port = Port.B,
right_track_motor_port: Port = Port.C,
medium_motor_port: Port = Port.A,
ir_sensor_port: Port = Port.S4,
ir_beacon_channel: int = 1):
super().__init__(wheel_diameter=self.WHEEL_DIAMETER,
axle_track=self.AXLE_TRACK,
left_motor_port=left_track_motor_port,
right_motor_port=right_track_motor_port,
ir_sensor_port=ir_sensor_port,
ir_beacon_channel=ir_beacon_channel)
self.ev3_brick = EV3Brick()
self.medium_motor = Motor(port=medium_motor_port,
positive_direction=Direction.CLOCKWISE)
def __init__(
self,
left_foot_motor_port: Port = Port.B, right_foot_motor_port: Port = Port.C,
medium_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):
super().__init__(
wheel_diameter=self.WHEEL_DIAMETER, axle_track=self.AXLE_TRACK,
left_motor_port=left_foot_motor_port, right_motor_port=right_foot_motor_port,
ir_sensor_port=ir_sensor_port, ir_beacon_channel=ir_beacon_channel)
self.medium_motor = Motor(port=medium_motor_port)
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 kalibriere(self):
headmotor = Motor(Port.A, Direction.COUNTERCLOCKWISE)
farbsensor = ColorSensor(Port.S3)
headmotor.run_until_stalled(speed=10, duty_limit=50)
debug('winkel=' + str(headmotor.angle()))
headmotor.run_target(speed=10, target_angle=-120, wait=False)
while (farbsensor.reflection() < 10): # & (headmotor.speed() != 0):
debug('farbwert=' + str(farbsensor.reflection()))
time.sleep(0.1)
headmotor.stop()
headmotor.run_angle(speed=10, rotation_angle=15)
debug(str(farbsensor.reflection()))
# winkel auf 0
headmotor.reset_angle(0)
self.angle_ist = 0
self._schreibe_winkel()
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.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 __init__(self,
left_track_motor_port: Port = Port.B,
right_track_motor_port: Port = Port.C,
gripping_motor_port: Port = Port.A,
touch_sensor_port: Port = Port.S1,
ir_sensor_port: Port = Port.S4,
ir_beacon_channel: int = 1):
super().__init__(wheel_diameter=self.WHEEL_DIAMETER,
axle_track=self.AXLE_TRACK,
left_motor_port=left_track_motor_port,
right_motor_port=right_track_motor_port,
ir_sensor_port=ir_sensor_port,
ir_beacon_channel=ir_beacon_channel)
self.ev3_brick = EV3Brick()
self.gripping_motor = Motor(port=gripping_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 __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):
super().__init__(
wheel_diameter=self.WHEEL_DIAMETER, axle_track=self.AXLE_TRACK,
left_motor_port=left_motor_port, right_motor_port=right_motor_port,
ir_sensor_port=ir_sensor_port, ir_beacon_channel=ir_beacon_channel)
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 __init__(
self,
left_motor_port: Port = Port.C, right_motor_port: Port = Port.B,
shovel_motor_port: Port = Port.A,
touch_sensor_port: Port = Port.S1,
ir_sensor_port: Port = Port.S4,
tank_drive_ir_beacon_channel: int = 1,
shovel_control_ir_beacon_channel: int = 4):
super().__init__(
wheel_diameter=self.WHEEL_DIAMETER, axle_track=self.AXLE_TRACK,
left_motor_port=left_motor_port, right_motor_port=right_motor_port,
polarity='inversed',
ir_sensor_port=ir_sensor_port,
ir_beacon_channel=tank_drive_ir_beacon_channel)
self.ev3_brick = EV3Brick()
self.shovel_motor = Motor(port=shovel_motor_port,
positive_direction=Direction.CLOCKWISE)
self.touch_sensor = TouchSensor(port=touch_sensor_port)
self.shovel_control_ir_beacon_channel = \
shovel_control_ir_beacon_channel
Download: https://education.lego.com/en-us/support/mindstorms-ev3/python-for-ev3 Building instructions can be found at: https://education.lego.com/en-us/support/mindstorms-ev3/building-instructions#robot """ from pybricks.hubs import EV3Brick from pybricks.ev3devices import Motor from pybricks.parameters import Port from pybricks.robotics import DriveBase # Initialize the EV3 Brick. ev3 = EV3Brick() # Initialize the motors. left_motor = Motor(Port.B) right_motor = Motor(Port.C) lift_motor = Motor(Port.A) # Initialize the drive base. robot = DriveBase(left_motor, right_motor, wheel_diameter=55.5, axle_track=104)
#!/usr/bin/env pybricks-micropython
import random
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
motor_piedra = Motor(Port.A)
motor_papel = Motor(Port.B)
motor_tijera = Motor(Port.C)
motors = [motor_papel, motor_piedra, motor_tijera]
GRADOS = 90
def reset():
for motor in motors:
motor.track_target(0)
wait(500)
def jugar_piedra():
pass
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
from threading import *
#Rightside touch, used as Pause and TrackSelect
touch = TouchSensor(Port.S1)
#Leftside touch, used as Track Change
SelectButton = TouchSensor(Port.S4)
#Left and Right are backwards, please input negative velocity
left = Motor(Port.D)
right = Motor(Port.A)
TOUCHED = True
selectionMade = 0
#pause function monitors the touch sensor for pause inputs. Changes the TOUCHED global variable
#from true to false and back again. On start should be True for music selection.
def pause():
#Call in the touchSensor into scope
global touch
while True:
if touch.pressed():
global TOUCHED
if TOUCHED == False:
TOUCHED = True
elif TOUCHED == True:
#!/usr/bin/env pybricks-micropython
from pybricks import ev3brick as brick
from pybricks.ev3devices import Motor, ColorSensor, TouchSensor, UltrasonicSensor, GyroSensor
from pybricks.parameters import Port, Direction, Color
import time
#モーター・センサー類の設定
Right = Motor(Port.B)
Left = Motor(Port.C, Direction.COUNTERCLOCKWISE) #Mモーター使用のため正の速度方向を逆に設定
CS = ColorSensor(Port.S1)
TS = TouchSensor(Port.S2)
US = UltrasonicSensor(Port.S3)
GS = GyroSensor(Port.S4)
#各種関数の定義
class My():
#モーターの角度をAngle度にリセット
def Reset(Angle):
Right.reset_angle(Angle)
Left.reset_angle(Angle)
#モーターをそれぞれ速度Right_Speed、Left_Speedで回転
def Run(Right_Speed, Left_Speed):
Right.run(Right_Speed)
Left.run(Left_Speed)
#変数Reflectionの値を境目にライントレース
def LineTrace(High_Power, Low_Power):
if CS.reflection() > Reflection:
#!/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
import time
Vmoottori = Motor(Port.B, Direction.CLOCKWISE)
Omoottori = Motor(Port.C, Direction.CLOCKWISE)
variSensori = ColorSensor(Port.S2)
# Play a sound
#brick.sound.file("Taistelujaska.wav")
va = True
reitilla = False
i = 0
laskuri = 0
while i < 50000:
vari = variSensori.color()
Vmoottori.run(-300)
Omoottori.run(-300)
time.sleep(0.05)
if vari == 6:
Vmoottori.run(200)
Omoottori.run(-200)
time.sleep(0.2)
#!/usr/bin/env pybricks-micropython
from pybricks import ev3brick as brick
from pybricks.hubs import EV3Brick
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 wait, StopWatch, DataLog
from pybricks.robotics import DriveBase
import time
# 모터 선언
motorB = Motor(Port.B)
motorC = Motor(Port.C)
# 컬러 센서 선언
color_sensor1 = ColorSensor(Port.S1)
color_sensor2 = ColorSensor(Port.S2)
CRITERIA = 20 # 반사값 기준 설정
speed = 150 # 모터 속도
while True:
if color_sensor1.reflection() > CRITERIA and color_sensor2.reflection(
) > CRITERIA:
# 센서 2개 모두 선 위에 있지 않을 경우, 직진한다.
motorB.run(speed)
motorC.run(speed)
elif color_sensor1.reflection() > CRITERIA and color_sensor2.reflection(
) <= CRITERIA:
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
#state of the robot
# 1: Cruise
# 2: Avoid
# 3: Escape
# 4: Goal reached
# TODO: more States
state = 1
left_motor = Motor(Port.A)
right_motor = Motor(Port.B)
left_motor_speed = 0
right_motor_speed = 0
def cruise():
global state
print("State: Cruise")
#TODO Fahre gerade nach vorne
#TODO Wechsle den state abhängig von aktuellen Sensorwerten
def avoid():
global state
print("State: Avoid")
#TODO Fahre nach vorne, aber lenke gleichzeitig zur Seite um einem Hindernis auszuweichen
#TODO Wechsle den state abhängig von aktuellen Sensorwerten
