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 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 tempfile
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: