- set_reference(${reference})

- set_gain(${gain})

- set_max_gain(${max_gain})

file_format: 1

- set_reference(${reference})

- set_gain(${gain})

- set_max_gain(${max_gain})

file_format: 1

- set_reference(${reference})

- set_gain(${gain})

- set_max_gain(${max_gain})

file_format: 1

make: 'this->${id} = analog::sig_source_${type.fcn}::make(0, analog::GR_CONST_WAVE, 0, 0, ${const});'

callbacks:

- set_offset(${const})

file_format: 1

make: 'this->${id} = analog::cpfsk_bc::make(${k}, ${amplitude}, ${samples_per_symbol});'

callbacks:

- set_amplitude(${amplitude})

file_format: 1

callbacks:

- set_level(${level})

- set_frequency(${freq})

translations:

'True': 'true'

'False': 'false'

make: 'this->${id} = analog::dpll_bb::make(${period}, ${gain});'

callbacks:

- set_gain(${gain})

file_format: 1

callbacks:

- set_type(${noise_type})

- set_amplitude(${amp})

translations:

analog.: 'analog::'

cpp_templates:

includes: ['#include <gnuradio/analog/feedforward_agc_cc.h>']

make: 'this->${id} = analog::feedforward_agc_cc::make(${num_samples}, ${reference});'

file_format: 1

make: 'this->${id} = analog::frequency_modulator_fc::make(${sensitivity});'

callbacks:

- set_sensitivity(${sensitivity})

file_format: 1

callbacks:

- set_type(${noise_type})

- set_amplitude(${amp})

translations:

analog.: 'analog::'

cpp_templates:

includes: ['#include <gnuradio/analog/phase_modulator_fc.h>']

make: 'this->${id} = analog::phase_modulator_fc::make(${sensitivity});'

callbacks:

- set_sensitivity(${sensitivity})

- set_loop_bandwidth(${w})

- set_max_freq(${max_freq})

- set_min_freq(${min_freq})

file_format: 1

- set_loop_bandwidth(${w})

- set_max_freq(${max_freq})

- set_min_freq(${min_freq})

file_format: 1

- set_loop_bandwidth(${w})

- set_max_freq(${max_freq})

- set_min_freq(${min_freq})

file_format: 1

callbacks:

- set_threshold(${threshold})

- set_alpha(${alpha})

translations:

True: true

False: false

callbacks:

- set_lo(${lo})

- set_hi(${hi})

file_format: 1

cpp_templates:

includes: ['#include <gnuradio/analog/random_uniform_source.h>']

make: 'this->${id} = analog.random_uniform_source_${type.fcn}(${minimum}, ${maximum}, ${seed});'

file_format: 1

- set_amplitude(${amp})

- set_offset(${offset})

- set_phase(${phase})

translations:

analog\.: 'analog::'

callbacks:

- set_threshold(${threshold})

- set_alpha(${alpha})

file_format: 1

includes: [ '#include <gnuradio/analog/frequency_modulator_fc.h>', '#include <boost/math/constants/constants.hpp>' ]

declarations: gr::analog::frequency_modulator_fc::sptr ${id};

make: this->${id} = gr::analog::frequency_modulator_fc::make(2 * boost::math::constants::pi<double>() * ${max_dev} / ${quad_rate});

file_format: 1

includes: [ '#include <gnuradio/audio/sink.h>' ]

declarations: 'audio::sink::sptr ${id};'

make: 'this->${id} = audio::sink::make(${samp_rate}, ${device_name}, ${ok_to_block});'

translations:

"'": '"'

'True': 'true'

includes: [ '#include <gnuradio/audio/source.h>' ]

declarations: 'audio::source::sptr ${id};'

make: 'this->${id} = audio::source::make(${samp_rate}, ${device_name}, ${ok_to_block});'

translations:

"'": '"'

'True': 'true'

count=${count},

bits_per_byte=${bits_per_byte},

reset_tag_key=${reset_tag_key});

file_format: 1

declarations: 'digital::binary_slicer_fb::sptr ${id};'

make: |-

this->${id} = digital::binary_slicer_fb::make();

file_format: 1

${post_padding},

${insert_phasing},

${length_tag_name});

translations:

'True': 'true'

'False': 'false'

this->${id} = digital::chunks_to_symbols_${in_type.fcn}${out_type.fcn}::make(

symbol_table,

${dimension});

callbacks:

- set_symbol_table(symbol_table)

${mu},

${gain_mu},

${omega_relative_limit});

callbacks:

- set_omega(${omega})

- set_gain_omega(${gain_omega})

% elif str(soft_dec_lut) != "None":

this->${id}.set_soft_dec_lut(${soft_dec_lut}, ${precision});

% endif

file_format: 1

includes: ['#include <gnuradio/digital/constellation_decoder_cb.h>']

declarations: 'digital::constellation_decoder_cb::sptr ${id};'

make: 'this->${id} = digital::constellation_decoder_cb::make(${constellation});'

file_format: 1

includes: ['#include <gnuradio/digital/constellation_encoder_bc.h>']

declarations: 'digital::constellation_encoder_bc::sptr ${id};'

make: 'this->${id} = digital::constellation_encoder_bc::make(${constellation});'

file_format: 1

${loop_bw},

${fmin},

${fmax}));

file_format: 1

declarations: 'digital::constellation_soft_decoder_cf::sptr ${id};'

make: |-

this->${id} = digital::constellation_soft_decoder_cf::make(${constellation});

file_format: 1

${mark_delay},

${threshold},

${threshold_method});

callbacks:

- set_mark_delay(${mark_delay})

- set_threshold(${threshold})

${access_code},

${threshold},

${tagname});

callbacks:

- set_access_code(${access_code})

- set_threshold(${threshold})

${access_code},

${threshold},

${tagname});

file_format: 1

${w},

${order},

${use_snr});

callbacks:

- set_loop_bandwidth(${w})

translations:

${samples_per_symbol},

${L},

${beta});

translations:

analog.cpm.: 'analog::cpm::'

make: |-

this->${id} = digital::crc32_async_bb::make(

${check});

translations:

'True': 'true'

'False': 'false'

${check},

${lengthtagname},

${packed});

translations:

'True': 'true'

'False': 'false'

${mask},

${seed},

${len});

file_format: 1

declarations: 'digital::diff_decoder_bb::sptr ${id};'

make: |-

this->${id} = digital::diff_decoder_bb::make(${modulus if coding.force_modulus == '-1' else coding.force_modulus}, ${coding});

translations:

digital.DIFF: 'digital::DIFF'

declarations: 'digital::diff_encoder_bb::sptr ${id};'

make: |-

this->${id} = digital::diff_encoder_bb::make(${modulus if coding.force_modulus == '-1' else coding.force_modulus}, ${coding});

translations:

digital.DIFF: 'digital::DIFF'

declarations: 'digital::diff_phasor_cc::sptr ${id};'

make: |-

this->${id} = digital::diff_phasor_cc::make();

file_format: 1

${rolloff},

${filter_size},

${w});

callbacks:

- set_loop_bandwidth(${w})

declarations: 'digital::framer_sink_1::sptr ${id};'

make: |-

this->${id} = digital::framer_sink_1::make(${target_queue});

file_format: 1

${repeat},

${mask},

${seed});

translations:

'True': 'true'

'False': 'false'

this->${id} = digital::hdlc_deframer_bp::make(

${min},

${max});

file_format: 1

includes: ['#include <gnuradio/digital/hdlc_framer_pb.h>']

declarations: 'digital::hdlc_framer_pb::sptr ${id};'

make: 'this->${id} = digital::hdlc_framer_pb::make(${frame_tag_name});'

file_format: 1

${samp_rate},

${special_tags},

${header_padding});

translations:

'True': 'true'

'False': 'false'

make: |-

std::vector<int> map = {${str(map)[1:-1]}};

this->${id} = digital::map_bb::make(map);

file_format: 1

std::vector<float> taps = {${str(taps)[1:-1]}};

this->${id} = ${id} = digital::modulate_vector_bc(${mod}.to_basic_block(),

data, taps);

file_format: 1

${type},

${tag_nsamples},

${alpha});

callbacks:

- set_type(${type})

- set_tag_nsamples(${tag_nsamples})

${gain},

${limit},

${osps});

callbacks:

- set_gain(${gain})

- set_sps(${sps})

${sync_words},

${len_tag_key},

${output_is_shifted});

translations:

'True': 'true'

'False': 'false'

${eq_noise_red_len},

${max_carr_offset},

${force_one_symbol});

translations:

'True': 'true'

'False': 'false'

% endif

${rolloff},

${tagname});

file_format: 1

${len_tag_key},

${propagate_channel_state},

${fixed_frame_len});

translations:

'True': 'true'

'False': 'false'

${symbols_skipped},

${carr_offset_key},

${input_is_shifted});

translations:

'True': 'true'

'False': 'false'

${cp_len},

${use_even_carriers},

${threshold});

callbacks:

- set_threshold(${threshold})

translations:

this->${id} = digital::packet_headergenerator_bb::make(

${header_len},

${len_tag_key});

callbacks:

- set_header_formatter(${header_formatter})

this->${id} = digital::packet_headergenerator_bb::make(

${header_len},

${len_tag_key});

file_format: 1

includes: ['#include <gnuradio/digital/packet_headerparser_b.h>']

declarations: 'digital::packet_headerparser_b::sptr ${id};'

make: 'this->${id} = digital::packet_headerparser_b::make(${header_formatter});'

file_format: 1

this->${id} = digital::packet_headerparser_b::make(

${header_len},

${len_tag_key});

file_format: 1

sync_vector,

${target_queue},

${threshold});

file_format: 1

${init_phase},

${max_dev},

${osps});

callbacks:

- update_taps(taps)

- set_loop_bandwidth(${loop_bw})

${degree},

${mask},

${seed});

file_format: 1

includes: ['#include <gnuradio/digital/probe_density_b.h>']

declarations: 'digital::probe_density_b::sptr ${id};'

make: 'this->${id} = digital::probe_density_b::make(${alpha});'

callbacks:

- set_alpha(${alpha})

${type},

${msg_nsamples},

${alpha});

callbacks:

- set_type(${type})

- set_msg_nsample(${msg_nsamples})

includes: ['#include <gnuradio/digital/protocol_formatter_async.h>']

declarations: 'digital::protocol_formatter_async::sptr ${id};'

make: 'this->${id} = digital::protocol_formatter_async::make(${format});'

file_format: 1

includes: ['#include <gnuradio/digital/protocol_formatter_bb.h>']

declarations: 'digital::protocol_formatter_bb::sptr ${id};'

make: 'this->${id} = digital::protocol_formatter_bb::make(${format}, ${len_tag_key});'

file_format: 1

includes: ['#include <gnuradio/digital/protocol_parser_b.h>']

declarations: 'digital::protocol_parser_b::sptr ${id};'

make: 'this->${id} = fft::ctrlport_probe_psd::make(${format});'

file_format: 1

includes: ['#include <gnuradio/digital/scrambler_bb.h>']

declarations: 'digital::scrambler_bb::sptr ${id};'

make: 'this->${id} = digital::scrambler_bb::make(${mask}, ${seed}, ${len});'

file_format: 1

${resamp_type},

${nfilters},

pfb_mf_taps);

callbacks:

- set_loop_bandwidth(${loop_bw})

- set_damping_factor(${damping})

this->${id} = ${id} = digital::header_format_default(${access_code},\

${threshold}, ${bps});

% endif

file_format: 1

includes: ['#include <gnuradio/dtv/atsc_deinterleaver.h>']

declarations: 'dtv::atsc_deinterleaver::sptr ${id};'

