def __init__(self, motor_izquierdo, motor_derecho, radio_rueda,
separacion_ruedas):
self.motor_izquierdo = Motor(motor_izquierdo)
self.motor_derecho = Motor(motor_derecho)
self.dos_motores = MoveTank(motor_izquierdo, motor_derecho)
self.radio = radio_rueda
self.sruedas = separacion_ruedas
def __init__(self, pixel_size):
self._touch = TouchSensor(INPUT_1)
self._color = ColorSensor(INPUT_4)
self._color.mode = 'COL-COLOR'
self._fb_motor = LargeMotor(OUTPUT_C)
self._lr_motor = LargeMotor(OUTPUT_B)
self._ud_motor = Motor(OUTPUT_A)
self._x_res = utilities.MAX_X_RES / int(pixel_size)
self._y_res = utilities.MAX_Y_RES / int(pixel_size)
self._padding_left = utilities.MAX_PADDING_LEFT / int(pixel_size)
self._padding_right = utilities.MAX_PADDING_RIGHT / int(pixel_size)
self._is_pen_up = True
self._pen_calibrated = False
self._ud_ratio = 5
self._fb_ratio = 4
self._lr_ratio = 1
self._pen_up_val = -3 * self._ud_ratio
self._pen_down_val = -self._pen_up_val
self._pen_up_down_speed = 10
self._pen_left_speed = 20
self._pen_right_speed = 20
self._paper_scroll_speed = 20
self._pixel_size = pixel_size
self._p_codes = []
self._current_line = 0
def reset():
fb_motor = LargeMotor(OUTPUT_C)
lr_motor = LargeMotor(OUTPUT_B)
ud_motor = Motor(OUTPUT_A)
fb_motor.stop()
lr_motor.stop()
ud_motor.stop()
def __init__(self, motor_izquierdo, motor_derecho, diametro_rueda,
separacion_ruedas):
self._motor_izquierdo = Motor(motor_izquierdo)
self._motor_derecho = Motor(motor_derecho)
self._dos_motores = MoveTank(motor_izquierdo, motor_derecho)
self._radio = diametro_rueda / 2
self._sruedas = separacion_ruedas
def stopAll(self):
self.tank.off()
try:
for out in self.outputList:
m = Motor(out)
m.stop()
except:
pass
def start():
print('Start minimal example')
motor = Motor(OUTPUT_A)
motor.on_for_seconds(SpeedPercent(50), 2)
sound = Sound()
sound.play_file('/home/robot/programs/minimal_example/R2D2a.wav')
class Thrower(object):
def __init__(self, output):
self.motor = Motor(output)
def throw(self):
self.motor.on_to_position(SpeedPercent(100), 50)
def reset(self):
self.motor.on_to_position(SpeedPercent(20), 0, block=False)
def __init__(self):
"""
Performs Alexa Gadget initialization routines and ev3dev resource allocation.
"""
super().__init__()
# Ev3dev initialization
self.leds = Leds()
self.sound = Sound()
self.motor = Motor(OUTPUT_A)
def on_message(self, messages):
global move_joystick
try:
print("got messages", messages)
for message in json.loads(messages):
type_ = message["type"]
if type_ == "rc-joystick":
if message["leftPort"] != old_joystick_left_port or message[
"rightPort"] != old_joystick_right_port:
move_joystick = MoveJoystick(message["leftPort"],
message["rightPort"])
if message["x"] == 0 and message["y"] == 0:
move_joystick.off(brake=False)
else:
move_joystick.on(message["x"], message["y"], 1)
elif type_ == "rc-motor":
if message["port"] in motors:
motor = motors[message["port"]]
else:
motor = motors[message["port"]] = Motor(
message["port"])
motor.on(message["speed"] * 100)
elif type_ == "sensor":
port = message["port"]
attributes = message["attributes"]
device = Sensor(port)
for name, value in attributes.items():
setattr(device, name, value)
# send changes to other clients
EV3InfoHandler.send_to_all(json.dumps({port: attributes}),
{self})
elif type_ == "motor":
port = message["port"]
attributes = message["attributes"]
device = Motor(port)
for name, value in attributes.items():
setattr(device, name, value)
# send changes to other clients
EV3InfoHandler.send_to_all(json.dumps({port: attributes}),
{self})
elif type_ == "led":
port = message["port"]
attributes = message["attributes"]
led_group = port.split(":")[1].lower()
for color_name, brightness in attributes.items():
LEDS.leds[color_name + "_" +
led_group].brightness_pct = float(brightness)
# send changes to other clients
EV3InfoHandler.send_to_all(json.dumps({port: attributes}),
{self})
else:
raise ValueError("Unknown message type '" + type_ + "'")
except Exception:
traceback.print_exc()
self.send_to_all("next")
def test_run_timed(self):
self.clientSocketMock.send_command.return_value = 1
motor = Motor(OUTPUT_A)
motor.on_for_seconds(30, 1)
self.assertEqual(len(self.clientSocketMock.mock_calls), 1)
fn_name, args, kwargs = self.clientSocketMock.mock_calls[0]
self.assertEqual(fn_name, 'send_command')
self.assertDictEqual(args[0].serialize(),
{'type': 'RotateCommand', 'address': 'ev3-ports:outA', 'stop_action': 'hold',
'speed': 315, 'distance': 315.0})
def stop_all():
if local:
print('Stop all')
else:
outputs = [OUTPUT_A, OUTPUT_B, OUTPUT_C, OUTPUT_D]
for output in outputs:
try:
motor = Motor(output)
motor.reset()
except DeviceNotDefined:
pass
def __turn(self, stop_motor: Motor, turn_motor: Motor, degrees: int,
speed: int):
stop_motor.stop()
start = turn_motor.degrees
turn_motor.on(speed)
while (abs(turn_motor.degrees - start) < degrees):
if (not self.__check_button()):
self.lm_left.stop()
self.lm_right.stop()
return False
return True
def testRotationSensor():
a = Motor(OUTPUT_A)
d = Motor(OUTPUT_D)
b = Motor(OUTPUT_B)
for x in range(10):
debug_print("A:" + str(a.position))
debug_print("D:" + str(d.position))
debug_print("B:" + str(b.position))
#td.on_for_rotations(global_power,global_power,1)
time.sleep(1)
def __init__(self, port_motor_move, port_motor_turn):
# Motor for moving turntable forwards and backwards
self.motor_move = Motor(port_motor_move)
self.motor_move.speed_sp = 400
self.motor_move.stop_action = 'brake'
self.motor_move_positions = (0, -740, -890, -1030, -1175, -1380)
# Motor for rotating turntable
self.motor_turn = Motor(port_motor_turn)
self.motor_turn.speed_sp = 400
self.motor_turn.stop_action = 'brake'
self.motor_turn_positions = (0, -345, 345)
def __init__(self, turner, up_motor='B', hand_motor='A'):
self.angle = turner.angle
self.up = Motor(up_motor)
self.hand = Motor(hand_motor)
self.degrees = 21
self.up_bounds = -100
self.pwm_base = 0.1
self.color_org = 0
self.color_tgt = 0
self.up_org = 0
self.up_tgt = 0
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 MotorReset(self, port):
self._logger.info(port)
ports = {
'a': OUTPUT_A,
'b': OUTPUT_B,
'c': OUTPUT_C,
'd': OUTPUT_D
}
try:
motor = Motor(ports[port])
motor.reset()
except DeviceNotFound as err:
self._logger.warn(err.message)
pass
def initmotors():
lw = Motor(OUTPUT_C)
rw = Motor(OUTPUT_B)
# for x in (lw,rw):
# x.polarity = 'inversed'
# x.ramp_up_sp = 2000
# x.ramp_down_sp = 2000
# lw.polarity = 'inversed'
# rw.polarity = 'inversed'
lw.ramp_up_sp = 2000
rw.ramp_up_sp = 2000
lw.ramp_down_sp = 1000
rw.ramp_down_sp = 1000
global mdiff
global mtank
mdiff = MoveDifferential(OUTPUT_C, OUTPUT_B, MCTire, 129.3)
mtank = MoveTank(OUTPUT_C, OUTPUT_B)
mtank.gyro = GyroSensor()
mdiff.set_polarity('inversed')
def test_units(self):
clean_arena()
populate_arena([('large_motor', 0, 'outA'),
('large_motor', 1, 'outB')])
m = Motor()
self.assertEqual(
SpeedPercent(35).to_native_units(m), 35 / 100 * m.max_speed)
self.assertEqual(SpeedDPS(300).to_native_units(m), 300)
self.assertEqual(SpeedNativeUnits(300).to_native_units(m), 300)
self.assertEqual(SpeedDPM(30000).to_native_units(m), (30000 / 60))
self.assertEqual(SpeedRPS(2).to_native_units(m), 360 * 2)
self.assertEqual(SpeedRPM(100).to_native_units(m), (360 * 100 / 60))
self.assertEqual(DistanceMillimeters(42).mm, 42)
self.assertEqual(DistanceCentimeters(42).mm, 420)
self.assertEqual(DistanceDecimeters(42).mm, 4200)
self.assertEqual(DistanceMeters(42).mm, 42000)
self.assertAlmostEqual(DistanceInches(42).mm, 1066.8)
self.assertAlmostEqual(DistanceFeet(42).mm, 12801.6)
self.assertAlmostEqual(DistanceYards(42).mm, 38404.8)
self.assertEqual(DistanceStuds(42).mm, 336)
def attachNew(self,
isMotor=True,
port="outA",
largeMotor=False): # Attach new motor
if isMotor:
self.m3 = Motor(port)
else:
self.m3 = LargeMotor(port)
class Turner(object):
def __init__(self, arm_motor='C', angle_motor='D'):
self.arm = Motor(arm_motor)
self.angle = Motor(angle_motor)
def start(self, turns=True):
if power_save:
print("brrr")
else:
print("it's time")
self.arm.on(30)
sleep(5)
self.arm.on(15)
if turns:
for _ in range(10):
self.angle.on_for_seconds(-50, 0.2)
self.angle.on_for_seconds(50, 0.2)
self.angle.on(10)
def test_units(self):
clean_arena()
populate_arena([('large_motor', 0, 'outA'), ('large_motor', 1, 'outB')])
m = Motor()
self.assertEqual(SpeedPercent(35).get_speed_pct(m), 35)
self.assertEqual(SpeedDPS(300).get_speed_pct(m), 300 / 1050 * 100)
self.assertEqual(SpeedNativeUnits(300).get_speed_pct(m), 300 / 1050 * 100)
self.assertEqual(SpeedDPM(30000).get_speed_pct(m), (30000 / 60) / 1050 * 100)
self.assertEqual(SpeedRPS(2).get_speed_pct(m), 360 * 2 / 1050 * 100)
self.assertEqual(SpeedRPM(100).get_speed_pct(m), (360 * 100 / 60) / 1050 * 100)
def test_stop_with_no_speed(self):
motor = Motor(OUTPUT_A)
self.clientSocketMock.send_command.return_value = 0
motor.on(0, False)
motor.stop()
self.assertEqual(len(self.clientSocketMock.mock_calls), 1)
self.assertEqual(motor.speed_sp, 0)
def test_units(self):
clean_arena()
populate_arena([('large_motor', 0, 'outA'),
('large_motor', 1, 'outB')])
m = Motor()
self.assertEqual(
SpeedPercent(35).to_native_units(m), 35 / 100 * m.max_speed)
self.assertEqual(SpeedDPS(300).to_native_units(m), 300)
self.assertEqual(SpeedNativeUnits(300).to_native_units(m), 300)
self.assertEqual(SpeedDPM(30000).to_native_units(m), (30000 / 60))
self.assertEqual(SpeedRPS(2).to_native_units(m), 360 * 2)
self.assertEqual(SpeedRPM(100).to_native_units(m), (360 * 100 / 60))
def MotorCommands(self, port):
self._logger.info(port)
ports = {
'a': OUTPUT_A,
'b': OUTPUT_B,
'c': OUTPUT_C,
'd': OUTPUT_D
}
try:
motor = Motor(ports[port])
commands = motor.commands
self._logger.info(commands)
return commands
except DeviceNotFound:
return list()
def __init__(self, motorL=None, motorR=None, motorM=None, gyroPort=None, colorL=None, colorR=None, colorM=None):
if motorL: self.motorL = LargeMotor(motorL)
if motorR: self.motorR = LargeMotor(motorR)
if motorM: self.motorM = Motor(motorM)
if gyroPort:
self.gyro = GyroSensor(gyroPort)
self.gyro.mode = 'GYRO-CAL'
time.sleep(0.2)
self.gyro.mode = 'GYRO-ANG'
if colorL: self.colorL = ColorSensor(colorL)
if colorR: self.colorR = ColorSensor(colorR)
if colorM: self.colorM = ColorSensor(colorM)
if motorL and motorR:
self.drive = MoveSteering(motorL, motorR)
self.move = MoveTank(motorL, motorR)
print("Successful initialization!")
def test_stop_reverse(self):
motor = Motor(OUTPUT_A)
self.clientSocketMock.send_command.return_value = 0
motor.on(-10, False)
motor.stop()
self.assertEqual(len(self.clientSocketMock.mock_calls), 2)
fn_name, args, kwargs = self.clientSocketMock.mock_calls[1]
self.assertEqual(fn_name, 'send_command')
self.assertDictEqual(args[0].serialize(),
{'type': 'StopCommand', 'address': 'ev3-ports:outA', 'stop_action': 'coast',
'speed': 105})
def test_run_direct(self):
self.clientSocketMock.send_command.return_value = 1
motor = Motor(OUTPUT_A)
motor.duty_cycle_sp = 30
motor.stop_action = 'coast'
motor.run_direct()
self.assertEqual(len(self.clientSocketMock.mock_calls), 1)
fn_name, args, kwargs = self.clientSocketMock.mock_calls[0]
self.assertEqual(fn_name, 'send_command')
self.assertDictEqual(args[0].serialize(),
{'type': 'RotateCommand', 'address': 'ev3-ports:outA', 'stop_action': 'coast',
'speed': 315, 'distance': 14175.0})
def test_direct_on_and_stop(self):
self.clientSocketMock.send_command.return_value = 1
motor = Motor(OUTPUT_A)
motor.on(10)
self.assertEqual(len(self.clientSocketMock.mock_calls), 1)
fn_name, args, kwargs = self.clientSocketMock.mock_calls[0]
self.assertEqual(fn_name, 'send_command')
distance = 105 * 45
self.assertDictEqual(args[0].serialize(),
{'type': 'RotateCommand', 'address': 'ev3-ports:outA', 'stop_action': 'hold',
'speed': 105, 'distance': distance})
motor.stop()
self.assertEqual(len(self.clientSocketMock.mock_calls), 2)
fn_name, args, kwargs = self.clientSocketMock.mock_calls[1]
self.assertEqual(fn_name, 'send_command')
self.assertDictEqual(args[0].serialize(),
{'type': 'StopCommand', 'address': 'ev3-ports:outA', 'stop_action': 'hold',
'speed': 105})
class Turntable:
def __init__(self, port_motor_move, port_motor_turn):
# Motor for moving turntable forwards and backwards
self.motor_move = Motor(port_motor_move)
self.motor_move.speed_sp = 400
self.motor_move.stop_action = 'brake'
self.motor_move_positions = (0, -740, -890, -1030, -1175, -1380)
# Motor for rotating turntable
self.motor_turn = Motor(port_motor_turn)
self.motor_turn.speed_sp = 400
self.motor_turn.stop_action = 'brake'
self.motor_turn_positions = (0, -345, 345)
@try_except
def move_to_abs_pos(self, pos):
''' Move the turntable to given absolute position [0,..,5].'''
self.motor_move.run_to_abs_pos(
position_sp=self.motor_move_positions[pos])
@try_except
def move_to_rel_pos(self, rel_pos):
''' Move the turntable over a given distance.'''
self.motor_move.run_to_rel_pos(position_sp=rel_pos) # rel_pos=150
wait_while_motors_running(self.motor_move)
@try_except
def turn_to_abs_pos(self, pos):
''' Turn the turntable to a given absolute position [0,..,2].'''
self.motor_turn.run_to_abs_pos(
position_sp=self.motor_turn_positions[pos])
@try_except
def goto_start_pos(self):
''' Move and turn the turntable to its start position.'''
self.move_to_abs_pos(0)
self.turn_to_abs_pos(0)
