id: import_

label: Import

parameters:

- id: imports

id: note

label: Note

parameters:

- id: note

id: options

label: Options

parameters:

- id: title

else: self.stop(); self.wait()'

cpp_templates:

documentation: |-

The options block sets special parameters for the flow graph. Only one option block is allowed per flow graph.

id: pad_sink

label: Pad Sink

parameters:

- id: label

id: pad_source

label: Pad Source

parameters:

- id: label

id: parameter

label: Parameter

parameters:

- id: label

var_make: self.${id} = ${id}

make: ${value}

documentation: |-

This block represents a parameter to the flow graph. A parameter can be used to pass command line arguments into a top block. Or, parameters can pass arguments into an instantiated hierarchical block.

templates:

- type: [stream, stream]

cpp_connect: hier_block2::connect(${ make_port_sig(source) }, ${ make_port_sig(sink) })

id: variable

label: Variable

parameters:

- id: value

id: variable_config

label: Variable Config

parameters:

- id: value

id: variable_function_probe

label: Function Probe

parameters:

- id: block_id

NEED_QT_GUI = 'need_qt_gui'

DEPRECATED = 'deprecated'

NOT_DSP = 'not_dsp'

def __init__(self, flags):

self.data = set(flags)

"""check if this block supports the selected output language"""

current_output_language = self.parent.get_option('output_language')

self.add_error_message("This block does not support C++ output.")

def _validate_var_value(self):

"""or variables check the value (only if var_value is used)"""

if self.is_variable and self.value != 'value':

a list of strings

"""

def make_callback(callback):

if 'this->' in callback:

return callback

return 'this->{}->{}'.format(self.name, callback)

cmake_opt_list = flow_graph.get_option('cmake_opt').split(";")

%>\

% if generate_options == 'qt_gui':

find_package(Qt5Widgets REQUIRED)

set(GR_LIBRARIES

boost_system

gnuradio-blocks

gnuradio-runtime

gnuradio-pmt

% for link in links:

${link}

% endif

% endfor

/********************

GNU Radio C++ Flow Graph Source File

********************/

#include "${flow_graph.get_option('id')}.hpp"

using namespace gr;

<%

%>\

% if generate_options == 'no_gui':

% elif generate_options.startswith('hb'):

## TODO: make_io_sig

% for pad in flow_graph.get_hier_block_message_io('in'):

message_port_register_hier_in("${pad['label']}")

% endfor

message_port_register_hier_out("${pad['label']}")

% endfor

% elif generate_options == 'qt_gui':

this->setWindowTitle("${title}");

// check_set_qss

// set icon

## self._lock = threading.RLock()

% endif

% if blocks:

// Blocks:

% for blk, blk_make, declarations in blocks:

{

## % if 'alias' in blk.params and blk.params['alias'].get_evaluated():

## ${blk.name}.set_block_alias("${blk.params['alias'].get_evaluated()}")

## % endif

% endfor

% endif

}

% endfor

int main (int argc, char **argv) {

% if parameters:

% endif

% if flow_graph.get_option('realtime_scheduling'):

if (enable_realtime_scheduling() != RT_OK) {

${class_name}* top_block = new ${class_name}();

## TODO: params

% if flow_graph.get_option('run_options') == 'prompt':

% for m in monitors:

(top_block->${m.name}).start();

% endfor

std::cin.ignore();

top_block->stop();

% elif flow_graph.get_option('run_options') == 'run':

% endif

% for m in monitors:

(top_block->${m.name}).start();

% elif generate_options == 'qt_gui':

QApplication app(argc, argv);

top_block->show();

app.exec();

#ifndef ${flow_graph.get_option('id').upper()}_HPP

#define ${flow_graph.get_option('id').upper()}_HPP

/********************

#include <QSettings>

% endif

using namespace gr;

<%

%>\

% if generate_options == 'no_gui':

% elif generate_options.startswith('hb'):

class ${class_name} : public hier_block2 {

% elif generate_options == 'qt_gui':

Q_OBJECT

% endif

% for block, make, declarations in blocks:

% endfor

% if parameters:

// Parameters:

% for param in parameters:

% endfor

% endif

% endif

public:

~${class_name}();

% for var in parameters + variables:

parameters = fg.get_parameters()

monitors = fg.get_monitors()

self._variable_types()

self.namespace = {

'flow_graph': fg,

for var in variables:

var.decide_type()

def _callbacks(self):

fg = self._flow_graph

variables = fg.get_cpp_variables()

for con in sorted(connections, key=by_domain_and_blocks):

template = templates[con.type]

code = template.render(make_port_sig=make_port_sig, source=con.source_port, sink=con.sink_port)

rendered.append(code)

return rendered

# Remove the virtual connection

connections.remove(connection)

# Bypassing blocks: Need to find all the enabled connections for the block using

# the *connections* object rather than get_connections(). Create new connections

# that bypass the selected block and remove the existing ones. This allows adjacent

includes=list,

declarations=str_,

make=str_,

callbacks=list,

link=list,

translations=dict,

DOMAIN_CONNECTION = expand(

type=Spec(types=list, required=True, item_scheme=None),

connect=str_,

)

DOMAIN_SCHEME = expand(

shell=False, universal_newlines=True

)

def _cpp_popen(self):

"""

Execute this C++ flow graph after generating and compiling it.

generator = self.page.get_generator()

run_command = generator.file_path + '/build/' + self.flow_graph.get_option('id')

if os.path.isfile(run_command):

os.remove(run_command)

xterm_executable = find_executable(self.xterm_executable)

Messages.send_start_exec(' '.join(run_command_args))

return subprocess.Popen(

stdout=subprocess.PIPE, stderr=subprocess.STDOUT,

)

def run(self):