make: 'this->${id} = dtv::atsc_deinterleaver::make();'

file_format: 1

includes: ['#include <gnuradio/dtv/atsc_depad.h>']

declarations: 'dtv::atsc_depad::sptr ${id};'

make: 'this->${id} = dtv::atsc_depad::make();'

file_format: 1

includes: ['#include <gnuradio/dtv/atsc_derandomizer.h>']

declarations: 'dtv::atsc_derandomizer::sptr ${id};'

make: 'this->${id} = dtv::atsc_derandomizer::make();'

file_format: 1

includes: ['#include <gnuradio/dtv/atsc_equalizer.h>']

declarations: 'dtv::atsc_equalizer::sptr ${id};'

make: 'this->${id} = dtv::atsc_equalizer::make();'

file_format: 1

includes: ['#include <gnuradio/dtv/atsc_field_sync_mux.h>']

declarations: 'dtv::atsc_field_sync_mux::sptr ${id};'

make: 'this->${id} = dtv::atsc_field_sync_mux::make();'

file_format: 1

includes: ['#include <gnuradio/dtv/atsc_fpll.h>']

declarations: 'dtv::atsc_fpll::sptr ${id};'

make: 'this->${id} = dtv::atsc_fpll::make(${rate});'

file_format: 1

includes: ['#include <gnuradio/dtv/atsc_fs_checker.h>']

declarations: 'dtv::atsc_fs_checker::sptr ${id};'

make: 'this->${id} = dtv::atsc_fs_checker::make();'

file_format: 1

includes: ['#include <gnuradio/dtv/atsc_interleaver.h>']

declarations: 'dtv::atsc_interleaver::sptr ${id};'

make: 'this->${id} = dtv::atsc_interleaver::make();'

file_format: 1

includes: ['#include <gnuradio/dtv/atsc_pad.h>']

declarations: 'dtv::atsc_pad::sptr ${id};'

make: 'this->${id} = dtv::atsc_pad::make();'

file_format: 1

includes: ['#include <gnuradio/dtv/atsc_randomizer.h>']

declarations: 'dtv::atsc_randomizer::sptr ${id};'

make: 'this->${id} = dtv::atsc_randomizer::make();'

file_format: 1

includes: ['#include <gnuradio/dtv/atsc_rs_decoder.h>']

declarations: 'dtv::atsc_rs_decoder::sptr ${id};'

make: 'this->${id} = dtv::atsc_rs_decoder::make();'

file_format: 1

includes: ['#include <gnuradio/dtv/atsc_rs_encoder.h>']

declarations: 'dtv::atsc_rs_encoder::sptr ${id};'

make: 'this->${id} = dtv::atsc_rs_encoder::make();'

file_format: 1

includes: ['#include <gnuradio/dtv/atsc_sync.h>']

declarations: 'dtv::atsc_sync::sptr ${id};'

make: 'this->{id} = dtv::atsc_sync::make(${rate});'

file_format: 1

includes: ['#include <gnuradio/dtv/atsc_trellis_encoder.h>']

declarations: 'dtv::atsc_trellis_encoder::sptr ${id};'

make: 'this->${id} = dtv::atsc_trellis_encoder::make();'

file_format: 1

includes: ['#include <gnuradio/dtv/atsc_viterbi_decoder.h>']

declarations: 'dtv::atsc_viterbi_decoder::sptr ${id};'

make: 'this->${id} = dtv::atsc_viterbi_decoder::make();'

file_format: 1

includes: ['#include <gnuradio/dtv/catv_frame_sync_enc_bb.h>']

declarations: 'dtv::catv_frame_sync_enc_bb::sptr ${id};'

make: 'this->${id} = dtv::catv_frame_sync_enc_bb::make(${constellation.val}, ${ctrlword});'

translations:

dtv\.: "dtv::"

includes: ['#include <gnuradio/dtv/catv_randomizer_bb.h>']

declarations: 'dtv::catv_randomizer_bb::sptr ${id};'

