def __init__(self, config: dict, robot): self.side = config['side'] if self.side in ['left', 'right']: dims = get_simulation_settings()['body_part_sizes']['touch_sensor_bar'] else: dims = get_simulation_settings()['body_part_sizes']['touch_sensor_bar_rear'] super(TouchSensor, self).__init__(config, robot, Dimensions(dims['width'], dims['height']), 'touch_sensor', driver_name='lego-ev3-touch')
def __init__(self, update_world_cb, world_state: WorldState, show_fullscreen: bool, show_maximized: bool, use_second_screen_to_show_simulator: bool): instance_checker = InstanceChecker(self) instance_checker.check_for_unique_instance() self.update_callback = update_world_cb self.world_state = world_state self.current_screen_index = None self.set_screen_to_display_simulator_at_startup( use_second_screen_to_show_simulator) self.size = Dimensions( get_simulation_settings()['screen_settings']['screen_width'], get_simulation_settings()['screen_settings']['screen_height']) self.msg_counter = 0 screen_title = get_simulation_settings( )['screen_settings']['screen_title'] screen_info = screen_title + f' version: {sim_version} ev3dev2 api: {api_version}' scale = self.determine_scale(self.size.width, self.size.height) if DEBUG: print('starting simulation with scaling', scale) print('arcade version: ', _arcade.version.VERSION) super(Visualiser, self).__init__( self.size.width, self.size.height, screen_info, update_rate=1 / 30, fullscreen=show_fullscreen, resizable=True, screen=_arcade.get_screens()[self.current_screen_index]) icon1 = pyglet.image.load(r'assets/images/body.png') self.set_icon(icon1) _arcade.set_background_color( get_simulation_settings()['screen_settings']['background_color']) self.sidebar = self._setup_sidebar() self.world_state.setup_pymunk_shapes(scale) self.world_state.setup_visuals(scale) if show_maximized: self.maximize() instance_checker.check_for_activation()
def test_create_jobs_coast_center(self): coasting_sub = get_simulation_settings( )['motor_settings']['degree_coasting_subtraction'] robot_sim = create_robot_sim() message_processor = MessageProcessor(0, robot_sim) message_processor.process_rotate_command( RotateCommand('ev3-ports:outB', 80, 200, 'coast')) for i in range(75): jobs = robot_sim.next_actuator_jobs() self.assertAlmostEqual(jobs[3][1], -2.667, 3) self.assertIsNone(jobs[0][1]) self.assertIsNone(jobs[1][1]) self.assertIsNone(jobs[2][1]) ppf = 2.667 - coasting_sub for i in range(2): jobs = robot_sim.next_actuator_jobs() self.assertAlmostEqual(jobs[3][1], -ppf, 3) self.assertIsNone(jobs[0][1]) self.assertIsNone(jobs[1][1]) self.assertIsNone(jobs[2][1]) ppf = max(ppf - coasting_sub, 0) jobs = robot_sim.next_actuator_jobs() self.assertEqual((jobs[0][1], jobs[1][1], jobs[2][1], jobs[3][1]), (None, None, None, None))
def test_process_sound_command(self): robot_sim = create_robot_sim() frames_per_second = get_simulation_settings( )['exec_settings']['frames_per_second'] frames = int(5 * frames_per_second) message_processor = MessageProcessor(0, robot_sim) message_processor.process_sound_command( SoundCommand('A test is running at the moment!', 5, 'speak')) for i in range(frames - 1): soundJob = [ i[1] for i in robot_sim.next_actuator_jobs() if i[0] == (0, 'speaker') ][0] self.assertIsNotNone(soundJob) message = [ i[1] for i in robot_sim.next_actuator_jobs() if i[0] == (0, 'speaker') ][0] self.assertEqual(message, 'A test is \nrunning at\n the momen\nt!') jobs = robot_sim.next_actuator_jobs() self.assertEqual((jobs[0][1], jobs[1][1], jobs[2][1], jobs[3][1]), (None, None, None, None))
def test_create_jobs_coast_left(self): coasting_sub = get_simulation_settings( )['motor_settings']['distance_coasting_subtraction'] robot_sim = create_robot_sim() message_processor = MessageProcessor(0, robot_sim) message_processor.process_rotate_command( RotateCommand('ev3-ports:outA', 80, 200, 'coast')) frames_check = (200 / 80) * 30 # (1000/100) * 30 # distance * fps distance_in_mm = 200 / 360 * wheel_circumference dpf = distance_in_mm / frames_check for i in range(75): jobs = robot_sim.next_actuator_jobs() self.assertAlmostEqual(jobs[1][1], dpf, 3) self.assertIsNone(jobs[0][1]) self.assertIsNone(jobs[2][1]) self.assertIsNone(jobs[3][1]) ppf = dpf - coasting_sub for i in range(2): jobs = robot_sim.next_actuator_jobs() self.assertAlmostEqual(jobs[1][1], ppf, 3) self.assertIsNone(jobs[0][1]) self.assertIsNone(jobs[3][1]) self.assertIsNone(jobs[2][1]) ppf = max(ppf - coasting_sub, 0) jobs = robot_sim.next_actuator_jobs() self.assertEqual((jobs[0][1], jobs[1][1], jobs[2][1], jobs[3][1]), (None, None, None, None))
def test_serialize_deserialize(self): server_thread = threading.Thread(target=self.run_fake_server) server_thread.start() msg_length = get_simulation_settings()['exec_settings']['message_size'] from ev3dev2simulator.connection.ClientSocket import get_client_socket sock = get_client_socket() command = RotateCommand('test_port', 500.0, 100.0, 'hold') sock.send_command(command) ser = sock._serialize(command) unpadded = ( b'{"type": "RotateCommand", "address": "test_port", "speed": 500.0, "distance": 100.0, ' b'"stop_action": "hold"}') expected = unpadded.ljust(msg_length, b'#') self.assertEqual(ser, expected) ser = b'{"value": 15}' deser = sock._deserialize(ser) self.assertEqual(deser, 15) sock.client.send(str.encode('close_test_server')) sock.client.close() server_thread.join()
def run(self): """ Listen for incoming connections. When a connection is established spawn a ClientSocketHandler to manage it. Multiple connections can be established at the same time. """ port = get_simulation_settings()['exec_settings']['socket_port'] for robot_sim in self.word_simulator.robot_simulators: for brick in robot_sim.robot.get_bricks(): sock = ClientSocketHandler(robot_sim, brick.brick, brick.name) sock.setDaemon(True) sock.start() self.brick_sockets[(robot_sim.robot.name, brick.name)] = sock 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) server.setblocking(False) server.settimeout(1) print('Listening for connections...') self.handle_sockets(server) print('Closing server')
def __init__(self, comm): get_client_socket( ) # this is not used for Bluetooth, but to force a connection to the simulator (startup # sequence) self.port = int( get_simulation_settings()['exec_settings']['bluetooth_port']) self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
def setup_visuals(self, scale): img_cfg = get_simulation_settings()['image_paths'] src_list = [ img_cfg[f'led_{color}'] for color in ['amber', 'black', 'red', 'green', 'orange', 'yellow'] ] self.init_sprite_with_list(src_list, scale, 1)
def __init__(self, config, robot): dims = get_simulation_settings()['body_part_sizes']['wheel'] super().__init__(config, robot, Dimensions(dims['width'], dims['height']), 'motor', driver_name='lego-ev3-l-motor')
def test_process_sound_command(self): d = { 'type': 'SoundCommand', 'message': 'A tests is running at the moment!', 'duration': 2, 'soundType': 'speak' } frames_per_second = get_simulation_settings( )['exec_settings']['frames_per_second'] frames = int(2 * frames_per_second) server = create_client_socket_handler() server.message_handler._process_sound_command(d) for i in range(frames): sound_job = [ i[1] for i in server.robot_sim.next_actuator_jobs() if i[0] == (0, 'speaker') ][0] self.assertIsNotNone(sound_job) sound_job = [ i[1] for i in server.robot_sim.next_actuator_jobs() if i[0] == (0, 'speaker') ][0] self.assertIsNone(sound_job)
def __init__(self): load_config(None) port = get_simulation_settings()['exec_settings']['socket_port'] self.client = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.client.connect(('localhost', port)) time.sleep(1)
def __init__(self, config, robot): dims = get_simulation_settings()['body_part_sizes']['arm'] super(Arm, self).__init__(config, robot, Dimensions(dims['width'], dims['height']), 'arm', driver_name='lego-ev3-m-motor') self.side_bar_arm = ArmLarge()
def setup_visuals(self, scale): if self.side == 'left': img = 'touch_sensor_left' elif self.side == 'right': img = 'touch_sensor_right' else: img = 'touch_sensor_rear' vis_conf = get_simulation_settings() self.init_sprite(vis_conf['image_paths'][img], scale)
def setup_visuals(self, x, y, width, height): self.center_x = x self.center_y = y self.rotate_x = x self.rotate_y = y + self.sweep_length vis_conf = get_simulation_settings() self.init_texture(vis_conf['image_paths']['arm_large'], width, height) self.side_bar_ground.create_shape(x, y - 70, width, 10) self.rotate(20)
def __init__(self, config, robot): dims = get_simulation_settings( )['body_part_sizes']['ultrasonic_sensor_bottom'] super(UltrasonicSensorBottom, self).__init__(config, robot, dims['width'], dims['height'], 'ultrasonic_sensor', driver_name='lego-ev3-us')
def test_coast_frames_required(self): coasting_sub = get_simulation_settings()['motor_settings']['distance_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, config, robot): dims = get_simulation_settings( )['body_part_sizes']['ultrasonic_sensor_top'] super(UltrasonicSensor, self).__init__(config, robot, Dimensions(dims['width'], dims['height']), 'ultrasonic_sensor', driver_name='lego-ev3-us') self.sensor_half_height = 22.5
def on_draw(self): """ Render the simulation. """ _arcade.start_render() for obstacle_list in self.world_state.static_obstacles: for shape in obstacle_list.get_shapes(): if shape.line_width == 1: shape.draw() else: print(shape) self.world_state.sprite_list.draw() for robot in self.world_state.get_robots(): robot.get_sprites().draw() if DEBUG: for sprite in robot.get_sprites(): sprite.draw_hit_box(color=RED, line_thickness=5) if robot.debug_shapes is not None: for shape in robot.debug_shapes: shape.draw() robot.debug_shapes.clear() if robot.is_falling() and self.msg_counter <= 0: self.msg_counter = get_simulation_settings( )['exec_settings']['frames_per_second'] * 3 for robot in self.world_state.get_robots(): self.sidebar.add_robot_info(robot.name, robot.values, robot.sounds) self.sidebar.draw() if self.msg_counter > 0: self.msg_counter -= 1 _arcade.draw_text(get_simulation_settings()['screen_settings'] ['falling_message'], self._msg_x, self.size.height - 100, _arcade.color.RADICAL_RED, 14, anchor_x="center")
def __init__(self, robot_sim: RobotSimulator, brick_id: int, brick_name: str): threading.Thread.__init__(self) self.message_handler = MessageHandler(MessageProcessor(brick_id, robot_sim)) self.client = None self.brick_id = brick_id self.is_running = True self.is_connected = False self.brick_name = brick_name self.robot_sim = robot_sim self.message_size = get_simulation_settings()['exec_settings']['message_size']
def __init__(self): cfg = get_simulation_settings() self.distance_coasting_sub = float( cfg['motor_settings']['distance_coasting_subtraction']) self.degree_coasting_sub = float( cfg['motor_settings']['degree_coasting_subtraction']) self.frames_per_second = int(cfg['exec_settings']['frames_per_second']) self.wheel_circumference = float( cfg['wheel_settings']['circumference'])
def __init__(self, brick: int, robot, center_x: int, center_y: int): config = { 'brick': brick, 'x_offset': center_x, 'y_offset': center_y, 'port': 'speaker' } dims = get_simulation_settings()['body_part_sizes']['speaker'] super(Speaker, self).__init__(config, robot, dims['width'], dims['height'], 'speaker')
def _setup_sidebar(self): sidebar_width = get_simulation_settings( )['screen_settings']['side_bar_width'] sidebar = Sidebar( Point(self.size.width - sidebar_width, self.size.height - 70), Dimensions(sidebar_width, self.size.height)) for robot in self.world_state.get_robots(): sidebar.init_robot(robot.name, robot.sensors, robot.bricks, robot.side_bar_sprites) return sidebar
def __init__(self): load_config(None) port = int(get_simulation_settings()['exec_settings']['socket_port']) self.client = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.client.settimeout(0.1) self.client.connect(('localhost', port)) self.lock = threading.Lock() time.sleep(1)
def __init__(self, world_state: WorldState): self.world_state = world_state self.robot_simulators = [] self.should_reset = False for robot in world_state.robots: robot_sim = RobotSimulator(robot) self.robot_simulators.append(robot_sim) self.world_state.space.add_default_collision_handler() self.space_step_size = float( get_simulation_settings()['exec_settings']['frames_per_second'])
def setup_visuals(self, x, y, width, height): """ Setup the visuals of the robot arm and add a bottom border to it. """ self.center_x = x self.center_y = y self.rotate_x = x self.rotate_y = y + self.sweep_length vis_conf = get_simulation_settings() self.init_texture(vis_conf['image_paths']['arm_large'], width, height) self.side_bar_ground.create_shape(x, y - 70, width, 10) self.angle = 0 self.rotate(20)
def _serialize(message: Any) -> bytes: """ Serialize the given message so it can be send via a stream channel. :param message: to be serialized. :return: bytes representing the message. """ obj_dict = message.serialize() jsn = json.dumps(obj_dict) jsn = jsn.ljust( get_simulation_settings()['exec_settings']['message_size'], '#') return str.encode(jsn)
def __init__(self, brick: int, robot, side, brick_x_offset, brick_y_offset): offset_x = -20 if side == 'left' else 20 config = { 'brick': brick, 'name': f'led_{side}', 'x_offset': brick_x_offset, 'y_offset': brick_y_offset, } dims = get_simulation_settings()['body_part_sizes']['led'] super().__init__(config, robot, dims['width'], dims['height'], 'led', offset_x, -32.5) self.old_texture_index = 1
def __init__(self, brick_id: int, robot_sim: robot_simulator): cfg = get_simulation_settings() self.brick_id = brick_id self.distance_coasting_sub = float( cfg['motor_settings']['distance_coasting_subtraction']) self.degree_coasting_sub = float( cfg['motor_settings']['degree_coasting_subtraction']) self.frames_per_second = int(cfg['exec_settings']['frames_per_second']) self.robot_sim = robot_sim self.command_processor = MotorCommandProcessor() self.led_cache = {k: None for k in LEDS.values()}
def __init__(self, address: str): self.address = address if address is None: raise RuntimeError('created connector with None as address') self.client_socket = get_client_socket() self.wait_time = 0.008 self.frame_time = 1 / int( get_simulation_settings()['exec_settings']['frames_per_second']) self.last_request_time = 0 self.value_cache = None self.delta_sum = 0