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):
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):
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):
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"))
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"))