make: 'this->${id} = dtv::catv_randomizer_bb::make(${constellation.val});'

translations:

dtv\.: "dtv::"

includes: ['#include <gnuradio/dtv/catv_reed_solomon_enc_bb.h>']

declarations: 'dtv::catv_reed_solomon_enc_bb::sptr ${id};'

make: 'this->${id} = dtv::catv_reed_solomon_enc_bb::make();'

file_format: 1

includes: ['#include <gnuradio/dtv/catv_transport_framing_enc_bb.h>']

declarations: 'dtv::catv_transport_framing_enc_bb::sptr ${id};'

make: 'this->${id} = dtv::catv_transport_framing_enc_bb::make();'

file_format: 1

includes: ['#include <gnuradio/dtv/catv_trellis_enc_bb.h>']

declarations: 'dtv::catv_trellis_enc_bb::sptr ${id};'

make: 'dtv::catv_trellis_enc_bb::make(${constellation.val});'

translations:

dtv\.: "dtv::"

${inband.val},

${fecblocks},

${tsrate});

translations:

dtv\.: 'dtv::'

% endif

% endif

);

translations:

dtv\.: 'dtv::'

% endif

% endif

);

translations:

dtv\.: 'dtv::'

% endif

% endif

${constellation.val});

translations:

dtv\.: 'dtv::'

${rate3.val},

% endif

${constellation.val});

translations:

dtv\.: 'dtv::'

% endif

${constellation.val},

${interpolation.val});

translations:

dtv\.: 'dtv::'

${constellation.val},

${pilots.val},

${goldcode});

translations:

dtv\.: 'dtv::'

declarations: 'dtv::dvbt2_cellinterleaver_cc::sptr ${id};'

make: 'this->${id} = dtv::dvbt2_cellinterleaver_cc::make(${framesize.val},

${constellation.val}, ${fecblocks}, ${tiblocks});'

translations:

dtv\.: 'dtv::'

${reservedbiasbits.val},

${l1scrambled.val},

${inband.val});

translations:

dtv\.: 'dtv::'

${preamble2.val}

% endif

);

translations:

dtv\.: 'dtv::'

includes: ['#include <gnuradio/dtv/dvbt2_interleaver_bb.h>']

declarations: 'dtv::dvbt2_interleaver_bb::sptr ${id};'

make: 'this->${id} = dtv::dvbt2_interleaver_bb::make(${framesize.val}, ${rate.val}, ${constellation.val});'

translations:

dtv\.: 'dtv::'

${paprmode2.val}

% endif

);

translations:

dtv\.: 'dtv::'

declarations: 'dtv::dvbt2_modulator_bc::sptr ${id};'

make: |-

this->${id} = dtv::dvbt2_modulator_bc::make(${framesize.val}, ${constellation.val}, ${rotation.val});

translations:

dtv\.: 'dtv::'

${showlevels.val},

${vclip}

);

translations:

dtv\.: 'dtv::'

${iterations},

${fftsize.vlength}

);

translations:

dtv\.: 'dtv::'

${bandwidth.val},

${fftsize.vlength}

);

translations:

dtv\.: 'dtv::'

${constellation.val},

${hierarchy.val},

${transmission_mode.val});

translations:

dtv\.: 'dtv::'

${constellation.val},

${hierarchy.val},

${transmission_mode.val});

translations:

dtv\.: 'dtv::'

declarations: 'dtv::dvbt_convolutional_deinterleaver::sptr ${id};'

make: |-

this->${id} = dtv::dvbt_convolutional_deinterleaver::make(${blocks}, ${I}, ${M});

file_format: 1

declarations: 'dtv::dvbt_convolutional_interleaver::sptr ${id};'

make: |-

this->${id} = dtv::dvbt_convolutional_interleaver::make(${blocks}, ${I}, ${M});

file_format: 1

${hierarchy.val},

${transmission_mode.val},

${gain});

translations:

dtv\.: 'dtv::'

