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)