def main(): """Main entry point for iotile-sgcompile.""" arg_parser = build_args() args = arg_parser.parse_args() model = DeviceModel() parser = SensorGraphFileParser() parser.parse_file(args.sensor_graph) if args.format == u'ast': write_output(parser.dump_tree(), True, args.output) sys.exit(0) parser.compile(model) if not args.disable_optimizer: opt = SensorGraphOptimizer() opt.optimize(parser.sensor_graph, model=model) if args.format == u'nodes': output = u'\n'.join(parser.sensor_graph.dump_nodes()) + u'\n' write_output(output, True, args.output) else: if args.format not in KNOWN_FORMATS: print("Unknown output format: {}".format(args.format)) sys.exit(1) output_format = KNOWN_FORMATS[args.format] output = output_format.format(parser.sensor_graph) write_output(output, output_format.text, args.output)
def compile_sg(name): """Compile a sensor graph.""" parser = SensorGraphFileParser() model = DeviceModel() parser.parse_file(get_path(name)) parser.compile(model=model) return parser.sensor_graph
def main(): arg_parser = build_args() args = arg_parser.parse_args() model = DeviceModel() parser = SensorGraphFileParser() parser.parse_file(args.sensor_graph) outfile = sys.stdout if args.output is not None: outfile = open(args.output, "wb") if args.format == u'ast': outfile.write(parser.dump_tree().encode()) outfile.close() sys.exit(0) parser.compile(model) if not args.disable_optimizer: opt = SensorGraphOptimizer() opt.optimize(parser.sensor_graph, model=model) if args.format == u'nodes': for node in parser.sensor_graph.dump_nodes(): outfile.write((node + u'\n').encode()) else: if args.format not in known_formats: print("Unknown output format: {}".format(args.format)) outfile.close() sys.exit(1) output = known_formats[args.format](parser.sensor_graph) if args.format in (u'snippet', u'ascii', u'config'): outfile.write(output.encode()) else: outfile.write(output) outfile.close()
def parser(): return SensorGraphFileParser()
def load_sgf(self, sgf_data): """Load, persist a sensor_graph file. The data passed in `sgf_data` can either be a path or the already loaded sgf lines as a string. It is determined to be sgf lines if there is a '\n' character in the data, otherwise it is interpreted as a path. Note that this scenario just loads the sensor_graph directly into the persisted sensor_graph inside the device. You will still need to reset the device for the sensor_graph to enabled and run. Args: sgf_data (str): Either the path to an sgf file or its contents as a string. """ if '\n' not in sgf_data: with open(sgf_data, "r") as infile: sgf_data = infile.read() model = DeviceModel() parser = SensorGraphFileParser() parser.parse_file(data=sgf_data) parser.compile(model) opt = SensorGraphOptimizer() opt.optimize(parser.sensor_graph, model=model) sensor_graph = parser.sensor_graph self._logger.info( "Loading sensor_graph with %d nodes, %d streamers and %d configs", len(sensor_graph.nodes), len(sensor_graph.streamers), len(sensor_graph.config_database)) # Directly load the sensor_graph into our persisted storage self.sensor_graph.persisted_nodes = sensor_graph.dump_nodes() self.sensor_graph.persisted_streamers = sensor_graph.dump_streamers() self.sensor_graph.persisted_constants = [] for stream, value in sorted(sensor_graph.constant_database.items(), key=lambda x: x[0].encode()): reading = IOTileReading(stream.encode(), 0, value) self.sensor_graph.persisted_constants.append((stream, reading)) self.sensor_graph.persisted_exists = True # Clear all config variables and load in those from this sgf file self.config_database.clear() for slot in sorted(sensor_graph.config_database, key=lambda x: x.encode()): for conf_var, (conf_type, conf_val) in sorted( sensor_graph.config_database[slot].items()): self.config_database.add_direct(slot, conf_var, conf_type, conf_val) # If we have an app tag and version set program them in app_tag = sensor_graph.metadata_database.get('app_tag') app_version = sensor_graph.metadata_database.get('app_version') if app_tag is not None: if app_version is None: app_version = "0.0" self.app_info = (app_tag, app_version)
def main(argv=None): """Main entry point for iotile sensorgraph simulator. This is the iotile-sgrun command line program. It takes an optional set of command line parameters to allow for testing. Args: argv (list of str): An optional set of command line parameters. If not passed, these are taken from sys.argv. """ if argv is None: argv = sys.argv[1:] try: executor = None parser = build_args() args = parser.parse_args(args=argv) model = DeviceModel() parser = SensorGraphFileParser() parser.parse_file(args.sensor_graph) parser.compile(model) if not args.disable_optimizer: opt = SensorGraphOptimizer() opt.optimize(parser.sensor_graph, model=model) graph = parser.sensor_graph sim = SensorGraphSimulator(graph) for stop in args.stop: sim.stop_condition(stop) for watch in args.watch: watch_sel = DataStreamSelector.FromString(watch) graph.sensor_log.watch(watch_sel, watch_printer) # If we are semihosting, create the appropriate executor connected to the device if args.semihost_device is not None: executor = SemihostedRPCExecutor(args.port, args.semihost_device) sim.rpc_executor = executor for mock in args.mock_rpc: slot, rpc_id, value = process_mock_rpc(mock) sim.rpc_executor.mock(slot, rpc_id, value) for stim in args.stimulus: sim.stimulus(stim) graph.load_constants() if args.trace is not None: sim.record_trace() try: if args.connected: sim.step(user_connected, 8) sim.run(accelerated=not args.realtime) except KeyboardInterrupt: pass if args.trace is not None: sim.trace.save(args.trace) finally: if executor is not None: executor.hw.close() return 0