${transmission_mode.val},

${include_cell_id.val},

${cell_id});

translations:

dtv\.: 'dtv::'

declarations: 'dtv::dvbt_energy_descramble::sptr ${id};'

make: |-

this->${id} = dtv::dvbt_energy_descramble::make(${nsize});

file_format: 1

declarations: 'dtv::dvbt_energy_dispersal::sptr ${id};'

make: |-

this->${id} = dtv::dvbt_energy_dispersal::make(${nsize});

file_format: 1

${constellation.val},

${hierarchy.val},

${code_rate.val});

translations:

dtv\.: 'dtv::'

${hierarchy.val},

${transmission_mode.val},

${gain});

translations:

dtv\.: 'dtv::'

${occupied_tones},

${cp_length},

${snr});

file_format: 1

${t},

${s},

${blocks});

file_format: 1

${t},

${s},

${blocks});

file_format: 1

${transmission_mode.val},

${include_cell_id.val},

${cell_id});

translations:

dtv\.: 'dtv::'

${transmission_mode.payload_length},

${transmission_mode.val},

${direction.val});

translations:

dtv\.: 'dtv::'

${hierarchy.val},

${code_rate.val},

${block_size});

translations:

dtv\.: 'dtv::'

includes: [ '#include <gnuradio/fft/ctrlport_probe_psd.h>' ]

declarations: 'fft::ctrlport_probe_psd::sptr ${id};'

make: 'this->${id} = fft::ctrlport_probe_psd::make(${name}, ${desc}, ${len});'

callbacks:

- set_length(${len})

% else:

this->${id} = fft::fft_vfc::make(${fft_size}, ${forward}, ${window}, ${shift}, ${nthreads});

% endif

callbacks:

- set_nthreads(${nthreads})

translations:

includes: [ '#include <gnuradio/fft/goertzel_fc.h>' ]

declarations: 'fft::goertzel_fc::sptr ${id};'

make: 'this->${id} = fft::goertzel_fc::make(${rate}, ${len}, ${freq});'

callbacks:

- set_freq(${freq})

- set_rate(${rate})

${width},

${win},

${beta}));

callbacks:

- set_taps(firdes::${type.fcn}(${gain}, ${samp_rate}, ${low_cutoff_freq}, ${high_cutoff_freq},

${width}, ${win}, ${beta}))

${width},

${win},

${beta}));

callbacks:

- set_taps(firdes::${type.fcn}(${gain}, ${samp_rate}, ${low_cutoff_freq}, ${high_cutoff_freq},

${width}, ${win}, ${beta}))

includes: ['#include <gnuradio/filter/dc_blocker_${type}.h>']

declarations: 'filter::dc_blocker_${type}::sptr ${id};'

make: 'this->${id} = filter::dc_blocker_${type}::make(${length}, ${long_form});'

translations:

'True': 'true'

'False': 'false'

taps,

${nthreads});

this->${id}.declare_sample_delay(${samp_delay});

callbacks:

- set_taps(taps)

- set_nthreads(${nthreads})

std::vector<float> taps = {${str(taps)[1:-1]}};

this->${id} = filter::fft_filter_${type}::make(

taps);

file_format: 1

make: |-

this->${id} = filter::filterbank_vcvcf::make(

${taps});

callbacks:

- set_taps(${taps})

${decim},

taps);

this->${id}.declare_sample_delay(${samp_delay});

callbacks:

- set_taps(taps)

${width},

${win},

${beta}));

callbacks:

- set_taps(firdes::high_pass(${gain}, ${samp_rate}, ${cutoff_freq}, ${width}, ${win},

${beta}))

${num_taps},

${win},

${beta});

file_format: 1

fftaps,

fbtaps,

${oldstyle});

callbacks:

- set_taps(fftaps, fbtaps)

translations:

std::vector<int> taps = {${str(taps)[1:-1]}};

% endif

this->${id} = filter::interp_fir_filter_${type}::make(${interp}, taps);

