def __init__(self):
cfg = get_config().get_data()
large_sim_type = get_config().is_large_sim_type()
self.address_motor_center = cfg['alloc_settings']['motor']['center'] if large_sim_type else ''
self.address_motor_left = cfg['alloc_settings']['motor']['left']
self.address_motor_right = cfg['alloc_settings']['motor']['right']
self.center_motor_queue = Queue()
self.left_motor_queue = Queue()
self.right_motor_queue = Queue()
self.sound_queue = Queue()
self.left_brick_left_led_color = 1
self.left_brick_right_led_color = 1
self.right_brick_left_led_color = 1
self.right_brick_right_led_color = 1
self.should_reset = False
self.values = {}
self.locks = {}
self.motor_lock = threading.Lock()
def __init__(self):
cfg = get_config().get_data()
self.scaling_multiplier = get_config().get_scale()
self.pixel_coasting_sub = cfg['motor_settings'][
'pixel_coasting_subtraction'] * self.scaling_multiplier
self.degree_coasting_sub = cfg['motor_settings'][
'degree_coasting_subtraction']
self.frames_per_second = cfg['exec_settings']['frames_per_second']
self.wheel_circumference = cfg['wheel_settings']['circumference']
def __init__(self):
port = get_config().get_data()['exec_settings']['socket_port']
self.client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.client.connect(('localhost', port))
time.sleep(1)
def test_coast_frames_required(self):
coasting_sub = get_config().get_data()['motor_settings']['pixel_coasting_subtraction']
creator = MotorCommandProcessor()
frames = creator._coast_frames_required(20, coasting_sub)
self.assertEqual(frames, int(round((20 / coasting_sub))), 5)
frames = creator._coast_frames_required(-20, coasting_sub)
self.assertEqual(frames, int(round((20 / coasting_sub))), 5)
def __init__(self, brick_name: str, robot_state: RobotState):
cfg = get_config().get_data()
large_sim_type = get_config().is_large_sim_type()
self.brick_name = brick_name + ':' if brick_name else ''
self.pixel_coasting_sub = apply_scaling(
cfg['motor_settings']['pixel_coasting_subtraction'])
self.degree_coasting_sub = cfg['motor_settings'][
'degree_coasting_subtraction']
self.frames_per_second = cfg['exec_settings']['frames_per_second']
self.address_us_front = cfg['alloc_settings']['ultrasonic_sensor'][
'front']
self.address_us_rear = cfg['alloc_settings']['ultrasonic_sensor'][
'rear'] if large_sim_type else ''
self.robot_state = robot_state
self.command_processor = MotorCommandProcessor()
self.led_cache = {k: None for k in LEDS.values()}
def __init__(self, address: str):
self.address = address
self.client_socket = get_client_socket()
self.wait_time = 0.008
self.frame_time = 1 / get_config().get_data(
)['exec_settings']['frames_per_second']
self.last_request_time = 0
self.value_cache = None
self.delta_sum = 0
def __init__(self,
address: str,
img_cfg,
robot: Robot,
delta_x: int,
delta_y: int):
super(UltrasonicSensor, self).__init__(address, robot, delta_x, delta_y)
self.init_texture(img_cfg['ultrasonic_sensor_top'], 0.20)
self.sensor_half_height = apply_scaling(22.5)
self.scaling_multiplier = get_config().get_scale()
self.eye_offset = apply_scaling(18)
def test_process_sound_command(self):
robot_state = RobotState()
frames_per_second = get_config().get_data()['exec_settings']['frames_per_second']
frames = int(round((32 / 2.5) * frames_per_second))
message_processor = MessageProcessor('left_brick', robot_state)
message_processor.process_sound_command(SoundCommand('A test is running at the moment!'))
for i in range(frames - 1):
self.assertIsNotNone(robot_state.next_sound_job())
message = robot_state.next_sound_job()
self.assertEqual(message, 'A test is \nrunning at\n the momen\nt!')
self.assertIsNone(robot_state.next_sound_job())
def run(self):
"""
Listen for incoming connections. When a connection is established spawn a ClientSocketHandler
to manage it. Two connections can be established at the same time.
When one connection is closed close the other one as well and start listening
for two new connections.
"""
port = get_config().get_data()['exec_settings']['socket_port']
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server.bind(('localhost', port))
server.listen(5)
while True:
print('Listening for connections...')
(client1, address1) = server.accept()
handler1 = self.create_handler(client1, self.client1_name)
(client2, address2) = server.accept()
handler2 = self.create_handler(client2, self.client2_name)
if not self.first_run:
self.robot_state.should_reset = True
self.first_run = False
time.sleep(1)
while True:
if not handler1.is_running:
handler2.is_running = False
break
elif not handler2.is_running:
handler1.is_running = False
break
else:
time.sleep(1)
time.sleep(1)
print('All connections closed')
def test_process_sound_command(self):
d = {
'type': 'SoundCommand',
'message': 'A test is running at the moment!',
}
frames_per_second = get_config().get_data(
)['exec_settings']['frames_per_second']
frames = int(round((32 / 2.5) * frames_per_second))
robot_state = RobotState()
server = ClientSocketHandler(robot_state, None, 'left_brick')
server._process_sound_command(d)
for i in range(frames):
self.assertIsNotNone(robot_state.next_sound_job())
self.assertIsNone(robot_state.next_sound_job())
def __init__(self, center_x: int, center_y: int, radius: float,
inner_radius: float, color: arcade.Color, border_width: int):
super(Lake, self).__init__(to_color_code(color))
self.large_sim_type = get_config().is_large_sim_type()
self.center_x = center_x
self.center_y = center_y
self.color = color
self.border_width = border_width
self.radius = radius if self.large_sim_type else radius * 1.2
self.inner_radius = inner_radius
self.outer_radius = self.radius + (self.border_width / 2)
self.points = self._create_points()
self.shape = self._create_shape()
self.hole = self._create_hole()
def run(self):
"""
Listen for incoming connections. Start listening for messages when a connection is established.
When the connection breaks up listen for a new connection.
"""
port = get_config().get_data()['exec_settings']['socket_port']
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server.bind(('localhost', port))
server.listen(5)
while True:
print('Listening for connections...')
(client, address) = server.accept()
print('Connection accepted')
if not self.first_run:
self.robot_state.should_reset = True
self.first_run = False
time.sleep(1)
try:
while True:
data = client.recv(128)
if data:
val = self._process(data)
if val:
client.send(val)
else:
break
except socket.error:
pass
print('Closing connection...')
client.close()
def test_create_jobs_coast_center(self):
coasting_sub = get_config().get_data()['motor_settings']['degree_coasting_subtraction']
robot_state = RobotState()
message_processor = MessageProcessor('left_brick', robot_state)
message_processor.process_rotate_command(RotateCommand('ev3-ports:outB', 80, 200, 'coast'))
for i in range(75):
c, l, r = robot_state.next_motor_jobs()
self.assertAlmostEqual(c, -2.667, 3)
self.assertIsNone(l)
self.assertIsNone(r)
ppf = 2.667 - coasting_sub
for i in range(2):
c, l, r = robot_state.next_motor_jobs()
self.assertAlmostEqual(c, -ppf, 3)
self.assertIsNone(l)
self.assertIsNone(r)
ppf = max(ppf - coasting_sub, 0)
self.assertEqual((None, None, None), robot_state.next_motor_jobs())
def test_create_jobs_coast_left(self):
coasting_sub = apply_scaling(get_config().get_data()['motor_settings']['pixel_coasting_subtraction'])
robot_state = RobotState()
message_processor = MessageProcessor('left_brick', robot_state)
message_processor.process_rotate_command(RotateCommand('ev3-ports:outA', 80, 200, 'coast'))
for i in range(75):
c, l, r = robot_state.next_motor_jobs()
self.assertIsNone(c)
self.assertAlmostEqual(l, 0.833, 3)
self.assertIsNone(r)
ppf = 0.833 - coasting_sub
for i in range(2):
c, l, r = robot_state.next_motor_jobs()
self.assertIsNone(c)
self.assertAlmostEqual(l, ppf, 3)
self.assertIsNone(r)
ppf = max(ppf - coasting_sub, 0)
self.assertEqual((None, None, None), robot_state.next_motor_jobs())
def main():
"""
Spawns the user thread and creates and starts the simulation.
"""
parser = argparse.ArgumentParser()
parser.add_argument("-V",
"--version",
action='store_true',
help="Show version info")
parser.add_argument("-s",
"--window_scaling",
default=0.65,
help="Scaling of the screen, default is 0.65",
required=False,
type=validate_scale)
parser.add_argument(
"-t",
"--simulation_type",
choices=['small', 'large'],
default='small',
help="Type of the simulation (small or large). Default is small",
required=False,
type=str)
parser.add_argument(
"-x",
"--robot_position_x",
default=200,
help="Starting position x-coordinate of the robot, default is 200",
required=False,
type=validate_xy)
parser.add_argument(
"-y",
"--robot_position_y",
default=300,
help="Starting position y-coordinate of the robot, default is 300",
required=False,
type=validate_xy)
parser.add_argument("-o",
"--robot_orientation",
default=0,
help="Starting orientation the robot, default is 0",
required=False,
type=int)
parser.add_argument(
"-c",
"--connection_order_first",
choices=['left', 'right'],
default='left',
help=
"Side of the first brick to connect to the simulator, default is 'left'",
required=False,
type=str)
parser.add_argument(
"-2",
"--show-on-second-monitor",
action='store_true',
help=
"Show simulator window on second monitor instead, default is first monitor"
)
parser.add_argument("-f",
"--fullscreen",
action='store_true',
help="Show simulator fullscreen")
parser.add_argument("-m",
"--maximized",
action='store_true',
help="Show simulator maximized")
args = vars(parser.parse_args())
if args['version'] == True:
from ev3dev2 import version as apiversion
from ev3dev2simulator import version as simversion
print("version ev3dev2 : " + apiversion.__version__)
print("version ev3dev2simulator : " + simversion.__version__)
sys.exit(0)
config = get_config()
s = args['window_scaling']
config.write_scale(s)
t = args['simulation_type']
config.write_sim_type(t)
x = apply_scaling(args['robot_position_x'])
y = apply_scaling(args['robot_position_y'])
o = args['robot_orientation']
c = args['connection_order_first']
use_second_screen_to_show_simulator = args['show_on_second_monitor']
show_fullscreen = args['fullscreen']
show_maximized = args['maximized']
robot_state = RobotState()
robot_pos = (x, y, o)
sim = Simulator(robot_state, robot_pos, show_fullscreen, show_maximized,
use_second_screen_to_show_simulator)
#sim.setup()
server_thread = ServerSocketDouble(
robot_state, c) if t == 'large' else ServerSocketSingle(robot_state)
server_thread.setDaemon(True)
server_thread.start()
arcade.run()
def __init__(self, robot_state: RobotState, robot_pos: Tuple[int, int,
int],
show_fullscreen: bool, show_maximized: bool,
use_second_screen_to_show_simulator: bool):
self.check_for_unique_instance()
self.robot_state = robot_state
self.set_screen_to_display_simulator_at_startup(
use_second_screen_to_show_simulator)
self.scaling_multiplier = get_config().get_scale()
self.large_sim_type = get_config().is_large_sim_type()
self.cfg = get_config().get_data()
self.screen_total_width = int(
apply_scaling(self.cfg['screen_settings']['screen_total_width']))
self.screen_width = int(
apply_scaling(self.cfg['screen_settings']['screen_width']))
self.screen_height = int(
apply_scaling(self.cfg['screen_settings']['screen_height']))
from ev3dev2.version import __version__ as apiversion
from ev3dev2simulator.version import __version__ as simversion
screen_title = self.cfg['screen_settings'][
'screen_title'] + " version: " + simversion + " ev3dev2 api: " + apiversion
self.frames_per_second = self.cfg['exec_settings']['frames_per_second']
self.falling_msg = self.cfg['screen_settings']['falling_message']
self.restart_msg = self.cfg['screen_settings']['restart_message']
super(Simulator, self).__init__(self.screen_total_width,
self.screen_height,
screen_title,
update_rate=1 / 30,
resizable=True)
icon1 = pyglet.image.load(r'assets/images/body.png')
self.set_icon(icon1)
arcade.set_background_color(
eval(self.cfg['screen_settings']['background_color']))
self.robot_elements = None
self.obstacle_elements = None
self.robot = None
self.robot_pos = robot_pos
self.red_lake = None
self.green_lake = None
self.blue_lake = None
self.rock1 = None
self.rock2 = None
self.bottle1 = None
self.border = None
self.edge = None
self.ground = None
self.space = None
self.center_cs_data = 0
self.left_cs_data = 0
self.right_cs_data = 0
self.left_ts_data = False
self.right_ts_data = False
self.front_us_data = -1
self.rear_us_data = -1
self.text_x = self.screen_width - apply_scaling(220)
self.msg_x = self.screen_width / 2
self.msg_counter = 0
self.setup()
if show_fullscreen == True:
self.toggleFullScreenOnCurrentScreen()
if show_maximized == True:
self.maximize()
self.check_for_activation()
def remove_scaling(value):
return value / get_config().get_scale()
def apply_scaling(value):
return get_config().get_scale() * value
def __init__(self, comm):
self.port = get_config().get_data()['exec_settings']['bluetooth_port']
self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
