def main():
# #Variable Assignments
lm = Motor(Port.B) #Left Motor
rm = Motor(Port.C) #Right Motor
#pm = Motor(Port.A) #Pickup Motor
#lm = Motor(Port.B) #Left Motor
#rm = Motor(Port.C) #Right Motor
robot = DriveBase(lm, rm, 56, 114)
ts = TouchSensor(Port.S1)
# gs = GyroSensor(Port.S2)
cs = ColorSensor(Port.S3) #Measures light intensity
us = UltrasonicSensor(Port.S4) #Measures distance
# PID tuning
Kp = 27 # proportional gain
Ki = 1.5 # integral gain
Kd = 1.7 # derivative gain
integral = 0
previous_error = 0
colorcomand = 0 #checking color
Tp = 150 #Target Power
offset = cs.reflection()
collected = False
while not done:
# Calculate steering using PID algorithm
error = offset - cs.reflection()
integral = (integral + error)
derivative = (error - previous_error)
Turn = (Kp*error) + (Ki*integral) + (Kd*derivative)
powerA = Tp + Turn
powerB = Tp - Turn
#colorcomand = cs.color()
#limit u to safe values (between -1000 and 1000)
print("Light level:", cs.reflection())
print("Distance:", us.distance())
#print("color", cs.color())
# print("Color:", cs.color())
# print("Ambient light:", cs.ambient())
if not collected:
if us.distance() < 40:
slam()
collected = True
rm.run(powerA)
lm.run(powerB)
previous_error = error
from time import sleep # This program requires LEGO EV3 MicroPython v2.0 or higher. # Click "Open user guide" on the EV3 extension tab for more information. ARM_SPEED = 500 ARM_MAX_ANGLE = 3200 ARM_MIN_ANGLE = 0 DRIVE_SPEED = 50 DRIVE_SLOW_SPEED = 10 # Create your objects here. ev3 = EV3Brick() # Initialize the motors. leftMotor = Motor(Port.B) rightMotor = Motor(Port.C) # Initialize the drive base. robot = DriveBase(leftMotor, rightMotor, wheel_diameter=55.5, axle_track=104) # Initialize the arm motor armMotor = Motor(Port.A) # Initialize the Touch Sensor. It is used to detect when the arm motor has # opened all the way. touchSensor = TouchSensor(Port.S4) # Initialize the color sensor. It is used to detect the color of the ground. colorSensor = ColorSensor(Port.S1)
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 dance_if_ir_beacon_pressed(self):
while Button.BEACON in self.ir_sensor.buttons(channel=self.ir_beacon_channel):
self.drive_base.turn(angle=randint(-360, 360))
def detect_object_by_ir_sensor(self):
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_if_touched(self):
MEDIUM_MOTOR_N_ROTATIONS_PER_BLAST = 3
MEDIUM_MOTOR_ROTATIONAL_DEGREES_PER_BLAST = MEDIUM_MOTOR_N_ROTATIONS_PER_BLAST * 360
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)
while True:
self.drive_once_by_ir_beacon(speed=driving_speed)
self.dance_if_ir_beacon_pressed()
# 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
# self.detect_object_by_ir_sensor()
self.blast_bazooka_if_touched()
#!/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
motorL = Motor(Port.B)
motorR = Motor(Port.C)
brick.display.text("Run eight", (60, 50))
robot = DriveBase(motorL, motorR, 56, 104) # wheel diameter (mm) | axle track (mm) !!!!!!!!!!!! ACHSENABSTAND MUSS ANGEPASST WERDEN
while True:
robot.drive_time(300, 44, 8181) # mm/s | deg/s circle right 9 secs
robot.drive_time(300, -44, 8181) # circle left 9 secs
#!/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
motor_b = Motor(Port.B)
motor_c = Motor(Port.C)
motor_b.run_angle(500, 720, Stop.BRAKE, False)
motor_c.run_angle(500, 720, Stop.BRAKE, True)
#!/usr/bin/env pybricks-micropython
from pybricks.hubs import EV3Brick
from pybricks.ev3devices import Motor, GyroSensor
from pybricks.parameters import Port, Direction
from pybricks.robotics import DriveBase
from pybricks.tools import wait
# Initialize the EV3 Brick.
ev3 = EV3Brick()
# Initialize the motors.
left_motor = Motor(Port.B, positive_direction=Direction.COUNTERCLOCKWISE)
right_motor = Motor(Port.C, positive_direction=Direction.COUNTERCLOCKWISE)
boccia_motor = Motor(Port.A)
forklift_motor = Motor(Port.D)
robot = DriveBase(left_motor, right_motor, wheel_diameter=94.2, axle_track=94)
robot.settings(straight_speed=200,
straight_acceleration=50,
turn_rate=150,
turn_acceleration=200)
ev3.screen.draw_text(50, 60, "Drop the blocks!")
ev3.speaker.beep()
gyro_sensor = GyroSensor(Port.S2, Direction.COUNTERCLOCKWISE)
def gyro_turn(angle, speed):
gyro_sensor.reset_angle(0)
if angle < 0:
#!/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
# Config Code
ev3 = EV3Brick()
left_motor = Motor(Port.B)
right_motor = Motor(Port.C)
right_ultra = UltrasonicSensor(Port.S4)
front_ultra = UltrasonicSensor(Port.S3)
watch = StopWatch()
gyro = GyroSensor(Port.S2)
color = ColorSensor(Port.S1)
# robot = DriveBase(left_motor, right_motor, wheel_diameter=80.3, axle_track=117.5)
# TODO: Create github repo for Fall Robotics
def steering(speed, turn_rate):
left_motor.run(speed + turn_rate)
#!/usr/bin/env pybricks-micropython
from pybricks.hubs import EV3Brick
from pybricks.tools import wait
from pybricks.ev3devices import (Motor, TouchSensor, ColorSensor,
InfraredSensor, UltrasonicSensor, GyroSensor)
from pybricks.parameters import Port, Stop, Direction, Button, Color
from math import sin, radians, pi, atan2, degrees
from connection import SpikePrimeStreamReader, SpikeRCWheel
# Create the connection. See README.md to find the address for your SPIKE hub.
wheel = SpikeRCWheel('38:0B:3C:A3:45:0D')
steer_motor = Motor(Port.A)
drive_l = Motor(Port.B)
drive_r = Motor(Port.C)
# Auto center steering wheels.
steer_motor.run_until_stalled(250)
steer_motor.reset_angle(80)
steer_motor.run_target(300,0)
speed = 0
left = 0
# Now you can simply read values!
while True:
steer_motor.track_target(wheel.steering() * -0.5 + wheel.right_thumb())
if wheel.left_paddle() > 15:
speed = wheel.left_paddle() * -10
#!/usr/bin/env pybricks-micropython from pybricks.ev3devices import Motor from pybricks.parameters import Port, Stop from pybricks.tools import wait left_motor = Motor(Port.B) right_motor = Motor(Port.C) left_motor.run(360) right_motor.run(360) wait(2000) left_motor.stop(Stop.BRAKE) right_motor.stop(Stop.BRAKE)
class SmallMotor:
def __init__(self, ev3, port):
self.ev3 = ev3
self.motor = Motor(port, Direction.COUNTERCLOCKWISE)
self.motor.reset_angle(0)
def reset(self):
self.motor.run_until_stalled(100)
self.motor.run_angle(800, -300)
self.motor.reset_angle(0)
def moveTo(self, angle, speed = 800, wait = False):
print(self.motor.angle())
self.motor.run_target(speed, angle, Stop.HOLD, wait)
print(self.motor.angle())
def move(self, speed = 20):
self.motor.run(speed)
def brake(self):
self.motor.brake()
def __init__(self, ev3, port):
self.ev3 = ev3
self.motor = Motor(port, Direction.COUNTERCLOCKWISE)
self.motor.reset_angle(0)
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()
###########################################
# Main method incoming
#motors
mRight = Motor(Port.D)
mLeft = Motor(Port.A)
#sensor
sRight = ColorSensor(Port.S4)
#other init for run_time
speed = 360 / 4 #deg/sec
timeA = 500 #ms
stop_type = Stop.COAST
waitA = False
#PID
#incoming
#LineFollow
#!/usr/bin/env pybricks-micropython
# pybrick imports
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 wait, print
# left, right: motor1
# up, down: motor2
motor1 = Motor(Port.A)
motor2 = Motor(Port.D)
speed = 500
while True:
btn = None
btns = brick.buttons()
if len(btns) != 1:
motor1.stop()
motor2.stop()
continue
btn = btns[0]
print("button:", btn)
if btn == Button.LEFT:
motor1.run(-speed)
motor2.stop()
elif btn == Button.RIGHT:
#!/usr/bin/env pybricks-micropython from pybricks.hubs import EV3Brick from pybricks.ev3devices import Motor, TouchSensor, ColorSensor from pybricks.parameters import Port, Stop, Direction from pybricks.tools import wait # Initialize the EV3 Brick ev3 = EV3Brick() # Configure the gripper motor on Port A with default settings. gripper_motor = Motor(Port.A) # Configure the elbow motor. It has an 8-teeth and a 40-teeth gear # connected to it. We would like positive speed values to make the # arm go upward. This corresponds to counterclockwise rotation # of the motor. elbow_motor = Motor(Port.B, Direction.COUNTERCLOCKWISE, [8, 40]) # Configure the motor that rotates the base. It has a 12-teeth and a # 36-teeth gear connected to it. We would like positive speed values # to make the arm go away from the Touch Sensor. This corresponds # to counterclockwise rotation of the motor. base_motor = Motor(Port.C, Direction.COUNTERCLOCKWISE, [12, 36]) # Limit the elbow and base accelerations. This results in # very smooth motion. Like an industrial robot. elbow_motor.control.limits(speed=60, acceleration=120) base_motor.control.limits(speed=60, acceleration=120) # Set up the Touch Sensor. It acts as an end-switch in the base
class Robot:
# wheel diameter in mm
WHEEL_DIAMETER = 64.2
# distance between wheels in mm
AXLE_TRACK = 200
BACKLASH_DUTY = 15
motor_left = Motor(Port.C, Direction.COUNTERCLOCKWISE, [12, 20])
motor_right = Motor(Port.B, Direction.CLOCKWISE, [12, 20])
light_sensor_right = ColorSensor(Port.S1)
light_sensor_left = ColorSensor(Port.S2)
gyro_sensor = GyroSensor(Port.S3)
ultrasonic_sensor = UltrasonicSensor(Port.S4)
drive_base = DriveBase(motor_left, motor_right, WHEEL_DIAMETER, AXLE_TRACK)
def p_line_Follow(self, _sensor, _sensor_target, _sensor_gain,
_base_speed):
# target light sensor value
light_sensor_target = _sensor_target
# light sensor gain
light_sensor_p_gain = _sensor_gain
# desired base speed of the drivetrain
base_speed = _base_speed
while (True):
Kp = light_sensor_p_gain * (light_sensor_target -
_sensor.reflection())
self.motor_left.run(base_speed - Kp)
self.motor_right.run(base_speed + Kp)
def move_straight(self, _speed, _degrees, _stop_type):
# thread that checks for stall condition
def check_stall():
while (True):
if self.motor_left.stalled() or self.motor_right.stalled():
self.motor_left.stop(Stop.HOLD)
self.motor_right.stop(Stop.HOLD)
brick.sound.beep()
break
# motor backlash compensation
def backlash_compensation(self, _degrees):
if (_degrees > 0):
self.motor_left.dc(self.BACKLASH_DUTY)
self.motor_right.dc(self.BACKLASH_DUTY)
elif (_degrees < 0):
self.motor_left.dc(self.BACKLASH_DUTY * -1)
self.motor_right.dc(self.BACKLASH_DUTY * -1)
else:
return
# duration to remove lash from motors
wait(100)
# reset rotation sensors
self.motor_left.reset_angle(0)
self.motor_right.reset_angle(0)
# compensate for the backlash
backlash_compensation(_degrees)
# start thread to detect stall condition
t_check_stall = Thread(target=check_stall, args=())
t_check_stall.start()
self.motor_left.run_target(_speed, _degrees, _stop_type, False)
self.motor_right.run_target(_speed, _degrees, _stop_type, True)
# turn off stall detection thread
t_check_stall.exit()
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
#################################
# Roboter
#################################
# Ein roboter erstellen:
linker_motor = Motor(Port.B)
rechter_motor = Motor(Port.C)
rad_durchmesser=56
achsen_abstand=133
roboter = DriveBase(linker_motor, rechter_motor, rad_durchmesser, achsen_abstand)
# oder
roboter = DriveBase(Motor(Port.B), Motor(Port.C), 56, 133)
# Fahren
geschwindigkeit = 100 # mm/s (Milimeter pro Sekunde)
steuern = 0 # Grad/s (360 Grad ist ganzer Kreis)
zeit = 1000 # ms (1000ms ist eine Sekunde)
# Fahren bis ein anderer Befehl kommt
roboter.drive(geschwindigkeit, steuern)
# oder
roboter.drive(100,0)
return contador
# Create your objects here.
ev3 = EV3Brick()
# Write your program here.
ev3.speaker.set_speech_options('pt-br','m3')
ev3.speaker.beep()
HOST = '192.168.0.3' # Endereco IP do Servidor
PORT = 2508 # Porta que o Servidor esta
udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
dest = (HOST, PORT)
# Motores
motorLeft = Motor(Port.B)
motorRight = Motor(Port.C)
motorBotton = Motor(Port.D)
motorTop = Motor(Port.A)
motorLeft.brake()
motorRight.brake()
motorBotton.brake()
motorTop.brake()
# Sensores ultrassônicos
topSensor = UltrasonicSensor(Port.S4)
bottonSensor = UltrasonicSensor(Port.S1)
# Sensores de cor
corLeft = ColorSensor(Port.S2)
corRight = ColorSensor(Port.S3)
from pybricks.parameters import (Port, Stop, Direction, Button, Color,
SoundFile, ImageFile, Align)
from pybricks.tools import wait
from pybricks.robotics import DriveBase
# how far do we want to go?
targetAngle = 365
# how fast do we want to get there?
speed = 100
# what's the min. speed that will cause the robot to move
minSpeed = 10
# make our motor objects
leftMotor = Motor(Port.B)
rightMotor = Motor(Port.C)
# set them all to read zero
leftMotor.reset_angle(0)
rightMotor.reset_angle(0)
# read the left motor's current position
# this should just be zero.
angle = leftMotor.angle()
# start moving the robot straight - at our top speed!
leftMotor.run(speed)
rightMotor.run(speed)
# keep going until the left motor has rotated
#!/usr/bin/env pybricks-micropython
#brickrun -r -- 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
from pybricks.iodevices import AnalogSensor, UARTDevice
brick.sound.beep()
minimotor = Motor(Port.D)
leftmotor = Motor(Port.C, Direction.CLOCKWISE)
rightmotor = Motor(Port.B, Direction.CLOCKWISE)
robot = DriveBase(leftmotor, rightmotor, 40, 200)
button = TouchSensor(Port.S1)
color = ColorSensor(Port.S2)
#sense = AnalogSensor(Port.S3, False)
direction = 1
while True:
if button.pressed():
direction *= -1
minimotor.run(direction * 20)
robot.drive(direction * 0, 0)
data = color.color()
# ----------------------------------------------------------------------------- # Everything below in this section is main operating code for the robot and the # operation of the conveyor and output sensors. # ----------------------------------------------------------------------------- # --------------------------------- Main Section ------------------------------ # Initializing ev3 brick instance ev3 = EV3Brick() # Initializing the Motors and Sensors for the System lM = Motor(Port.A) rM = Motor(Port.B) launchMotor = Motor(Port.C) strtButton = TouchSensor(Port.S4) conveyorMotor = Motor(Port.D) # Zeroing all drive motor angles to zero lM.reset_angle(0) rM.reset_angle(0) # Five Bar Robot - constants made global to limit arguments to user defined functions r_1 = 86 # Length of first linkage (mm)
#!/usr/bin/env pybricks-micropython
"""
gary-the-dancing-machine
"""
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
motor_a = Motor(Port.A)
motor_b = Motor(Port.B)
sensor = TouchSensor(Port.S1)
while True:
if sensor.pressed():
motor_a.run(500)
motor_b.run(500)
else:
motor_a.stop(Stop.BRAKE)
motor_b.stop(Stop.BRAKE)
#!/usr/bin/env pybricks-micropython from pybricks.hubs import EV3Brick from pybricks.ev3devices import Motor, ColorSensor, TouchSensor from pybricks.parameters import Port, Direction, Color, Button from pybricks.tools import wait, StopWatch from pybricks.media.ev3dev import SoundFile # Initialize the EV3 brick. ev3 = EV3Brick() # Configure the legs motor, which moves all four legs. Set the motor # direction to counterclockwise, so that positive speed values make # the legs move forward. legs_motor = Motor(Port.A, Direction.COUNTERCLOCKWISE) # Configure the trunk motor. Set the motor direction to # counterclockwise, so that positive speed values make the trunk move # upward. trunk_motor = Motor(Port.B, Direction.COUNTERCLOCKWISE) # Configure the neck motor with default settings. neck_motor = Motor(Port.D) # Set up the Touch Sensor. It is used to detect when the trunk has # moved to its maximum position. touch_sensor = TouchSensor(Port.S1) # Set up the Color Sensor. It is used to detect the red beam when the # neck has moved to its maximum position. color_sensor = ColorSensor(Port.S4)
#!/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
from helpers import getColorName
# Construct motors and robot
leftM = Motor(Port.C)
rightM = Motor(Port.B)
robot = DriveBase(leftM, rightM, 55, 121)
# Construct Color Sensors
leftS = ColorSensor(Port.S4)
rightS = ColorSensor(Port.S1)
# Leave the starting point
robot.drive_time(300, 0, 400)
robot.stop(Stop.BRAKE)
# Turn right
robot.drive_time(0, 90, 740)
robot.stop(Stop.BRAKE)
# Drive a while to pass intermediate area
robot.drive_time(300, 0, 2850)
print("end of drive_time")
# Start to read Color Censor
# print( "BLACK: ", Color.BLACK)
# print( "BLUE: ", Color.BLUE)
#!/usr/bin/env pybricks-micropython
from pybricks.hubs import EV3Brick
from pybricks.ev3devices import Motor, InfraredSensor
from pybricks.media.ev3dev import SoundFile
from pybricks.parameters import Button, Direction, Port, Stop
MEDIUM_MOTOR = Motor(port=Port.A, positive_direction=Direction.CLOCKWISE)
IR_SENSOR = InfraredSensor(port=Port.S4)
EV3_BRICK = EV3Brick()
is_gripping = False
MEDIUM_MOTOR.run_time(speed=500, time=1000, then=Stop.HOLD, wait=True)
while True:
if Button.BEACON in IR_SENSOR.buttons(channel=1):
if is_gripping:
MEDIUM_MOTOR.run_time(speed=1000,
time=2000,
then=Stop.HOLD,
wait=True)
EV3_BRICK.speaker.play_file(file=SoundFile.AIR_RELEASE)
is_gripping = False
else:
MEDIUM_MOTOR.run_time(speed=-1000,
from pybricks.media.ev3dev import SoundFile, ImageFile
from threading import Thread
# Import test files
#from .BrokenLineTest.py import BrokenLineTestFunc
# This program requires LEGO EV3 MicroPython v2.0 or higher.
# Click "Open user guide" on the EV3 extension tab for more information.
# Logger for debugging (connect through SSH to view files)
#logger = DataLog('dist', 'myLog', True, 'csv', False)
ev3 = EV3Brick()
# Motors initialised
leftMotor = Motor(Port.A)
rightMotor = Motor(Port.B)
grabberMotor = Motor(Port.C)
# Colour sensor initialised
lineSensor = ColorSensor(Port.S2)
# Ultrasonic sensor initialised
distanceSensor = UltrasonicSensor(Port.S4)
robot = DriveBase(leftMotor, rightMotor, wheel_diameter = 55.5, axle_track=105)
black = 10
gray = 40
white = 70
#sensor=EV3Sensor(Port.S1) # same port as above # higher value means brighter, lower value means darker #while True: # print(sensor.read()) # wait(2000) # Plan: # Start with a bang-bang controller # Attempt proportional controller # Attempt proportional-derivative controller # bang-bang left_sensor = EV3Sensor(Port.S2) right_sensor = EV3Sensor(Port.S3) left_motor = Motor(Port.A, Direction.COUNTERCLOCKWISE) right_motor = Motor(Port.D, Direction.COUNTERCLOCKWISE) wheelDiameter = 56 wheelBase = 175 car = DriveBase(left_motor, right_motor, wheelDiameter, wheelBase) #speed = 150 #turn_speed = 60 left_val = left_sensor.read() right_val = right_sensor.read() tolerance_range = 50 calibrate_val = 151 # L/R? L total = 0 run = True count = 0 watch = StopWatch()
#!/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)
#(90 degrees)
robot.drive_time(0, 90, 1000)
robot.stop()
#!/usr/bin/env pybricks-micropython
# from pybricks.hubs import EV3Brick
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
from pybricks.tools import wait, StopWatch
from pybricks.robotics import DriveBase
from pybricks.ev3devices import Motor
# This program requires LEGO EV3 MicroPython v2.0 or higher.
# Click "Open user guide" on the EV3 extension tab for more information.
WHEEL_DIAMETER_MM = 89
AXLE_TRACK_MM = 157
SOUND_VOLUME = 7
left_motor = Motor(Port.A, Direction.COUNTERCLOCKWISE)
right_motor = Motor(Port.B, Direction.COUNTERCLOCKWISE)
robot = DriveBase(left_motor, right_motor, WHEEL_DIAMETER_MM, AXLE_TRACK_MM)
brick.sound.beep(700, 80, SOUND_VOLUME)
robot.drive_time(0, 1, 10000)
robot.stop(stop_type=Stop.BRAKE)
left_motor.run_angle(90, 180, Stop.BRAKE)
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()
ev3.speaker.beep()
left_motor = Motor(Port.A)
right_motor = Motor(Port.D)
medium_left = Motor(Port.B)
medium_right = Motor(Port.C)
gs = GyroSensor(Port.S3)
csLeft = ColorSensor(Port.S1)
csMiddle = ColorSensor(Port.S2)
csRight = ColorSensor(Port.S4)
robot = DriveBase(left_motor, right_motor, axle_track=104, wheel_diameter=55.5)
def turnLeft(turn_angle):
angle = gs.angle()
gs.reset_angle(0)
robot.stop()
while (angle < turn_angle):
#!/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
from time import sleep
pm = Motor(Port.A) #Pickup Motor
lm = Motor(Port.B) #Left Motor
rm = Motor(Port.C) #Right Motor
#Play a sound.
brick.sound.beep()
done = False
#Function Assignments
def slam(): #What you would expect.
pm.run_time(-400, 1000)
def forward(sp,t):
robot.drive(sp, t)
#Truen right and left
#def turnleft():
# rm.run_time(300,1450)
# wait(1000)