callbacks:

- set_taps(${taps})

${width},

${win.replace('firdes.', 'gr::filter::firdes::')},

${beta}));

callbacks:

- set_taps(gr::filter::firdes::low_pass(${gain}, ${samp_rate}, ${cutoff_freq}, ${width}, ${win.replace('firdes.', 'gr::filter::firdes::')},

${beta}))

this->${id} = filter::mmse_resampler_${type.fcn}::make(

${phase_shift},

${resamp_ratio});

callbacks:

- set_resamp_ratio(${resamp_ratio})

taps,

${nfilts});

this->${id}->declare_sample_delay(${samp_delay});

callbacks:

- set_taps(taps)

- set_rate(${rrate})

${atten});

this->${id}.set_channel_map(${ch_map});

this->${id}.declare_sample_delay(${samp_delay});

callbacks:

- set_taps(taps)

- set_channel_map(${ch_map})

${fft_rot},

${fft_filts});

this->${id}.declare_sample_delay(${samp_delay});

callbacks:

- set_taps(taps)

- set_channel(int(${channel}))

taps,

${atten});

this->${id}.declare_sample_delay(${samp_delay});

callbacks:

- set_taps(taps)

${twox});

this->${id}->set_channel_map(ch_map);

this->${id}->declare_sample_delay(${samp_delay});

callbacks:

- set_taps(taps)

- set_channel_map(ch_map)

${decim},

taps,

${fbw});

callbacks:

- set_taps(${taps})

${sym_rate},

${alpha},

${ntaps}));

callbacks:

- set_taps(firdes::root_raised_cosine(${gain}, ${samp_rate}, ${sym_rate}, ${alpha},

${ntaps}))

includes: ['#include <gnuradio/filter/single_pole_iir_filter_${type.fcn}.h>']

declarations: 'filter::single_pole_iir_filter_${type.fcn}::sptr ${id};'

make: 'this->${id} = filter::single_pole_iir_filter_${type.fcn}::make(${alpha}, ${vlen});'

callbacks:

- set_taps(${alpha})

var_make: |-

this->${id} = ${id} = firdes.${type}(${gain}, ${samp_rate}, ${low_cutoff_freq}, \

${high_cutoff_freq}, ${width}, ${win}, ${beta});

documentation: |-

This is a convenience wrapper for calling firdes.band_pass() or firdes.complex_band_pass()

var_make: |-

this->${id} = ${id} = firdes.${type}(${gain}, ${samp_rate}, ${low_cutoff_freq},\

${high_cutoff_freq}, ${width}, ${win}, ${beta});

documentation: |-

This is a convenience wrapper for calling firdes.band_reject() or firdes.complex_band_reject().

var_make: |-

this->${id} = ${id} = firdes.high_pass(${gain}, ${samp_rate}, ${cutoff_freq},\

${width}, ${win}, ${beta});

documentation: |-

This variable is a convenience wrapper around a call to firdes.high_pass(...).

var_make: |-

this->${id} = ${id} = firdes.low_pass(${gain}, ${samp_rate}, ${cutoff_freq},\

${width}, ${win}, ${beta});

documentation: |-

This variable is a convenience wrapper around a call to firdes.low_pass(...).

var_make: |-

this->${id} = ${id} = firdes.root_raised_cosine(${gain}, ${samp_rate},\

${sym_rate}, ${alpha}, ${ntaps});

documentation: |-

This is a convenience wrapper for calling firdes.root_raised_cosine(...).

- set_${id}(${value})

- QMetaObject::invokeMethod(this->_${id}_line_edit, "setText", Q_ARG(QString,

QString::number(${id})))

make: |-

this->_${id}_tool_bar = new QToolBar();

