def __init__(self): """ Make a platform for gnuradio. """ #ensure hier dir if not os.path.exists(HIER_BLOCKS_LIB_DIR): os.mkdir(HIER_BLOCKS_LIB_DIR) #init _Platform.__init__( self, name='GNU Radio Companion', version=(gr.version(), gr.major_version(), gr.api_version(), gr.minor_version()), key='grc', license=__doc__.strip(), website='http://gnuradio.org/', block_paths=BLOCKS_DIRS, block_dtd=BLOCK_DTD, default_flow_graph=DEFAULT_FLOW_GRAPH, generator=Generator, colors=COLORS, ) _GUIPlatform.__init__( self, prefs_file=PREFS_FILE )
def main(args=None): args = args or argument_parser().parse_args() platform = Platform( name="GNU Radio Companion Compiler", prefs=gr.prefs(), version=gr.version(), version_parts=(gr.major_version(), gr.api_version(), gr.minor_version()), ) platform.build_library() out_dir = ( args.output if not args.user_lib_dir else platform.config.hier_block_lib_dir ) if os.path.exists(out_dir): pass # all is well elif args.save_to_lib: os.mkdir(out_dir) # create missing hier_block lib directory else: exit("Error: Invalid output directory") Messages.send_init(platform) flow_graph = file_path = None for grc_file in args.grc_files: os.path.exists(grc_file) or exit("Error: missing " + grc_file) Messages.send("\n") flow_graph, file_path = platform.load_and_generate_flow_graph( os.path.abspath(grc_file), os.path.abspath(out_dir) ) if not file_path: exit("Compilation error") if file_path and args.run: run_command_args = flow_graph.get_run_command(file_path, split=True) subprocess.call(run_command_args)
def main(args=None): args = args or argument_parser().parse_args() platform = Platform(name='GNU Radio Companion Compiler', prefs=gr.prefs(), version=gr.version(), version_parts=(gr.major_version(), gr.api_version(), gr.minor_version())) platform.build_library() output_dir = args.output if not args.user_lib_dir else platform.config.hier_block_lib_dir try: # recursive mkdir: os.makedirs doesn't work with .. paths, resolve with realpath os.makedirs(os.path.realpath(output_dir), exist_ok=True) except Exception as e: exit(str(e)) Messages.send_init(platform) flow_graph = file_path = None for grc_file in args.grc_files: os.path.exists(grc_file) or exit('Error: missing ' + grc_file) Messages.send('\n') flow_graph, file_path = platform.load_and_generate_flow_graph( os.path.abspath(grc_file), os.path.abspath(output_dir)) if not file_path: exit('Compilation error') if file_path and args.run: run_command_args = flow_graph.get_run_command(file_path, split=True) subprocess.call(run_command_args)
def grc_to_py(grcfile, outdir): platform = Platform(prefs_file=gr.prefs(), version=gr.version(), version_parts=(gr.major_version(), gr.api_version(), gr.minor_version())) data = platform.parse_flow_graph(grcfile) # Clean out the QT GUI, etc. blocks = data['flow_graph']['block'] for b in blocks: if b['key'] == 'options': for opt in b['param']: if opt['key'] == 'generate_options' and opt[ 'value'] != 'no_gui': opt['value'] = 'no_gui' elif opt['key'] == 'run_options' and opt['value'] != 'run': opt['value'] = 'run' elif opt['key'] == 'run' and opt['value'] != 'False': opt['value'] = 'False' fg = platform.get_new_flow_graph() fg.import_data(data) fg.grc_file_path = os.path.abspath(grcfile) fg.validate() if not fg.is_valid(): raise StandardError("\n\n".join(["Validation failed:"] + fg.get_error_messages())) if outdir[-1] != '/': outdir += '/' gen = platform.Generator(fg, outdir) gen.write()
def __init__(self): """ Make a platform for gnuradio. """ # ensure hier and conf directories if not os.path.exists(HIER_BLOCKS_LIB_DIR): os.mkdir(HIER_BLOCKS_LIB_DIR) if not os.path.exists(os.path.dirname(PREFS_FILE)): os.mkdir(os.path.dirname(PREFS_FILE)) self.block_docstrings = {} self.block_docstrings_loaded_callback = lambda: None # dummy to be replaced by BlockTreeWindow self._docstring_extractor = extract_docs.SubprocessLoader( callback_query_result=self._save_docstring_extraction_result, callback_finished=lambda: self.block_docstrings_loaded_callback()) # init _Platform.__init__( self, name='GNU Radio Companion', version=(gr.version(), gr.major_version(), gr.api_version(), gr.minor_version()), key='grc', license=__doc__.strip(), website='http://gnuradio.org/', block_paths=BLOCKS_DIRS, block_dtd=BLOCK_DTD, default_flow_graph=DEFAULT_FLOW_GRAPH, generator=Generator, colors=[(name, color) for name, key, sizeof, color in CORE_TYPES], ) self._move_old_pref_file() _GUIPlatform.__init__(self, prefs_file=PREFS_FILE) self._auto_hier_block_generate_chain = set()
def main(args=None): args = args or argument_parser().parse_args() platform = Platform( name='GNU Radio Companion Compiler', prefs=gr.prefs(), version=gr.version(), version_parts=(gr.major_version(), gr.api_version(), gr.minor_version()) ) platform.build_library() out_dir = args.output if not args.user_lib_dir else platform.config.hier_block_lib_dir if os.path.exists(out_dir): pass # all is well elif args.save_to_lib: os.mkdir(out_dir) # create missing hier_block lib directory else: exit('Error: Invalid output directory') Messages.send_init(platform) flow_graph = file_path = None for grc_file in args.grc_files: os.path.exists(grc_file) or exit('Error: missing ' + grc_file) Messages.send('\n') flow_graph, file_path = platform.load_and_generate_flow_graph( os.path.abspath(grc_file), os.path.abspath(out_dir)) if not file_path: exit('Compilation error') if file_path and args.run: run_command_args = flow_graph.get_run_command(file_path, split=True) subprocess.call(run_command_args)
def main(): from gnuradio import gr parser = argparse.ArgumentParser( description=VERSION_AND_DISCLAIMER_TEMPLATE % gr.version()) parser.add_argument('flow_graphs', nargs='*') parser.add_argument( '--log', choices=['debug', 'info', 'warning', 'error', 'critical'], default='warning') args = parser.parse_args() # Enable logging # Note: All other modules need to use the 'grc.<module>' convention log = logging.getLogger('grc') # NOTE: This sets the log level to what was requested for the logger on the # command line, but this may not be the correct approach if multiple handlers # are intended to be used. The logger level shown here indicates all the log # messages that are captured and the handler levels indicate messages each # handler will output. A better approach may be resetting this to logging.DEBUG # to catch everything and making sure the handlers have the correct levels set. # This would be useful for a future GUI logging window that can filter messages # independently of the console output. In this case, this should be DEBUG. log.setLevel(LOG_LEVELS[args.log]) # Console formatting console = logging.StreamHandler() console.setLevel(LOG_LEVELS[args.log]) #msg_format = '[%(asctime)s - %(levelname)8s] --- %(message)s (%(filename)s:%(lineno)s)' msg_format = '[%(levelname)s] %(message)s (%(filename)s:%(lineno)s)' date_format = '%I:%M' formatter = logging.Formatter(msg_format, datefmt=date_format) #formatter = utils.log.ConsoleFormatter() console.setFormatter(formatter) log.addHandler(console) py_version = sys.version.split()[0] log.debug("Starting GNU Radio Companion ({})".format(py_version)) # Delay importing until the logging is setup from .gui.Platform import Platform from .gui.Application import Application log.debug("Loading platform") platform = Platform(version=gr.version(), version_parts=(gr.major_version(), gr.api_version(), gr.minor_version()), prefs=gr.prefs(), install_prefix=gr.prefix()) platform.build_library() log.debug("Loading application") app = Application(args.flow_graphs, platform) log.debug("Running") sys.exit(app.run())
def main(): from gnuradio import gr parser = argparse.ArgumentParser( description=VERSION_AND_DISCLAIMER_TEMPLATE % gr.version()) parser.add_argument('flow_graphs', nargs='*') parser.add_argument( '--log', choices=['debug', 'info', 'warning', 'error', 'critical'], default='warning') args = parser.parse_args() try: Gtk.window_set_default_icon(Gtk.IconTheme().load_icon( 'gnuradio-grc', 256, 0)) except: pass # Enable logging # Note: All other modules need to use the 'grc.<module>' convention log = logging.getLogger('grc') log.setLevel(logging.DEBUG) # Console formatting console = logging.StreamHandler() console.setLevel(LOG_LEVELS[args.log]) #msg_format = '[%(asctime)s - %(levelname)8s] --- %(message)s (%(filename)s:%(lineno)s)' msg_format = '[%(levelname)s] %(message)s (%(filename)s:%(lineno)s)' date_format = '%I:%M' formatter = logging.Formatter(msg_format, datefmt=date_format) #formatter = utils.log.ConsoleFormatter() console.setFormatter(formatter) log.addHandler(console) py_version = sys.version.split()[0] log.debug("Starting GNU Radio Companion ({})".format(py_version)) # Delay importing until the logging is setup from .gui.Platform import Platform from .gui.Application import Application log.debug("Loading platform") platform = Platform(version=gr.version(), version_parts=(gr.major_version(), gr.api_version(), gr.minor_version()), prefs=gr.prefs(), install_prefix=gr.prefix()) platform.build_library() log.debug("Loading application") app = Application(args.flow_graphs, platform) log.debug("Running") sys.exit(app.run())
def main(): from gnuradio import gr parser = argparse.ArgumentParser( description=VERSION_AND_DISCLAIMER_TEMPLATE % gr.version()) parser.add_argument("flow_graphs", nargs="*") parser.add_argument( "--log", choices=["debug", "info", "warning", "error", "critical"], default="warning", ) args = parser.parse_args() # Enable logging # Note: All other modules need to use the 'grc.<module>' convention log = logging.getLogger("grc") log.setLevel(logging.INFO) # Console formatting console = logging.StreamHandler() console.setLevel(LOG_LEVELS[args.log]) # msg_format = '[%(asctime)s - %(levelname)8s] --- %(message)s (%(filename)s:%(lineno)s)' msg_format = "[%(levelname)s] %(message)s (%(filename)s:%(lineno)s)" date_format = "%I:%M" formatter = logging.Formatter(msg_format, datefmt=date_format) # formatter = utils.log.ConsoleFormatter() console.setFormatter(formatter) log.addHandler(console) py_version = sys.version.split()[0] log.debug("Starting GNU Radio Companion ({})".format(py_version)) # Delay importing until the logging is setup from .gui.Platform import Platform from .gui.Application import Application log.debug("Loading platform") platform = Platform( version=gr.version(), version_parts=(gr.major_version(), gr.api_version(), gr.minor_version()), prefs=gr.prefs(), install_prefix=gr.prefix(), ) platform.build_library() log.debug("Loading application") app = Application(args.flow_graphs, platform) log.debug("Running") sys.exit(app.run())
def main(): from gnuradio import gr parser = argparse.ArgumentParser( description=VERSION_AND_DISCLAIMER_TEMPLATE % gr.version()) parser.add_argument('flow_graphs', nargs='*') parser.add_argument('--log', choices=['debug', 'info', 'warning', 'error', 'critical'], default='warning') args = parser.parse_args() # Enable logging # Note: All other modules need to use the 'grc.<module>' convention log = logging.getLogger('grc') log.setLevel(logging.DEBUG) # Console formatting console = logging.StreamHandler() console.setLevel(LOG_LEVELS[args.log]) #msg_format = '[%(asctime)s - %(levelname)8s] --- %(message)s (%(filename)s:%(lineno)s)' msg_format = '[%(levelname)s] %(message)s (%(filename)s:%(lineno)s)' date_format = '%I:%M' formatter = logging.Formatter(msg_format, datefmt=date_format) #formatter = utils.log.ConsoleFormatter() console.setFormatter(formatter) log.addHandler(console) py_version = sys.version.split()[0] log.debug("Starting GNU Radio Companion ({})".format(py_version)) # Delay importing until the logging is setup from .gui.Platform import Platform from .gui.Application import Application log.debug("Loading platform") platform = Platform( version=gr.version(), version_parts=(gr.major_version(), gr.api_version(), gr.minor_version()), prefs=gr.prefs(), install_prefix=gr.prefix() ) platform.build_library() log.debug("Loading application") app = Application(args.flow_graphs, platform) log.debug("Running") sys.exit(app.run())
def __init__(self): """ Make a platform for gnuradio. """ # ensure hier and conf directories if not os.path.exists(HIER_BLOCKS_LIB_DIR): os.mkdir(HIER_BLOCKS_LIB_DIR) if not os.path.exists(os.path.dirname(PREFS_FILE)): os.mkdir(os.path.dirname(PREFS_FILE)) self.block_docstrings = block_docstrings = dict() self.block_docstrings_loaded_callback = lambda: None def setter(key, docs): block_docstrings[key] = '\n\n'.join( '--- {0} ---\n{1}\n'.format(b, d.replace('\n\n', '\n')) for b, d in docs.iteritems() if d is not None ) self._docstring_extractor = extract_docs.SubprocessLoader( callback_query_result=setter, callback_finished=lambda: self.block_docstrings_loaded_callback() ) # init _Platform.__init__( self, name='GNU Radio Companion', version=(gr.version(), gr.major_version(), gr.api_version(), gr.minor_version()), key='grc', license=__doc__.strip(), website='http://gnuradio.org/', block_paths=BLOCKS_DIRS, block_dtd=BLOCK_DTD, default_flow_graph=DEFAULT_FLOW_GRAPH, generator=Generator, colors=COLORS, ) self._move_old_pref_file() _GUIPlatform.__init__( self, prefs_file=PREFS_FILE ) self._auto_hier_block_generate_chain = set()
def main(): parser = optparse.OptionParser( usage='usage: %prog [options] [saved flow graphs]', version=VERSION_AND_DISCLAIMER_TEMPLATE % gr.version()) options, args = parser.parse_args() try: gtk.window_set_default_icon(gtk.IconTheme().load_icon('gnuradio-grc', 256, 0)) except: pass platform = Platform( prefs_file=gr.prefs(), version=gr.version(), version_parts=(gr.major_version(), gr.api_version(), gr.minor_version()), install_prefix=gr.prefix() ) ActionHandler(args, platform) gtk.main()
def __init__(self): """ Make a platform for gnuradio. """ # ensure hier and conf directories if not os.path.exists(HIER_BLOCKS_LIB_DIR): os.mkdir(HIER_BLOCKS_LIB_DIR) if not os.path.exists(os.path.dirname(PREFS_FILE)): os.mkdir(os.path.dirname(PREFS_FILE)) self.block_docstrings = block_docstrings = dict() self.block_docstrings_loaded_callback = lambda: None def setter(key, docs): block_docstrings[key] = '\n\n'.join( '--- {0} ---\n{1}\n'.format(b, d.replace('\n\n', '\n')) for b, d in docs.iteritems() if d is not None) self._docstring_extractor = extract_docs.SubprocessLoader( callback_query_result=setter, callback_finished=lambda: self.block_docstrings_loaded_callback()) # init _Platform.__init__( self, name='GNU Radio Companion', version=(gr.version(), gr.major_version(), gr.api_version(), gr.minor_version()), key='grc', license=__doc__.strip(), website='http://gnuradio.org/', block_paths=BLOCKS_DIRS, block_dtd=BLOCK_DTD, default_flow_graph=DEFAULT_FLOW_GRAPH, generator=Generator, colors=COLORS, ) self._move_old_pref_file() _GUIPlatform.__init__(self, prefs_file=PREFS_FILE) self._auto_hier_block_generate_chain = set()
def __init__(self): """ Make a platform for gnuradio. """ # ensure hier and conf directories if not os.path.exists(HIER_BLOCKS_LIB_DIR): os.mkdir(HIER_BLOCKS_LIB_DIR) if not os.path.exists(os.path.dirname(PREFS_FILE)): os.mkdir(os.path.dirname(PREFS_FILE)) self.block_docstrings = {} self.block_docstrings_loaded_callback = lambda: None # dummy to be replaced by BlockTreeWindow self._docstring_extractor = extract_docs.SubprocessLoader( callback_query_result=self._save_docstring_extraction_result, callback_finished=lambda: self.block_docstrings_loaded_callback() ) # init _Platform.__init__( self, name='GNU Radio Companion', version=(gr.version(), gr.major_version(), gr.api_version(), gr.minor_version()), key='grc', license=__doc__.strip(), website='http://gnuradio.org/', block_paths=BLOCKS_DIRS, block_dtd=BLOCK_DTD, default_flow_graph=DEFAULT_FLOW_GRAPH, generator=Generator, colors=[(name, color) for name, key, sizeof, color in CORE_TYPES], ) self._move_old_pref_file() _GUIPlatform.__init__( self, prefs_file=PREFS_FILE ) self._auto_hier_block_generate_chain = set()
import threading import gi gi.require_version("Gtk", "3.0") gi.require_version("PangoCairo", "1.0") from gi.repository import GLib from gnuradio import gr from gnuradio.grc.gui.Platform import Platform from gnuradio.grc.gui.Application import Actions, Application # include the necessary boilerplate from grc's main function to create the app platform = Platform( version=gr.version(), version_parts=(gr.major_version(), gr.api_version(), gr.minor_version()), prefs=gr.prefs(), install_prefix=gr.prefix(), ) platform.build_library() # pick an example that runs a bunch of qt-gui sinks example_grc_path = (pathlib.Path(gr.prefix()) / "share" / "gnuradio" / "examples" / "qt-gui" / "qtgui_multi_input.grc") app = Application((example_grc_path, ), platform) # script what we want to try out with the app def script(app): # ensure the app is initialized before proceeding while not app.init: time.sleep(1)