def main(argv): arguments = Arguments("settings.json", argv) settings = arguments.get_settings("environment_viewer_interactive") environment = Environment.setup(arguments) viewer = Viewer_Interactive(environment, settings) arguments.check_help() viewer.start()
def main(argv): import_manager = Import_Manager() thread_manager = Thread_Manager() usb_manager = USB_Manager() usb_manager.index() arguments = Arguments("settings.json", argv, positionals=[{ "name": "rf_sensor_class", "help": "Sensor class to use for the RF sensor", "type": "class", "module": "zigbee.RF_Sensor", "required": True }]) rf_sensor_class = arguments.get_positional_value("rf_sensor_class") rf_sensor_type = import_manager.load_class(rf_sensor_class, relative_module="zigbee") rf_sensor = rf_sensor_type(arguments, thread_manager, get_location, receive_packet, location_valid, usb_manager=usb_manager) arguments.check_help() try: rf_sensor.activate() print("RF sensor has joined the network.") while True: if rf_sensor.id == 0: # The ground station does not need to start in order to receive # measurements, so do not bother giving this possibility. time.sleep(1) else: # Wait for the user to determine when to perform measurements # and when to stop. Add a newline so that the messages do not # mess up other output. raw_input("Press Enter to start measurements...\n") rf_sensor.start() raw_input("Press Enter to stop measurements...\n") rf_sensor.stop() except: traceback.print_exc() thread_manager.destroy() usb_manager.clear()
def main(argv): # Initialize, read parameters from input and set up problems stamp = int(time.time()) thread_manager = Thread_Manager() import_manager = Import_Manager() arguments = Arguments("settings.json", argv) runner = Planning_Runner(arguments, thread_manager, import_manager, iteration_callback) arguments.check_help() t_max = runner.get_iteration_limit() size = runner.get_population_size() print("Settings: Algorithm {}, mu={}, t_max={}".format( runner.algorithm.get_name(), size, t_max)) print("Steps: {}".format(runner.algorithm.steps)) indices = runner.start() # Show feasible solutions in a sorted manner. if len(indices) == 0: print("No feasible solutions found after {} iterations!".format(t_max)) return print("Search variables an objective values for feasible solutions:") # If we have fewer nondominated solutions than the total number of # individuals, then only show the nondominated ones. Otherwise, just show # all feasible solutions. c = 0 for i in indices: c += 1 positions, unsnappable = runner.get_positions_plot(i, c, len(indices)) if positions.size == 0: continue print("{}. {} ({})".format(i, runner.get_objectives(i), unsnappable)) do_data("positions-{}-{}".format(stamp, c), positions.tolist()) do_plot("display-{}-{}.eps".format(stamp, c)) # Plot the pareto front between the two objectives. print("Pareto front after t={}".format(t_max)) runner.make_pareto_plot() do_plot("front-{}.eps".format(stamp))
def main(argv): # Initialize, read parameters from input and set up problems stamp = int(time.time()) thread_manager = Thread_Manager() import_manager = Import_Manager() arguments = Arguments("settings.json", argv) runner = Planning_Runner(arguments, thread_manager, import_manager, iteration_callback) arguments.check_help() t_max = runner.get_iteration_limit() size = runner.get_population_size() print("Settings: Algorithm {}, mu={}, t_max={}".format(runner.algorithm.get_name(), size, t_max)) print("Steps: {}".format(runner.algorithm.steps)) indices = runner.start() # Show feasible solutions in a sorted manner. if len(indices) == 0: print("No feasible solutions found after {} iterations!".format(t_max)) return print("Search variables an objective values for feasible solutions:") # If we have fewer nondominated solutions than the total number of # individuals, then only show the nondominated ones. Otherwise, just show # all feasible solutions. c = 0 for i in indices: c += 1 positions, unsnappable = runner.get_positions_plot(i, c, len(indices)) if positions.size == 0: continue print("{}. {} ({})".format(i, runner.get_objectives(i), unsnappable)) do_data("positions-{}-{}".format(stamp, c), positions.tolist()) do_plot("display-{}-{}.eps".format(stamp, c)) # Plot the pareto front between the two objectives. print("Pareto front after t={}".format(t_max)) runner.make_pareto_plot() do_plot("front-{}.eps".format(stamp))
def main(argv): arguments = Arguments("settings.json", argv) setup = Setup(arguments) try: setup.setup() except Exception: traceback.print_exc() finally: setup.disable()
def __init__(self, parent, name): self.parent = parent self.name = name self.doc = Documentation('[Documentation]', self) self.args = Arguments('[Arguments]', self) self.return_ = Return('[Return]', self) self.timeout = Timeout('[Timeout]', self) self.teardown = Fixture('[Teardown]', self) self.steps = []
def __init__(self, parent, name): self.parent = parent self.name = name self.doc = Documentation('[Documentation]', self) self.args = Arguments('[Arguments]', self) self.return_ = Return('[Return]', self) self.timeout = Timeout('[Timeout]', self) self.steps = [] self._setters = self._get_setters()
def main(argv): arguments = Arguments("settings.json", argv) settings = arguments.get_settings("xbee_configurator") arguments.check_help() usb_manager = USB_Manager() for sensor_id in range(0, settings.get("number_of_sensors") + 1): if sensor_id == 0: raw_input("Connect the ground station XBee sensor and press Enter...") else: raw_input("Connect XBee sensor {} and press Enter...".format(sensor_id)) usb_manager.index() parameters = { "ID": settings.get("pan_id"), "NI": str(sensor_id), "PM": 0, "PL": 0 } xbee_configurator = XBee_Configurator(arguments, usb_manager) # Show the current parameters. for key in parameters.iterkeys(): value = xbee_configurator.get(key) if value != None: print("{}[Sensor {}] {} is {}.{}".format(COLORS["green"], sensor_id, key, value, COLORS["end"])) else: print("{}[Sensor {}] {} is unknown.{}".format(COLORS["red"], sensor_id, key, COLORS["end"])) # Set the new parameters. for key, value in parameters.iteritems(): if xbee_configurator.set(key, value): print("{}[Sensor {}] {} set to {}.{}".format(COLORS["green"], sensor_id, key, value, COLORS["end"])) else: print("{}[Sensor {}] {} not set to {}.{}".format(COLORS["red"], sensor_id, key, value, COLORS["end"])) # Write the changes to the sensor. if xbee_configurator.write(): print("{}[Sensor {}] Changes written to sensor.{}".format(COLORS["green"], sensor_id, COLORS["end"])) else: print("{}[Sensor {}] Changes not written to sensor.{}".format(COLORS["red"], sensor_id, COLORS["end"])) usb_manager.clear()
def main(argv): thread_manager = Thread_Manager() arguments = Arguments("settings.json", argv) try: infrared_sensor = Infrared_Sensor(arguments, thread_manager) except OSError as e: arguments.error("Could not configure infrared sensor: {}".format(e)) arguments.check_help() try: infrared_sensor.register("start", start_callback) infrared_sensor.register("stop", stop_callback) infrared_sensor.activate() while True: time.sleep(1) except: thread_manager.destroy()
def main(argv): arguments = Arguments("settings.json", argv) test_run = Test_Run(arguments) arguments.check_help() # Clean up the logs directory so that old logs are not considered when # checking for exception logs. test_run.clear_logs_directory() print("> Executing unit tests") test_run.execute_unit_tests() statement_coverage_report = test_run.execute_statement_coverage_report() if statement_coverage_report is not None: print("> Executing statement coverage") print(statement_coverage_report) method_coverage_report = test_run.execute_method_coverage_report() if method_coverage_report is not None: print("> Executing method coverage") print(method_coverage_report) files, commit_range = test_run.get_changed_files() if files: print("> Executing pylint on changed files in {}".format(commit_range)) test_run.execute_pylint(files) print("> Cleaning up the logs directory") log_contents = test_run.read_logs_directory() if log_contents != "": print("Exception logs found:") print(log_contents) test_run.clear_logs_directory() if not test_run.is_passed(): exit(1)
def main(argv): arguments = Arguments("settings.json", argv) try: environment = Environment.setup(arguments, simulated=False) distance_sensors = environment.get_distance_sensors() except Exception: arguments.error(traceback.format_exc()) settings = arguments.get_settings("distance_sensor_physical") arguments.check_help() while True: for sensor in distance_sensors: print("Measured distance: {} m".format(sensor.get_distance())) time.sleep(settings.get("interval_delay"))