this->_${id}_label = new QLabel(QString::fromStdString(std::string("${label.strip("'")}")+ std::string(":")));

- set_update_time(${update_time})

- set_y_axis(${ymin}, ${ymax})

- this->${id}.set_trigger_mode(${tr_mode}, ${tr_level}, ${tr_chan}, ${tr_tag})

make: |-

this->${id} = qtgui::${type.fcn}::make(

${fftsize}, // size

firdes.: 'filter::firdes::'

'True': 'true'

'False': 'false'

documentation: |-

The GUI hint can be used to position the widget within the application. The hint is of the form [tab_id@tab_index]: [row, col, row_span, col_span]. Both the tab specification and the grid position are optional.

## Attempt to replicate logic of Python gui_hint() method

this->top_grid_layout->addWidget(${id + '->qwidget()' + (', ' + str(gui_hint)[1:-1] if len(gui_hint) > 2 else '')});

translations:

'True': 'true'

'False': 'false'

callbacks:

- set_frequency_range(${fc}, ${bw})

- set_update_time(${update_time})

make: |-

this->${id} = qtgui::${type.fcn}::make(

${fftsize}, // size

declarations: 'video_sdl::sink_${type.fcn}::sptr ${id};'

make: 'this->${id} = video_sdl::sink_${type.fcn}::make(${fps}, ${width}, ${height}, 0, ${display_width},

${display_height});'

documentation: |-

Provides a rudimentary on-screen video display using libsdl.

includes: [ '#include <gnuradio/zeromq/pub_msg_sink.h>' ]

declarations: gr::zeromq::pub_msg_sink::sptr ${id};

make: this->${id} = gr::zeromq::pub_msg_sink::make(const_cast<char *>(${address}${'.c_str())' if str(address)[0] not in '"\'' else ')'}, ${timeout});

file_format: 1

${timeout},

${pass_tags},

${hwm});

translations:

'True': 'true'

'False': 'false'

includes: [ '#include <gnuradio/zeromq/pull_msg_source.h>' ]

declarations: gr::zeromq::pull_msg_source::sptr ${id};

make: this->${id} = gr::zeromq::pull_msg_source::make(const_cast<char *>(${address}${'.c_str())' if str(address)[0] not in '"\'' else ')'}, ${timeout});

file_format: 1

${timeout},

${pass_tags},

${hwm});

translations:

'True': 'true'

'False': 'false'

includes: [ '#include <gnuradio/zeromq/push_msg_sink.h>' ]

declarations: gr::zeromq::push_msg_sink::sptr ${id};

make: this->${id} = gr::zeromq::push_msg_sink::make(const_cast<char *>(${address}${'.c_str())' if str(address)[0] not in '"\'' else ')'}, ${timeout});

file_format: 1

${timeout},

${pass_tags},

${hwm});

translations:

'True': 'true'

'False': 'false'

includes: [ '#include <gnuradio/zeromq/rep_msg_sink.h>' ]

declarations: gr::zeromq::rep_msg_sink::sptr ${id};

make: this->${id} = gr::zeromq::rep_msg_sink::make(const_cast<char *>(${address}${'.c_str())' if str(address)[0] not in '"\'' else ')'}, ${timeout});

file_format: 1

${timeout},

${pass_tags},

${hwm});

translations:

'True': 'true'

'False': 'false'

includes: [ '#include <gnuradio/zeromq/req_msg_source.h>' ]

declarations: gr::zeromq::req_msg_source::sptr ${id};

make: this->${id} = gr::zeromq::req_msg_source::make(const_cast<char *>(${address}${'.c_str())' if str(address)[0] not in '"\'' else ')'}, ${timeout});

file_format: 1

${timeout},

${pass_tags},

${hwm});

translations:

'True': 'true'

'False': 'false'

includes: [ '#include <gnuradio/zeromq/sub_msg_source.h>' ]

declarations: gr::zeromq::sub_msg_source::sptr ${id};

make: this->${id} = gr::zeromq::sub_msg_source::make(const_cast<char *>(${address}${'.c_str())' if str(address)[0] not in '"\'' else ')'}, ${timeout});

file_format: 1

${pass_tags},

${hwm},

${key});

translations:

'True': 'true'

'False': 'false'