def __init__(self, output_a, output_d):
self.right_motor = LargeMotor(output_a)
self.left_motor = LargeMotor(output_d)
self.btn = Button()
self.cl = ColorSensor()
self.us = UltrasonicSensor()
self.us.mode='US-DIST-CM'
self.gy = GyroSensor()
self.gy.mode='GYRO-ANG'
self.defaultSpeed = 450
self.right_sp = 450
self.left_sp = 450
self.lastColor1 = None
self.lastColor2 = None
self.lastColor3 = None
self.node = [(0,0)]
# self.direction = None
self.directionStr = ['top', 'right', 'bottom', 'left']
def test_color_and_us_sensor_downwards(self):
test_args = ["program", "-t", "config_large"]
with patch.object(sys, 'argv', test_args):
sim = Process(target=__main__.main, daemon=True)
sim.start()
cs.client_socket = None
sleep(5)
clm = ColorSensor(INPUT_2)
usb = UltrasonicSensor(INPUT_4)
usb.mode = "US-DIST-CM"
tank_drive = MoveDifferential(OUTPUT_A, OUTPUT_D, EV3EducationSetTire,
15 * STUD_MM)
self.assertEqual(clm.color, 1)
tank_drive.on_for_rotations(0, -55, 1)
tank_drive.on_for_rotations(10, 0, 0.2)
tank_drive.stop()
self.assertEqual(clm.color, 5)
tank_drive.turn_left(30, -40)
self.assertEqual(usb.value(), 20.0)
tank_drive.turn_left(30, 120)
self.assertEqual(usb.value(), 2550.0)
cs.client_socket.client.close()
sim.terminate()
def __init__(self, *args, **kwargs):
self.exposed_support_tilt = LargeMotor(OUTPUT_A)
self.exposed_support_power = LargeMotor(OUTPUT_B)
self.exposed_right_us = UltrasonicSensor(INPUT_1)
self.exposed_left_us = UltrasonicSensor(INPUT_2)
self.exposed_drop_us = UltrasonicSensor(INPUT_3)
self.exposed_rear_us = UltrasonicSensor(INPUT_4)
super().__init__(*args, **kwargs)
def move(motor_pair, color_sensor, caminar, sound):
ultrasonic_sensor = UltrasonicSensor()
ts1 = TouchSensor(INPUT_1)
ts2 = TouchSensor(INPUT_4)
if color_sensor.color == 3:
caminar = True
while caminar:
if color_sensor.color == 5:
caminar = False
motor_pair.off()
sound.play('hasta_la_vista.wav')
break
motor_pair.on(steering=0, speed=60)
if ts1.is_pressed and ts2.is_pressed:
reverse(motor_pair, sound, 100, 3)
if ts1.is_pressed:
reverse(motor_pair, sound, -100, 2)
if ts2.is_pressed:
reverse(motor_pair, sound, 100, 2)
if ultrasonic_sensor.distance_centimeters < 10:
reverse(motor_pair, sound, 100, 3)
def __init__(self, motor_address=OUTPUT_D, us_sensor_address=INPUT_2, start_open=True):
self.claw_motor = MediumMotor(motor_address)
self.eyes = UltrasonicSensor(us_sensor_address)
if start_open and not self.is_open():
self.open()
elif not start_open and self.is_open():
self.close()
def __init__(self):
self.leds = Leds()
self.tank_drive = MoveTank(OUTPUT_A, OUTPUT_B)
self.tank_drive.set_polarity(LargeMotor.POLARITY_INVERSED)
self.color = ColorSensor()
self.ultra = UltrasonicSensor()
self.sound = Sound()
def __init__(self, sensorList=[]):
try:
self.tank = MoveTank(OUTPUT_B, OUTPUT_C)
self.outputList = [OUTPUT_B, OUTPUT_C]
except:
self.tank = None
try:
self.cs = ColorSensor()
except:
self.cs = None
try:
self.gyro = GyroSensor()
except:
self.gyro = None
try:
self.ultrasonicSensor = UltrasonicSensor()
except:
self.ultrasonicSensor = None
try:
self.large = LargeMotor(OUTPUT_D)
self.outputList.append(OUTPUT_D)
except:
self.large = None
try:
self.medium = MediumMotor(OUTPUT_D)
self.outputList.append(OUTPUT_D)
except:
self.medium = None
def __init__(self, left_motor_port, right_motor_port, infra_mode,
ultra_mode):
self.__moveSteering = MoveSteering(left_motor_port, right_motor_port)
self.__mediumMotor = MediumMotor()
self.__ir = InfraredSensor()
self.__ir.mode = infra_mode
self.__us = UltrasonicSensor()
self.__us.mode = ultra_mode
def constructor():
# color_sensor = ColorSensor()
sound = Sound()
motor_pair = MoveSteering(OUTPUT_B, OUTPUT_C)
# touch_sensor = TouchSensor()
ultrasonic_sensor = UltrasonicSensor()
return sound, motor_pair, ultrasonic_sensor
def __init__(self, motor, sensor, midPoint):
self.motor = LargeMotor(motor)
self.sensor = UltrasonicSensor(sensor)
self.midPoint = midPoint
self.motorPositionUp = self.motor.position - 20
self.motorPositionDown = self.motor.position + 20
self.integral = 0
self.integralCount = 0
def test_ultrasonic():
us = UltrasonicSensor(INPUT_3)
for mode in us.modes:
if 'SI' in mode:
continue
us.mode = mode
print('The current ultrasonic mode is: {}'.format(us.mode))
print('Distance in cm: {}'.format(us.distance_centimeters))
print('Distance in inches: {}'.format(us.distance_inches))
print('Another ultrasonic sensor nearby? {}'.format(
us.other_sensor_present))
sleep(0.5)
while not button.any():
print('Inches: {}, cm: {}'.format(us.distance_inches,
us.distance_centimeters))
sleep(0.5)
def __init__(self):
print("Hockey Bot initialized")
self.bat = MediumMotor(OUTPUT_C)
self.cs = ColorSensor(INPUT_2)
self.cs.mode = 'COL-REFLECT'
self.us = UltrasonicSensor(INPUT_1)
self.drive = MoveTank(OUTPUT_A, OUTPUT_B)
self.stop = False
self.kickAngle = 180
def __init__(self):
self.tank_pair = MoveTank(OUTPUT_B, OUTPUT_C)
self.color_sensor = ColorSensor()
self.ultrasonic = UltrasonicSensor()
self.sound = Sound()
self.tile_length = 200
# Ranges for color intensities
self.black_range = range(0, 30)
self.white_range = range(30, 100)
self.sensor_dist = 86
class EdgeAvoider(Avoider):
def __init__(self):
self.color = 6 # white
self.drive_actions_lcs = [
MoveAction(Speed.NORMAL, -200),
RotateAction(Speed.NORMAL, -60)
] # L/C cs triggered
self.drive_actions_rcs = [
MoveAction(Speed.NORMAL, -200),
RotateAction(Speed.NORMAL, 60)
] # R cs triggered
self.drive_actions_us = [
MoveAction(Speed.NORMAL, 200),
RotateAction(Speed.NORMAL, -60)
] # Us triggered
self.csL = ColorSensor(address=INPUT_1)
self.csC = ColorSensor(address=INPUT_3)
self.csR = ColorSensor(address=INPUT_4)
self.us = UltrasonicSensor()
self.us.mode = 'US-DIST-CM'
def triggered(self):
if self.csL.color is self.color \
or self.csC.color is self.color \
or self.csR.color is self.color:
return constant.color_sensor_id
if self.us.value() > 40:
return constant.us_rear_sensor_id
return -1
def actions(self):
if self.csL.color is self.color or self.csC.color is self.color:
return self.drive_actions_lcs
if self.csR.color is self.color:
return self.drive_actions_rcs
if self.us.value() > 40:
return self.drive_actions_us
return []
def __init__(self):
self.locomotion = RobotLocomotion(OUTPUT_C, OUTPUT_B)
self.eyes = UltrasonicSensor(INPUT_1)
self.should_run = True
self.wink_arm = TouchyArm(OUTPUT_A, INPUT_4)
self.throw_arm = Thrower(OUTPUT_D)
self.has_ball = True
self.voice = Sound()
atexit.register(self.reset)
self.reset()
def __init__(self):
self.host_bt_mac = "AC:FD:CE:82:1E:CC"
self.port = 1
self.backlog = 1
self.size = 1024
self.s = socket.socket(socket.AF_BLUETOOTH, socket.SOCK_STREAM,
socket.BTPROTO_RFCOMM)
self.s.bind((self.host_bt_mac, self.port))
self.s.listen(self.backlog)
self.us = UltrasonicSensor()
def __init__(self):
# colour sensor instance
self.cl = ColorSensor()
self.cl.mode = 'COL-COLOR'
# sound class instance
self.sound = Sound()
# motor class instance
self.mB = LargeMotor('outB')
self.mC = LargeMotor('outC')
self.drive = MoveTank(OUTPUT_B, OUTPUT_C)
self.mdiff = MoveDifferential(
OUTPUT_B, OUTPUT_C, EV3Tire,
16 * 8) # 8 is the distance between the 2 wheels
# ultrasonic sensor instance
self.us = UltrasonicSensor()
self.us.mode = 'US-DIST-CM'
# varaibles that helps to count the tile and check its position
self.count_black_tile = 0
self.distance_right = 0
self.distance_left = 0
def __init__(self):
"""Initialize robot's sensors and define distances and color ranges.
"""
self.tank_pair = MoveTank(OUTPUT_B, OUTPUT_C)
self.color_sensor = ColorSensor()
self.ultrasonic = UltrasonicSensor()
self.sound = Sound()
self.tile_length = 200
self.sensor_dist = 86
# Ranges for color intensities
self.black_range = range(0, 30)
self.white_range = range(30, 100)
def __init__(self):
self.color = 6 # white
self.drive_actions_lcs = [
MoveAction(Speed.NORMAL, -200),
RotateAction(Speed.NORMAL, -60)
] # L/C cs triggered
self.drive_actions_rcs = [
MoveAction(Speed.NORMAL, -200),
RotateAction(Speed.NORMAL, 60)
] # R cs triggered
self.drive_actions_us = [
MoveAction(Speed.NORMAL, 200),
RotateAction(Speed.NORMAL, -60)
] # Us triggered
self.csL = ColorSensor(address=INPUT_1)
self.csC = ColorSensor(address=INPUT_3)
self.csR = ColorSensor(address=INPUT_4)
self.us = UltrasonicSensor()
self.us.mode = 'US-DIST-CM'
def __init__(self):
"""
Initializer for a Robot.
"""
self.cs = ColorSensor()
self.left_touch = TouchSensor('ev3-ports:in1')
self.right_touch = TouchSensor('ev3-ports:in4')
self.us = UltrasonicSensor()
self.tank_drive = Robot.get_tank_drive()
self.sound = Sound()
self.leds = Leds()
self.setup_sensors()
def test_touch_and_us_sensor_forward(self):
test_args = ["program", "-t", "config_small"]
with patch.object(sys, 'argv', test_args):
sim = Process(target=__main__.main, daemon=True)
sim.start()
cs.client_socket = None
sleep(5)
ts1 = TouchSensor(INPUT_1)
usf = UltrasonicSensor(INPUT_3)
usf.mode = "US-DIST-CM"
tank_drive = MoveDifferential(OUTPUT_A, OUTPUT_D, EV3EducationSetTire, 15 * STUD_MM)
tank_drive.turn_right(30, 90)
self.assertEqual(ts1.is_pressed, 0)
sleep(0.2)
self.assertAlmostEqual(usf.value(), 756, delta=10)
val = usf.value()
print(val)
tank_drive.on_for_distance(50, 450)
self.assertAlmostEqual(val - 450, usf.value(), delta=15)
self.assertEqual(False, ts1.is_pressed)
sleep(3)
tank_drive.on_for_rotations(20, 0, 0.3)
self.assertEqual(True, ts1.is_pressed)
cs.client_socket.client.close()
sim.terminate()
def test_give_existing_port(self):
with patch(
'ev3dev2simulator.connector.device_connector.get_client_socket'
) as Device_get_client_socketMock:
with patch(
'ev3dev2simulator.connector.sensor_connector.get_client_socket'
) as get_client_socketMock:
mock_instance = MagicMock()
Device_get_client_socketMock.return_value = mock_instance
mock_instance.send_command.return_value = 'ev3-ports:in3'
us = UltrasonicSensor(ev3.INPUT_1)
self.assertEqual(us.address, 'ev3-ports:in3')
def test_determine_connected_port(self):
with patch(
'ev3dev2simulator.connector.device_connector.get_client_socket'
) as Device_get_client_socketMock:
with patch(
'ev3dev2simulator.connector.sensor_connector.get_client_socket'
) as get_client_socketMock:
mock_instance = MagicMock()
Device_get_client_socketMock.return_value = mock_instance
mock_instance.send_command.return_value = 'ev3-ports:in1'
us = UltrasonicSensor()
self.assertEqual(us.address, 'ev3-ports:in1')
self.assertEqual(us.connector.address, 'ev3-ports:in1')
def __init__(self):
# Large motors
self.lm_left_port = "outB"
self.lm_right_port = "outA"
self.lm_left = LargeMotor(self.lm_left_port)
self.lm_right = LargeMotor(self.lm_right_port)
# distance at which sensor motor start moving
self.move_sensor_check_degrees = 400
self.move_degrees = 570 # one tile distance
self.move_speed = 35
self.after_crash_degrees = 200
self.steering_turn_speed = 30 # turning left or right
self.steering_turn_degrees = 450
self.steering_turn_fwd_degrees = 150 # distance to move after turning
# distance at which sensors start spinning
self.steering_sensor_check_degrees = 50
self.btn = Button()
# small motor
self.sm_port = "outC"
self.sm = Motor(self.sm_port)
self.sm_turn_speed = 30
self.sm_center_turn_angle = 90
self.sm_side_turn_angle = 110
self.sm_is_left = False
# color sensor
self.color_sensor_port = "in1"
self.color_sensor = ColorSensor(self.color_sensor_port)
self.color_sensor.mode = ColorSensor.MODE_COL_REFLECT
self.color_sensor_values = []
# regulations
self.regulation_desired_value = 4
self.regulation_max_diff = 3
self.regulation_p = 1.5
self.regulation_tick = 0.03
# ultrasonic sensor
self.ultrasonic_sensor_port = "in4"
self.ultrasonic_sensor = UltrasonicSensor(self.ultrasonic_sensor_port)
self.ultrasonic_sensor.mode = 'US-DIST-CM'
self.ultrasonic_tile_length = 30
self.ultrasonic_max_value = 255
self.ultrasonic_sensor_values = []
# touch sensors
self.touch_right = TouchSensor("in2")
self.touch_left = TouchSensor("in3")
def __init__(self, *args_module_name):
super().__init__(*args_module_name)
self.m_left = OUTPUT_B # Motor left
self.m_right = OUTPUT_A # Motor right
self.s_us = INPUT_1 # Sensor Ultrasonic
self.sl_left = INPUT_3 # Sensor Light left
self.sl_right = INPUT_4 # Sensor Right left
self.mMT = MoveTank(self.m_left, self.m_right) # move with 2 motors
self.mMS = MoveSteering(self.m_left, self.m_right) # move on position
self.sUS = UltrasonicSensor(self.s_us)
self.sLS_left = LightSensor(INPUT_3)
self.sLS_right = LightSensor(INPUT_4)
self.thread_detect_danger = ControlThread()
self.thread_detect_light_intesity = ControlThread()
self.stop_detect_light_intesity = False
def __init__(self):
self.playDebugSound = False
self.s = Sound()
self.display = Display()
self.display.clear()
self.colorSensor = ColorSensor(INPUT_2)
self.lastColor = 0
self.usSensor = UltrasonicSensor(INPUT_3)
self.usSensor.mode = 'US-DIST-CM'
self.touchL = TouchSensor(INPUT_1)
self.touchR = TouchSensor(INPUT_4)
def __init__(self):
self.tankDrive = MoveTank(OUTPUT_A, OUTPUT_D)
self.motorA = LargeMotor(OUTPUT_A)
self.motorD = LargeMotor(OUTPUT_D)
self.myGyroSensor = GyroSensor()
self.myGripper = RobotGripper()
self.myUltrasonicSensor = UltrasonicSensor()
self.myColorSensor = ColorSensor()
self.Turning = False
self.Moving = False
self.myAngle = 0
self.positionX = 0
self.positionY = 0
self.myDefaultSpeed = 50
self.desiredBarCode = "BWWB"
self.myGPS = IGPS()
def __init__(self, bluetooth=None):
"""
Initializer for a Robot.
"""
self.bluetooth = bluetooth
if bluetooth:
self.bluetooth.initiate_connection()
print('connected')
self.cs = ColorSensor()
self.left_touch = TouchSensor('ev3-ports:in1')
self.right_touch = TouchSensor('ev3-ports:in4')
self.us = UltrasonicSensor()
self.tank_drive = Robot.get_tank_drive()
self.sound = Sound()
self.leds = Leds()
self.setup_sensors()
class RobotBehaviourThread(threading.Thread):
move_steering = MoveSteering(OUTPUT_B, OUTPUT_C)
color_sensor = ColorSensor()
color_sensor.mode = ColorSensor.MODE_COL_REFLECT
ultrasonic_sensor = UltrasonicSensor()
gyroscope = GyroSensor()
touch_sensor = TouchSensor()
def __init__(self, callback=None):
super().__init__()
print("Initializing thread")
self._stop_event = threading.Event()
self.callback = callback
def stop(self):
self._stop_event.set()
def stopped(self):
return self._stop_event.is_set()
def move(self, angle, speed):
self.move_steering.on(angle, SpeedPercent(speed))
def turn_degrees(self, degrees, direction):
initial_angle = self.gyroscope.angle
direction_actual = -100 if direction <= 0 else 100
self.move(direction_actual, 25)
print("rotating")
print(initial_angle)
while self.gyroscope.angle < initial_angle + degrees and self.gyroscope.angle > initial_angle - degrees:
pass
print("done rotating")
self.stop_movement()
def stop_movement(self):
self.move_steering.off(brake=True)
def get_color(self):
self.color_sensor.mode = 'COL-COLOR'
#print(self.color_sensor.value())
return self.color_sensor.value()
def __init__(Self, WheelDistance, WheelDiameter, TankBase, MedMotors,
Ultrasonic, Color1, Color2,
Gyro): # WheelDistance and WheelDiameter in cm.
# Import the parts of the robot.
from ev3dev2.button import Button
from ev3dev2.display import Display
from ev3dev2.motor import MoveTank, MediumMotor, LargeMotor, SpeedRPS, OUTPUT_A, OUTPUT_B, OUTPUT_C, OUTPUT_D
from ev3dev2.sensor import INPUT_1, INPUT_2, INPUT_3, INPUT_4
from ev3dev2.sensor.lego import UltrasonicSensor, ColorSensor, GyroSensor
# Define the ports.
Ports = {
"A": OUTPUT_A,
"B": OUTPUT_B,
"C": OUTPUT_C,
"D": OUTPUT_D,
"1": INPUT_1,
"2": INPUT_2,
"3": INPUT_3,
"4": INPUT_4
}
# Define the parts of the robot.
Self.SpeedRPS = SpeedRPS
Self.WheelDistance = WheelDistance
Self.WheelCircumference = WheelDiameter * 3.1416
Self.TankBase = MoveTank(Ports[TankBase[0]], Ports[TankBase[1]])
Self.DriveMotor = LargeMotor(
Ports[TankBase[0]]) # Used only for sensing degrees.
Self.MedMotors = [
MediumMotor(Ports[MedMotors[0]]),
MediumMotor(Ports[MedMotors[1]])
]
Self.Ultrasonic = UltrasonicSensor(Ports[Ultrasonic])
Self.Color1 = ColorSensor(Ports[Color1])
Self.Color2 = ColorSensor(Ports[Color2])
Self.Gyro = GyroSensor(Ports[Gyro])
Self.Buttons = Button()
Self.LCD = Display()
# Lock the medium motors.
Self.MotorOff([0])
Self.MotorOff([1])
