def __init__(self):
# Initialize the EV3 Brick.
self.ev3 = EV3Brick()
self.ev3.speaker.set_speech_options(voice='f3')
# large motors
self.left_motor = Motor(Port.A,
positive_direction=Direction.COUNTERCLOCKWISE,
gears=None)
self.right_motor = Motor(Port.B,
positive_direction=Direction.COUNTERCLOCKWISE,
gears=None)
# small (medium) motors
self.small_motor_left = Motor(Port.C,
positive_direction=Direction.CLOCKWISE,
gears=None)
self.small_motor_right = Motor(Port.D,
positive_direction=Direction.CLOCKWISE,
gears=None)
# gyro sensor
self.gyro_sensor = GyroSensor(Port.S3, Direction.CLOCKWISE)
# Initialize the drive base.
self.drive_base = DriveBase(self.left_motor,
self.right_motor,
wheel_diameter=93.5,
axle_track=120)
return
def __initSensors(self):
'''Sub-method for initializing Sensors.'''
self.logger.debug(self, "Starting sensor initialisation...")
try:
self.__gyro = GyroSensor(self.__conf2port[self.__config['gyroSensorPort']], Direction.CLOCKWISE if not self.__config['gyroInverted'] else Direction.COUNTERCLOCKWISE) if self.__config['gyroSensorPort'] != 0 else 0
self.logger.debug(self, 'Gyrosensor initialized sucessfully on port %s' % self.__config['gyroSensorPort'])
except Exception as exception:
self.__gyro = 0
self.logger.error(self, "Failed to initialize the Gyro-Sensor - Are u sure it's connected to Port %s?" % exception, exception)
try:
self.__rLight = ColorSensor(
self.__conf2port[self.__config['rightLightSensorPort']]) if self.__config['rightLightSensorPort'] != 0 else 0
self.logger.debug(self, 'Colorsensor initialized sucessfully on port %s' % self.__config['rightLightSensorPort'])
except Exception as exception:
self.logger.error(self, "Failed to initialize the right Color-Sensor - Are u sure it's connected to Port %s?" % exception, exception)
try:
self.__lLight = ColorSensor(
self.__conf2port[self.__config['leftLightSensorPort']]) if self.__config['leftLightSensorPort'] != 0 else 0
self.logger.debug(self, 'Colorsensor initialized sucessfully on port %s' % self.__config['leftLightSensorPort'])
except Exception as exception:
self.logger.error(self, "Failed to initialize the left Color-Sensor - Are u sure it's connected to Port %s?" % exception, exception)
try:
self.__touch = TouchSensor(self.__conf2port[self.__config['backTouchSensor']]) if self.__config['backTouchSensor'] != 0 else 0
self.logger.debug(self, 'Touchsensor initialized sucessfully on port %s' % self.__config['backTouchSensor'])
except Exception as exception:
self.logger.error(self, "Failed to initialize the Touch-Sensor - Are u sure it's connected to Port %s?" % exception, exception)
self.logger.debug(self, "Sensor initialisation done")
def __init__(self):
self.brick = EV3Brick()
self.frontMotor = Motor(Port.D)
self.rearMotor = Motor(Port.A)
self.leftMotor = Motor(Port.C)
self.rightMotor = Motor(Port.B)
if path.exists('sensorpoints.py'):
import sensorpoints
self.leftSensor = LightSensor(Port.S3, sensorpoints.leftLow,
sensorpoints.leftHigh)
self.rightSensor = LightSensor(Port.S2, sensorpoints.rightLow,
sensorpoints.rightHigh)
else:
self.leftSensor = LightSensor(Port.S3, 10, 105)
self.rightSensor = LightSensor(Port.S2, 20, 160)
self.gyroSensor = GyroSensor(Port.S1)
wait(100)
self.gyroSensor.speed()
self.gyroSensor.angle()
wait(500)
self.gyroSensor.reset_angle(0.0)
wait(200)
def __init__(self, robot):
self.robot = robot
try:
self.gyro = GyroSensor(Port.S2, Direction.CLOCKWISE)
except:
self.gyro = None
print("No Gyro Sensor plugged into Port 2. Cannot run Greyden's Skills. :-(")
print()
def __init__(self, left_motor_port, right_motor_port, med_motor_port,
gyro_port, wheel_diameter, wheel_base):
self.left_motor = Motor(left_motor_port)
self.right_motor = Motor(right_motor_port)
# self.med_motor = Motor(med_motor_port)
self.robot = DriveBase(self.left_motor, self.right_motor,
wheel_diameter, wheel_base)
self.gyro = GyroSensor(gyro_port)
def fall_check(self):
fall_gyro = GyroSensor(Port.S4, Direction.CLOCKWISE)
while True:
real_angle = fall_gyro.angle()
if real_angle > 45 or real_angle < -45:
self.brick.speaker.beep()
else:
wait(30)
print(real_angle)
def run():
motor_b = Motor(Port.B)
motor_c = Motor(Port.C)
Gyro = GyroSensor(Port.S1)
while Gyro.angle() <= 65:
motor_c.run(900)
motor_b.run(-900)
motor_c.stop(Stop.BRAKE)
motor_b.stop(Stop.BRAKE)
class Robot():
#robot hardware
brick = EV3Brick()
wheel_left = Motor(Port.A)
wheel_right = Motor(Port.B)
arm_left = Motor(Port.D)
arm_right = Motor(Port.C)
gyro = GyroSensor(Port.S1, Direction.COUNTERCLOCKWISE)
color_left = ColorSensor(Port.S2)
color_right = ColorSensor(Port.S3)
chassis = DriveBase(wheel_left,
wheel_right,
wheel_diameter=49.5,
axle_track=150)
@classmethod
def reset_settings(cls):
cls.chassis.stop()
cls.chassis.settings(115, 460, 88, 352)
@classmethod
def settings(cls,
straight_speed=None,
straight_acceleration=None,
turn_rate=None,
turn_acceleration=None):
cls.chassis.stop() #Settings can only be changed while stopped
current_settings = cls.chassis.settings()
cls.chassis.settings(
straight_speed if straight_speed is not None else
current_settings[0], straight_acceleration
if straight_acceleration is not None else current_settings[1],
turn_rate if turn_rate is not None else current_settings[2],
turn_acceleration
if turn_acceleration is not None else current_settings[3])
@classmethod
def brake(cls):
cls.chassis.stop()
cls.wheel_left.brake()
cls.wheel_right.brake()
@classmethod
def reset_gyro(cls):
cls.gyro.reset_angle(0)
cls.gyro.angle()
cls.gyro.speed()
cls.gyro.angle()
wait(10)
def rotate_180_by_gyro(self):
gyro_sensor = GyroSensor(Port.S4)
gyro_sensor.reset_angle(0)
self.left_motor.run(self.TRUCK_SPEED)
self.right_motor.run(-self.TRUCK_SPEED)
while (gyro_sensor.angle() < 135):
print("Angle: ", gyro_sensor.angle())
wait(1)
self.stop()
wait(4000)
def turn(angle, max_speed, gyro_port, drive_base):
gyro = GyroSensor(gyro_port, Direction.COUNTERCLOCKWISE)
ev3 = EV3Brick()
ev3.screen.clear()
initial_error = gyro.angle() - angle
while abs(gyro.angle() - angle) > 2:
error = gyro.angle() - angle
speed = max_speed * (error / initial_error)
ev3.screen.print(gyro.angle(), error, speed)
drive_base.drive(0, speed)
wait(10)
def main():
# sound test
log.info('test beep')
brick.sound.beep()
# color sensor test
sensor_color = ColorSensor(ROBOT['sensor_color_port'])
log.debug('color sensor: color=%s' % sensor_color.color())
# gyro sensor test
sensor_gyro = GyroSensor(ROBOT['sensor_gyro_port'])
log.debug('gyro sensor: speed=%d, angle=%d' %
(sensor_gyro.speed(), sensor_gyro.angle()))
def __init__(self,
left_motor=Motor(Port.A),
right_motor=Motor(Port.B),
attachment_motor=(Motor(Port.C)),
wheel_diameter=56,
axle_track=145):
#wheel_diameter=43, axle_track=110):
self.left_motor = left_motor
self.right_motor = right_motor
self.attachment_motor = attachment_motor
self.color_sensor = ColorSensor(Port.S2)
self.gyro_sensor = GyroSensor(Port.S1)
super().__init__(left_motor, right_motor, wheel_diameter, axle_track)
def run():
motor_b = Motor(Port.B)
motor_c = Motor(Port.C)
Gyro = GyroSensor(Port.S1)
Gyro.reset_angle(0)
motor_b.run_angle(500, 720, Stop.BRAKE, False)
motor_c.run_angle(500, 720, Stop.BRAKE, True)
wait(10)
while Gyro.angle() <= 180:
motor_c.run(100)
motor_b.run(-100)
wait(10)
motor_b.run_angle(500, 720, Stop.BRAKE, False)
motor_c.run_angle(500, 720, Stop.BRAKE, True)
def test_gyro_drift(port=Port.S4):
gyro = GyroSensor(port)
printMsg("Checking for drift.")
numTests = 5
drifting = False
for i in range(numTests):
angle = gyro.angle()
printMsg("Test %i/%i = %d" % (i + 1, numTests, angle))
if angle != 0:
drifting = True
break # no need to keep testing
wait(1000)
return drifting
def get_robot():
# Initialize two motors and a drive base
wheel_diameter_mm=54
axle_track_mm=152
crane_motor=Motor(Port.A)
left_motor=Motor(Port.C)
right_motor=Motor(Port.B)
robot = DriveBase(left_motor, right_motor, wheel_diameter_mm, axle_track_mm)
#robot.drive(2000, 0)
gyro=GyroSensor(Port.S1)
calibrate_gyro(gyro)
color_sensor_left = ColorSensor(Port.S3)
color_sensor_right = None #ColorSensor(Port.S2)
# Initialize the Ultrasonic Sensor.
# obstacle_sensor = UltrasonicSensor(Port.S4)
return robot, crane_motor, left_motor, right_motor,color_sensor_left, color_sensor_right, gyro
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 __init__(self):
"""Class that represents the robot
"""
try:
self.state = "Port 1: Right Color"
self.right_color = ColorSensor(Port.S1)
self.state = "Port 2: Center Color"
self.center_color = ColorSensor(Port.S2)
self.state = "Port 3: Left Color"
self.left_color = ColorSensor(Port.S3)
self.state = "Port 4: Gyro"
self.gyro = GyroSensor(Port.S4, Direction.COUNTERCLOCKWISE)
self.state = "Port A: Left Motor"
self.left_motor = Motor(Port.A)
self.state = "Port B: Right Motor"
self.right_motor = Motor(Port.B)
self.state = "Port C: Linear Gear"
self.linear_attachment_motor = Motor(Port.C)
self.state = "Port D: Block Dropper"
self.dropper_attachment_motor = Motor(Port.D)
self.wheel_diameter = 55
self.axle_track = 123
self.drive_base = DriveBase(self.left_motor, self.right_motor,
self.wheel_diameter, self.axle_track)
self.state = "OK"
self.clock = StopWatch()
self.dance_clock = 0
self.sign = 1
except:
brick.screen.clear()
big_font = Font(size=18)
brick.screen.set_font(big_font)
brick.screen.draw_text(0, 20, "Error!")
brick.screen.draw_text(0, 40, self.state)
def __init__(self,
port,
left_motor,
right_motor,
wheel_radius,
axis_radius,
debug=False):
self.port = port
self.left_motor = left_motor
self.right_motor = right_motor
self.wheel_radius = wheel_radius
self.axis_radius = axis_radius
self.debug = debug
# either connect to real hardware, or our dummy sim class
self.gyro = GyroSensor(self.port)
self.degrees = int(0)
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 __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()
#!/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:
AXLE_TRACK_MM=135
SENSOR_TO_AXLE=118
# Get wheel circumference
WHEEL_CIRCUM_MM=3.149*89
# 360 degrees -> WHEEL_CIRCUM_MM so 1 degree -> ?
DEGREES_PER_MM=360/WHEEL_CIRCUM_MM
#drive motors
left_motor=Motor(Port.C, Direction.CLOCKWISE)
right_motor=Motor(Port.D, Direction.CLOCKWISE)
robot = DriveBase(left_motor, right_motor, WHEEL_DIAMETER_MM, AXLE_TRACK_MM)
crane_motor=Motor(Port.B, Direction.CLOCKWISE, [8,24])
gyro=GyroSensor(Port.S1, Direction.COUNTERCLOCKWISE)
# color_sensor_left = ColorSensor(Port.S1)
color_sensor_right = ColorSensor(Port.S4)
def move_to_color(
color_sensor,
stop_on_color,
speed_mm_s):
robot.drive(speed_mm_s, 0)
# Check if color reached.
while color_sensor.color() != stop_on_color:
wait(10)
robot.stop(stop_type=Stop.BRAKE)
#!/usr/bin/env pybricks-micropython
from pybricks import ev3brick as brick
from pybricks.ev3devices import Motor, GyroSensor
from pybricks.parameters import Port, Stop, Direction, Button
from pybricks.tools import print, wait, StopWatch
from pybricks.robotics import DriveBase
import time
left = Motor(Port.B)
right = Motor(Port.C)
gyro = GyroSensor(Port.S1)
gyro.reset_angle(0)
data = open("m_angle.data", "w")
def rot(spd=40, ang=0):
while(True):
if(gyro.angle() > ang):
right.run(spd)
left.run(spd * -1)
if(gyro.angle() < ang):
left.run(spd)
right.run(spd * -1)
if(gyro.angle() == ang):
left.stop(Stop.HOLD)
right.stop(Stop.HOLD)
time.sleep(0.5)
if(gyro.angle() == ang):
data.write(str(gyro.angle()) + "\n")
gyro.reset_angle(0)
break
# This program requires LEGO EV3 MicroPython v2.0 or higher.
# Click "Open user guide" on the EV3 extension tab for more information.
# Variables and constants
ev3 = EV3Brick()
leftmotor = Motor(Port.C, Direction.CLOCKWISE)
rightmotor = Motor(Port.B, Direction.CLOCKWISE)
#left medium motor
mediummotor = Motor(Port.D, Direction.COUNTERCLOCKWISE)
#right medium motor
mediummotor2 = Motor(Port.A, Direction.COUNTERCLOCKWISE)
robot = DriveBase(leftmotor, rightmotor, 55.85, 108)
robot.settings(300, 100, 200, 100)
rightcolor = ColorSensor(Port.S1)
leftcolor = ColorSensor(Port.S2)
gyroSensor = GyroSensor(Port.S3)
black = 3
white = 35
threshold = int((black + white) / 2) #19
print(threshold)
#seeing white first and then line squaring
def linesquare():
lightrange = range(threshold - 2,
threshold + 2) #light range for final result
#lightrange = range(threshold - 4, threshold + 4) #light rnage for adjustment
#First, move the robot straight until one of the sensor sees range.
while rightcolor.reflection() > 4 and leftcolor.reflection() > 4:
robot.drive(70, 0)
# Initialize the motors.
left_motor = Motor(Port.B, positive_direction=Direction.COUNTERCLOCKWISE)
right_motor = Motor(Port.C, positive_direction=Direction.COUNTERCLOCKWISE)
lift_motor = Motor(Port.A)
forklift_motor = Motor(Port.D, positive_direction=Direction.COUNTERCLOCKWISE)
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, "Alright, let's do this.")
ev3.speaker.beep()
gyro_sensor = GyroSensor(Port.S2, Direction.COUNTERCLOCKWISE)
def gyro_turn(angle, speed=150):
gyro_sensor.reset_angle(0)
if angle < 0:
while gyro_sensor.angle() > angle:
left_motor.run(speed=(-1 * speed))
right_motor.run(speed=speed)
wait(10)
elif angle > 0:
while gyro_sensor.angle() < angle:
left_motor.run(speed=speed)
right_motor.run(speed=(-1 * speed))
wait(10)
else:
#!/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
obstacle_sensor = UltrasonicSensor(Port.S3)
gyro_sensor_front = GyroSensor(Port.S4)
right_motor = Motor(Port.C)
left_motor = Motor(Port.B)
wheel_diameter = 56
axle_track = 114
robot = DriveBase(left_motor, right_motor, wheel_diameter, axle_track)
def start():
while True:
robot.drive(200, 0)
while obstacle_sensor.distance() < 250:
robot.stop()
obstacle_avoidance()
def obstacle_avoidance(step = 2000, speed = 200, min_dist = 250, rotation_angle = 90):
print('avoid')
distance = 0
rotate(rotation_angle)
distance += drive_past(step, speed, min_dist, rotation_angle)
# 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()
# Write your program here.
ev3.speaker.beep()
left_up_motor = Motor(Port.A, positive_direction=Direction.COUNTERCLOCKWISE)
right_up_motor = Motor(Port.B, positive_direction=Direction.COUNTERCLOCKWISE)
left_down_motor = Motor(Port.C, positive_direction=Direction.CLOCKWISE)
right_down_motor = Motor(Port.D, positive_direction=Direction.CLOCKWISE)
Gyro = GyroSensor(Port.S1, positive_direction=Direction.CLOCKWISE)
Gyro.reset_angle(0)
for i in range(3):
Gyro_angle = Gyro.angle()
#Gyro_speed = Gyro.speed()
print('Gyro angle: ', Gyro_angle)
#print('Gyro speed: ', Gyro_speed)
left_up_motor.run(300)
right_up_motor.run(300)
left_down_motor.run(300)
right_down_motor.run(300)
time.sleep(1)
for i in range(5):
done = False # flag to halt program DTFlag = False watch = StopWatch() amplitude = 90 # ================================= mB = Motor(Port.B) # initialize two large motors mC = Motor(Port.C) robot = DriveBase(mB, mC, 94, 115) # wheel OD=94mm, wheelbase=115mm mB.set_run_settings(200, 250) # max speed, max accel mC.set_run_settings(200, 250) # max speed, max accel gy = GyroSensor(Port.S3) gy2 = GyroSensor(Port.S2) gy.mode='GYRO-RATE' # deliver turn-rate (must integrate for angle) gy2.mode='GYRO-RATE' # deliver turn-rate (must integrate for angle) sleep(0.5) gy.mode='GYRO-ANG' # changing modes causes recalibration gy2.mode='GYRO-ANG' # changing modes causes recalibration sleep(3) gy.reset_angle(0) gy2.reset_angle(0) mB.reset_angle(0) mC.reset_angle(0) angle = 0 # global var holding accumulated turn angle
ev3 = EV3Brick() # Initialize the motors connected to the drive wheels. left_motor = Motor(Port.D) right_motor = Motor(Port.A) # Initialize the motor connected to the arms. arm_motor = Motor(Port.C) # Initialize the Color Sensor. It is used to detect the colors that command # which way the robot should move. color_sensor = ColorSensor(Port.S1) # Initialize the gyro sensor. It is used to provide feedback for balancing the # robot. gyro_sensor = GyroSensor(Port.S2) # Initialize the ultrasonic sensor. It is used to detect when the robot gets # too close to an obstruction. ultrasonic_sensor = UltrasonicSensor(Port.S4) # Initialize the timers. fall_timer = StopWatch() single_loop_timer = StopWatch() control_loop_timer = StopWatch() action_timer = StopWatch() # The following (UPPERCASE names) are constants that control how the program # behaves. GYRO_CALIBRATION_LOOP_COUNT = 200
#!/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
esquerda = Motor(Port.B, Direction.COUNTERCLOCKWISE)
direita = Motor(Port.C, Direction.COUNTERCLOCKWISE)
MotorMA = Motor(Port.A)
MotorMD = Motor(Port.D)
melhorSensor = GyroSensor(Port.S2)
# ev3 = EV3Brick()
gabriel = DriveBase(esquerda, direita, wheel_diameter=100,axle_track=166.2)
def Acelera(qp_max, qf):
# dados iniciais ----------------------
qi = 0 # posição inicial (em mm)
# primeiro cálculo
Dq = qf - qi # variação da posição (distância, em mm)