gnuradio.digital: Signal Processing Blocks

gnuradio.digital.fll_band_edge_cc(float samps_per_sym, float rolloff, int filter_size, float bandwidth) → sptr

fll_band_edge_cc_sptr.active_thread_priority(self) → int

fll_band_edge_cc_sptr.advance_loop(self, float error)

fll_band_edge_cc_sptr.filter_size(self) → int

fll_band_edge_cc_sptr.frequency_limit(self)

fll_band_edge_cc_sptr.get_alpha(self) → float

fll_band_edge_cc_sptr.get_beta(self) → float

fll_band_edge_cc_sptr.get_damping_factor(self) → float

fll_band_edge_cc_sptr.get_frequency(self) → float

fll_band_edge_cc_sptr.get_loop_bandwidth(self) → float

fll_band_edge_cc_sptr.get_max_freq(self) → float

fll_band_edge_cc_sptr.get_min_freq(self) → float

fll_band_edge_cc_sptr.get_phase(self) → float

fll_band_edge_cc_sptr.phase_wrap(self)

fll_band_edge_cc_sptr.print_taps(self)

fll_band_edge_cc_sptr.rolloff(self) → float

fll_band_edge_cc_sptr.samples_per_symbol(self) → float

fll_band_edge_cc_sptr.set_alpha(self, float alpha)

fll_band_edge_cc_sptr.set_beta(self, float beta)

fll_band_edge_cc_sptr.set_damping_factor(self, float df)

fll_band_edge_cc_sptr.set_filter_size(self, int filter_size)

fll_band_edge_cc_sptr.set_frequency(self, float freq)

fll_band_edge_cc_sptr.set_loop_bandwidth(self, float bw)

fll_band_edge_cc_sptr.set_max_freq(self, float freq)

fll_band_edge_cc_sptr.set_min_freq(self, float freq)

fll_band_edge_cc_sptr.set_phase(self, float phase)

fll_band_edge_cc_sptr.set_rolloff(self, float rolloff)

fll_band_edge_cc_sptr.set_samples_per_symbol(self, float sps)

fll_band_edge_cc_sptr.set_thread_priority(self, int priority) → int

fll_band_edge_cc_sptr.thread_priority(self) → int

fll_band_edge_cc_sptr.update_gains(self)

gnuradio.digital.kurtotic_equalizer_cc(int num_taps, float mu) → sptr

kurtotic_equalizer_cc_sptr.active_thread_priority(self) → int

kurtotic_equalizer_cc_sptr.gain(self) → float

kurtotic_equalizer_cc_sptr.set_gain(self, float mu)

kurtotic_equalizer_cc_sptr.set_thread_priority(self, int priority) → int

kurtotic_equalizer_cc_sptr.thread_priority(self) → int

gnuradio.digital.lms_dd_equalizer_cc(int num_taps, float mu, int sps, constellation_sptr cnst) → sptr

lms_dd_equalizer_cc_sptr.active_thread_priority(self) → int

lms_dd_equalizer_cc_sptr.gain(self) → float

lms_dd_equalizer_cc_sptr.set_gain(self, float mu)

lms_dd_equalizer_cc_sptr.set_taps(self, std::vector<(gr_complex, std::allocator<(gr_complex)>)> taps)

lms_dd_equalizer_cc_sptr.set_thread_priority(self, int priority) → int

lms_dd_equalizer_cc_sptr.taps(self) → std::vector<(gr_complex,std::allocator<(gr_complex)>)>

lms_dd_equalizer_cc_sptr.thread_priority(self) → int

gnuradio.digital.mpsk_receiver_cc(unsigned int M, float theta, float loop_bw, float fmin, float fmax, float mu, float gain_mu, float omega, float gain_omega, float omega_rel) → sptr

mpsk_receiver_cc_sptr.active_thread_priority(self) → int

mpsk_receiver_cc_sptr.gain_mu(self) → float

mpsk_receiver_cc_sptr.gain_omega(self) → float

mpsk_receiver_cc_sptr.gain_omega_rel(self) → float

mpsk_receiver_cc_sptr.modulation_order(self) → float

mpsk_receiver_cc_sptr.mu(self) → float

mpsk_receiver_cc_sptr.omega(self) → float

mpsk_receiver_cc_sptr.set_gain_mu(self, float gain_mu)

mpsk_receiver_cc_sptr.set_gain_omega(self, float gain_omega)

mpsk_receiver_cc_sptr.set_gain_omega_rel(self, float omega_rel)

mpsk_receiver_cc_sptr.set_modulation_order(self, unsigned int M)

mpsk_receiver_cc_sptr.set_mu(self, float mu)

mpsk_receiver_cc_sptr.set_omega(self, float omega)

mpsk_receiver_cc_sptr.set_theta(self, float theta)

mpsk_receiver_cc_sptr.set_thread_priority(self, int priority) → int

mpsk_receiver_cc_sptr.theta(self) → float

mpsk_receiver_cc_sptr.thread_priority(self) → int

gnuradio.digital.mpsk_snr_est_cc(snr_est_type_t type, int tag_nsamples = 10000, double alpha = 0.001) → sptr

mpsk_snr_est_cc_sptr.active_thread_priority(self) → int

mpsk_snr_est_cc_sptr.alpha(self) → double

mpsk_snr_est_cc_sptr.set_alpha(self, double alpha)

mpsk_snr_est_cc_sptr.set_tag_nsample(self, int n)

mpsk_snr_est_cc_sptr.set_thread_priority(self, int priority) → int

mpsk_snr_est_cc_sptr.set_type(self, snr_est_type_t t)

mpsk_snr_est_cc_sptr.snr(self) → double

mpsk_snr_est_cc_sptr.tag_nsample(self) → int

mpsk_snr_est_cc_sptr.thread_priority(self) → int

gnuradio.digital.clock_recovery_mm_cc(float omega, float gain_omega, float mu, float gain_mu, float omega_relative_limit) → sptr

clock_recovery_mm_cc_sptr.active_thread_priority(self) → int

clock_recovery_mm_cc_sptr.gain_mu(self) → float

clock_recovery_mm_cc_sptr.gain_omega(self) → float

clock_recovery_mm_cc_sptr.mu(self) → float

clock_recovery_mm_cc_sptr.omega(self) → float

clock_recovery_mm_cc_sptr.set_gain_mu(self, float gain_mu)

clock_recovery_mm_cc_sptr.set_gain_omega(self, float gain_omega)

clock_recovery_mm_cc_sptr.set_mu(self, float mu)

clock_recovery_mm_cc_sptr.set_omega(self, float omega)

clock_recovery_mm_cc_sptr.set_thread_priority(self, int priority) → int

clock_recovery_mm_cc_sptr.set_verbose(self, bool verbose)

clock_recovery_mm_cc_sptr.thread_priority(self) → int

gnuradio.digital.clock_recovery_mm_ff(float omega, float gain_omega, float mu, float gain_mu, float omega_relative_limit) → sptr

clock_recovery_mm_ff_sptr.active_thread_priority(self) → int

clock_recovery_mm_ff_sptr.gain_mu(self) → float

clock_recovery_mm_ff_sptr.gain_omega(self) → float

clock_recovery_mm_ff_sptr.mu(self) → float

clock_recovery_mm_ff_sptr.omega(self) → float

clock_recovery_mm_ff_sptr.set_gain_mu(self, float gain_mu)

clock_recovery_mm_ff_sptr.set_gain_omega(self, float gain_omega)

clock_recovery_mm_ff_sptr.set_mu(self, float mu)

clock_recovery_mm_ff_sptr.set_omega(self, float omega)

clock_recovery_mm_ff_sptr.set_thread_priority(self, int priority) → int

clock_recovery_mm_ff_sptr.set_verbose(self, bool verbose)

clock_recovery_mm_ff_sptr.thread_priority(self) → int

gnuradio.digital.constellation_decoder_cb(constellation_sptr constellation) → sptr

constellation_decoder_cb_sptr.active_thread_priority(self) → int

constellation_decoder_cb_sptr.set_thread_priority(self, int priority) → int

constellation_decoder_cb_sptr.thread_priority(self) → int

gnuradio.digital.constellation_receiver_cb(constellation_sptr constellation, float loop_bw, float fmin, float fmax) → sptr

constellation_receiver_cb_sptr.active_thread_priority(self) → int

constellation_receiver_cb_sptr.phase_error_tracking(self, float phase_error)

constellation_receiver_cb_sptr.set_thread_priority(self, int priority) → int

constellation_receiver_cb_sptr.thread_priority(self) → int

gnuradio.digital.correlate_access_code_bb(string access_code, int threshold) → sptr

correlate_access_code_bb_sptr.active_thread_priority(self) → int

correlate_access_code_bb_sptr.set_access_code(self, string access_code) → bool

correlate_access_code_bb_sptr.set_thread_priority(self, int priority) → int

correlate_access_code_bb_sptr.thread_priority(self) → int

gnuradio.digital.costas_loop_cc(float loop_bw, int order) → sptr

costas_loop_cc_sptr.active_thread_priority(self) → int

costas_loop_cc_sptr.advance_loop(self, float error)

costas_loop_cc_sptr.frequency_limit(self)

costas_loop_cc_sptr.get_alpha(self) → float

costas_loop_cc_sptr.get_beta(self) → float

costas_loop_cc_sptr.get_damping_factor(self) → float

costas_loop_cc_sptr.get_frequency(self) → float

costas_loop_cc_sptr.get_loop_bandwidth(self) → float

costas_loop_cc_sptr.get_max_freq(self) → float

costas_loop_cc_sptr.get_min_freq(self) → float

costas_loop_cc_sptr.get_phase(self) → float

costas_loop_cc_sptr.phase_wrap(self)

costas_loop_cc_sptr.set_alpha(self, float alpha)

costas_loop_cc_sptr.set_beta(self, float beta)

costas_loop_cc_sptr.set_damping_factor(self, float df)

costas_loop_cc_sptr.set_frequency(self, float freq)

costas_loop_cc_sptr.set_loop_bandwidth(self, float bw)

costas_loop_cc_sptr.set_max_freq(self, float freq)

costas_loop_cc_sptr.set_min_freq(self, float freq)

costas_loop_cc_sptr.set_phase(self, float phase)

costas_loop_cc_sptr.set_thread_priority(self, int priority) → int

costas_loop_cc_sptr.thread_priority(self) → int

costas_loop_cc_sptr.update_gains(self)

gnuradio.digital.cma_equalizer_cc(int num_taps, float modulus, float mu, int sps) → sptr

cma_equalizer_cc_sptr.active_thread_priority(self) → int

cma_equalizer_cc_sptr.gain(self) → float

cma_equalizer_cc_sptr.modulus(self) → float

cma_equalizer_cc_sptr.set_gain(self, float mu)

cma_equalizer_cc_sptr.set_modulus(self, float mod)

cma_equalizer_cc_sptr.set_taps(self, std::vector<(gr_complex, std::allocator<(gr_complex)>)> taps)

cma_equalizer_cc_sptr.set_thread_priority(self, int priority) → int

cma_equalizer_cc_sptr.taps(self) → std::vector<(gr_complex,std::allocator<(gr_complex)>)>

cma_equalizer_cc_sptr.thread_priority(self) → int

gnuradio.digital.binary_slicer_fb() → sptr

binary_slicer_fb_sptr.active_thread_priority(self) → int

binary_slicer_fb_sptr.set_thread_priority(self, int priority) → int

binary_slicer_fb_sptr.thread_priority(self) → int

gnuradio.digital.gmskmod_bc(int samples_per_sym = 2, int L = 4, double beta = 0.3) → sptr

gmskmod_bc_sptr.beta(self) → double

gmskmod_bc_sptr.make_gmskmod_bc(self, int samples_per_sym = 2, int L = 4, double beta = 0.3) → sptr

gmskmod_bc_sptr.samples_per_sym(self) → int

gmskmod_bc_sptr.taps(self) → pmt_vector_float

gnuradio.digital.probe_mpsk_snr_est_c(snr_est_type_t type, int msg_nsamples = 10000, double alpha = 0.001) → sptr

probe_mpsk_snr_est_c_sptr.active_thread_priority(self) → int

probe_mpsk_snr_est_c_sptr.alpha(self) → double

probe_mpsk_snr_est_c_sptr.msg_nsample(self) → int

probe_mpsk_snr_est_c_sptr.set_alpha(self, double alpha)

probe_mpsk_snr_est_c_sptr.set_msg_nsample(self, int n)

probe_mpsk_snr_est_c_sptr.set_thread_priority(self, int priority) → int

probe_mpsk_snr_est_c_sptr.set_type(self, snr_est_type_t t)

probe_mpsk_snr_est_c_sptr.snr(self) → double

probe_mpsk_snr_est_c_sptr.thread_priority(self) → int

gnuradio.digital.cpmmod_bc(cpm_type type, float h, int samples_per_sym, int L, double beta = 0.3) → sptr

cpmmod_bc_sptr.beta(self) → double

cpmmod_bc_sptr.make_gmskmod_bc(self, int samples_per_sym = 2, int L = 4, double beta = 0.3) → sptr

cpmmod_bc_sptr.samples_per_sym(self) → int

cpmmod_bc_sptr.taps(self) → pmt_vector_float

gnuradio.digital.glfsr_source_b(int degree, bool repeat = True, int mask = 0, int seed = 1) → sptr

glfsr_source_b_sptr.active_thread_priority(self) → int

glfsr_source_b_sptr.mask(self) → int

glfsr_source_b_sptr.period(self) → unsigned int

glfsr_source_b_sptr.set_thread_priority(self, int priority) → int

glfsr_source_b_sptr.thread_priority(self) → int

gnuradio.digital.glfsr_source_f(int degree, bool repeat = True, int mask = 0, int seed = 1) → sptr

glfsr_source_f_sptr.active_thread_priority(self) → int

glfsr_source_f_sptr.mask(self) → int

glfsr_source_f_sptr.period(self) → unsigned int

glfsr_source_f_sptr.set_thread_priority(self, int priority) → int

glfsr_source_f_sptr.thread_priority(self) → int

gnuradio.digital.framer_sink_1(sptr target_queue) → sptr

framer_sink_1_sptr.active_thread_priority(self) → int

framer_sink_1_sptr.set_thread_priority(self, int priority) → int

framer_sink_1_sptr.thread_priority(self) → int

gnuradio.digital.framer_sink_1(sptr target_queue) → sptr

framer_sink_1_sptr.active_thread_priority(self) → int

framer_sink_1_sptr.set_thread_priority(self, int priority) → int

framer_sink_1_sptr.thread_priority(self) → int

gnuradio.digital.additive_scrambler_bb(int mask, int seed, int len, int count = 0) → sptr

additive_scrambler_bb_sptr.active_thread_priority(self) → int

additive_scrambler_bb_sptr.count(self) → int

additive_scrambler_bb_sptr.len(self) → int

additive_scrambler_bb_sptr.mask(self) → int

additive_scrambler_bb_sptr.seed(self) → int

additive_scrambler_bb_sptr.set_thread_priority(self, int priority) → int

additive_scrambler_bb_sptr.thread_priority(self) → int

gnuradio.digital.descrambler_bb(int mask, int seed, int len) → sptr

descrambler_bb_sptr.active_thread_priority(self) → int

descrambler_bb_sptr.set_thread_priority(self, int priority) → int

descrambler_bb_sptr.thread_priority(self) → int

gnuradio.digital.diff_decoder_bb(unsigned int modulus) → sptr

diff_decoder_bb_sptr.active_thread_priority(self) → int

diff_decoder_bb_sptr.set_thread_priority(self, int priority) → int

diff_decoder_bb_sptr.thread_priority(self) → int

gnuradio.digital.diff_encoder_bb(unsigned int modulus) → sptr

diff_encoder_bb_sptr.active_thread_priority(self) → int

diff_encoder_bb_sptr.set_thread_priority(self, int priority) → int

diff_encoder_bb_sptr.thread_priority(self) → int

gnuradio.digital.map_bb(__dummy_5__ map) → sptr

map_bb_sptr.active_thread_priority(self) → int

map_bb_sptr.map(self) → __dummy_5__

map_bb_sptr.set_map(self, __dummy_5__ map)

map_bb_sptr.set_thread_priority(self, int priority) → int

map_bb_sptr.thread_priority(self) → int

gnuradio.digital.scrambler_bb(int mask, int seed, int len) → sptr

scrambler_bb_sptr.active_thread_priority(self) → int

scrambler_bb_sptr.set_thread_priority(self, int priority) → int

scrambler_bb_sptr.thread_priority(self) → int

gnuradio.digital.pn_correlator_cc(int degree, int mask = 0, int seed = 1) → sptr

pn_correlator_cc_sptr.active_thread_priority(self) → int

pn_correlator_cc_sptr.set_thread_priority(self, int priority) → int

pn_correlator_cc_sptr.thread_priority(self) → int

gnuradio.digital.simple_framer(int payload_bytesize) → sptr

simple_framer_sptr.active_thread_priority(self) → int

simple_framer_sptr.set_thread_priority(self, int priority) → int

simple_framer_sptr.thread_priority(self) → int

gnuradio.digital.chunks_to_symbols_bc(std::vector<(gr_complex, std::allocator<(gr_complex)>)> symbol_table, int D = 1) → sptr

chunks_to_symbols_bc_sptr.D(self) → int

chunks_to_symbols_bc_sptr.active_thread_priority(self) → int

chunks_to_symbols_bc_sptr.set_thread_priority(self, int priority) → int

chunks_to_symbols_bc_sptr.symbol_table(self) → std::vector<(gr_complex,std::allocator<(gr_complex)>)>

chunks_to_symbols_bc_sptr.thread_priority(self) → int

gnuradio.digital.chunks_to_symbols_bf(pmt_vector_float symbol_table, int D = 1) → sptr

chunks_to_symbols_bf_sptr.D(self) → int

chunks_to_symbols_bf_sptr.active_thread_priority(self) → int

chunks_to_symbols_bf_sptr.set_thread_priority(self, int priority) → int

chunks_to_symbols_bf_sptr.symbol_table(self) → pmt_vector_float

chunks_to_symbols_bf_sptr.thread_priority(self) → int

gnuradio.digital.chunks_to_symbols_ic(std::vector<(gr_complex, std::allocator<(gr_complex)>)> symbol_table, int D = 1) → sptr

chunks_to_symbols_ic_sptr.D(self) → int

chunks_to_symbols_ic_sptr.active_thread_priority(self) → int

chunks_to_symbols_ic_sptr.set_thread_priority(self, int priority) → int

chunks_to_symbols_ic_sptr.symbol_table(self) → std::vector<(gr_complex,std::allocator<(gr_complex)>)>

chunks_to_symbols_ic_sptr.thread_priority(self) → int

gnuradio.digital.chunks_to_symbols_if(pmt_vector_float symbol_table, int D = 1) → sptr

chunks_to_symbols_if_sptr.D(self) → int

chunks_to_symbols_if_sptr.active_thread_priority(self) → int

chunks_to_symbols_if_sptr.set_thread_priority(self, int priority) → int

chunks_to_symbols_if_sptr.symbol_table(self) → pmt_vector_float

chunks_to_symbols_if_sptr.thread_priority(self) → int

gnuradio.digital.chunks_to_symbols_sc(std::vector<(gr_complex, std::allocator<(gr_complex)>)> symbol_table, int D = 1) → sptr

chunks_to_symbols_sc_sptr.D(self) → int

chunks_to_symbols_sc_sptr.active_thread_priority(self) → int

chunks_to_symbols_sc_sptr.set_thread_priority(self, int priority) → int

chunks_to_symbols_sc_sptr.symbol_table(self) → std::vector<(gr_complex,std::allocator<(gr_complex)>)>

chunks_to_symbols_sc_sptr.thread_priority(self) → int

gnuradio.digital.chunks_to_symbols_sf(pmt_vector_float symbol_table, int D = 1) → sptr

chunks_to_symbols_sf_sptr.D(self) → int

chunks_to_symbols_sf_sptr.active_thread_priority(self) → int

chunks_to_symbols_sf_sptr.set_thread_priority(self, int priority) → int

chunks_to_symbols_sf_sptr.symbol_table(self) → pmt_vector_float

chunks_to_symbols_sf_sptr.thread_priority(self) → int

class gnuradio.digital.generic_demod(constellation, differential=False, samples_per_symbol=2, pre_diff_code=True, excess_bw=0.35, freq_bw=0.06283185307179587, timing_bw=0.06283185307179587, phase_bw=0.06283185307179587, verbose=False, log=False)

Hierarchical block for RRC-filtered differential generic demodulation.

The input is the complex modulated signal at baseband. The output is a stream of bits packed 1 bit per byte (LSB)

Parameters:

• constellation – determines the modulation type (gnuradio.digital.digital_constellation)
• samples_per_symbol – samples per baud >= 2 (float)
• differential – whether to use differential encoding (boolean)
• pre_diff_code – whether to use apply a pre-differential mapping (boolean)
• excess_bw – Root-raised cosine filter excess bandwidth (float)
• freq_bw – loop filter lock-in bandwidth (float)
• timing_bw – timing recovery loop lock-in bandwidth (float)
• phase_bw – phase recovery loop bandwidth (float)
• verbose – Print information about modulator? (boolean)
• log – Log modulation data to files? (boolean)

static add_options(parser)

Adds generic demodulation options to the standard parser

classmethod extract_kwargs_from_options(options)

Given command line options, create dictionary suitable for passing to __init__

class gnuradio.digital.generic_mod(constellation, differential=False, samples_per_symbol=2, pre_diff_code=True, excess_bw=0.35, verbose=False, log=False)

Hierarchical block for RRC-filtered differential generic modulation.

The input is a byte stream (unsigned char) and the output is the complex modulated signal at baseband.

Parameters:

• constellation – determines the modulation type (gnuradio.digital.digital_constellation)
• samples_per_symbol – samples per baud >= 2 (float)
• differential – whether to use differential encoding (boolean)
• pre_diff_code – whether to use apply a pre-differential mapping (boolean)
• excess_bw – Root-raised cosine filter excess bandwidth (float)
• verbose – Print information about modulator? (boolean)
• log – Log modulation data to files? (boolean)

static add_options(parser)

Adds generic modulation options to the standard parser

classmethod extract_kwargs_from_options(options)

Given command line options, create dictionary suitable for passing to __init__

class gnuradio.digital.bpsk.dbpsk_demod(mod_code=None, *args, **kwargs)

Hierarchical block for RRC-filtered DBPSK modulation.

The input is a byte stream (unsigned char) and the output is the complex modulated signal at baseband.

Parameters:

• mod_code – Argument is not used. It exists purely to simplify generation of the block in grc.
• samples_per_symbol – samples per baud >= 2 (float)
• excess_bw – Root-raised cosine filter excess bandwidth (float)
• freq_bw – loop filter lock-in bandwidth (float)
• timing_bw – timing recovery loop lock-in bandwidth (float)
• phase_bw – phase recovery loop bandwidth (float)
• verbose – Print information about modulator? (boolean)
• log – Log modulation data to files? (boolean)

class gnuradio.digital.bpsk.dbpsk_mod(mod_code=None, *args, **kwargs)

Hierarchical block for RRC-filtered DBPSK modulation.

The input is a byte stream (unsigned char) and the output is the complex modulated signal at baseband.

Parameters:

• mod_code – Argument is not used. It exists purely to simplify generation of the block in grc.
• samples_per_symbol – samples per baud >= 2 (float)
• excess_bw – Root-raised cosine filter excess bandwidth (float)
• verbose – Print information about modulator? (boolean)
• log – Log modulation data to files? (boolean)

class gnuradio.digital.qpsk.dqpsk_demod(mod_code='gray', *args, **kwargs)

Hierarchical block for RRC-filtered DQPSK modulation.

The input is a byte stream (unsigned char) and the output is the complex modulated signal at baseband.

Parameters:

• mod_code – Whether to use a gray_code (digital.mod_codes.GRAY_CODE) or not (digital.mod_codes.NO_CODE).
• samples_per_symbol – samples per baud >= 2 (float)
• excess_bw – Root-raised cosine filter excess bandwidth (float)
• freq_bw – loop filter lock-in bandwidth (float)
• timing_bw – timing recovery loop lock-in bandwidth (float)
• phase_bw – phase recovery loop bandwidth (float)
• verbose – Print information about modulator? (boolean)
• log – Log modulation data to files? (boolean)

class gnuradio.digital.qpsk.dqpsk_mod(mod_code='gray', *args, **kwargs)

Hierarchical block for RRC-filtered DQPSK modulation.

The input is a byte stream (unsigned char) and the output is the complex modulated signal at baseband.

Parameters:

• mod_code – Whether to use a gray_code (digital.mod_codes.GRAY_CODE) or not (digital.mod_codes.NO_CODE).
• samples_per_symbol – samples per baud >= 2 (float)
• excess_bw – Root-raised cosine filter excess bandwidth (float)
• verbose – Print information about modulator? (boolean)
• log – Log modulation data to files? (boolean)

class gnuradio.digital.gmsk.gmsk_demod(samples_per_symbol=2, gain_mu=None, mu=0.5, omega_relative_limit=0.005, freq_error=0.0, verbose=False, log=False)

Hierarchical block for Gaussian Minimum Shift Key (GMSK) demodulation.

The input is the complex modulated signal at baseband. The output is a stream of bits packed 1 bit per byte (the LSB)

Parameters:

• samples_per_symbol – samples per baud (integer)
• verbose – Print information about modulator? (boolean)
• log – Print modualtion data to files? (boolean)
• gain_mu – controls rate of mu adjustment (float)
• mu – fractional delay [0.0, 1.0] (float)
• omega_relative_limit – sets max variation in omega (float)
• freq_error – bit rate error as a fraction (float)

static add_options(parser)

Adds GMSK demodulation-specific options to the standard parser

static extract_kwargs_from_options(options)

Given command line options, create dictionary suitable for passing to __init__

class gnuradio.digital.gmsk.gmsk_mod(samples_per_symbol=2, bt=0.35, verbose=False, log=False)

Hierarchical block for Gaussian Minimum Shift Key (GMSK) modulation.

The input is a byte stream (unsigned char) and the output is the complex modulated signal at baseband.

Parameters:

• samples_per_symbol – samples per baud >= 2 (integer)
• bt – Gaussian filter bandwidth * symbol time (float)
• verbose – Print information about modulator? (boolean)
• debug – Print modulation data to files? (boolean)

static add_options(parser)

Adds GMSK modulation-specific options to the standard parser

static extract_kwargs_from_options(options)

Given command line options, create dictionary suitable for passing to __init__

class gnuradio.digital.bpsk.bpsk_demod(mod_code=None, differential=False, *args, **kwargs)

Hierarchical block for RRC-filtered BPSK modulation.

The input is a byte stream (unsigned char) and the output is the complex modulated signal at baseband.

Parameters:

• mod_code – Argument is not used. It exists purely to simplify generation of the block in grc.
• differential – whether to use differential encoding (boolean)
• samples_per_symbol – samples per baud >= 2 (float)
• excess_bw – Root-raised cosine filter excess bandwidth (float)
• freq_bw – loop filter lock-in bandwidth (float)
• timing_bw – timing recovery loop lock-in bandwidth (float)
• phase_bw – phase recovery loop bandwidth (float)
• verbose – Print information about modulator? (boolean)
• log – Log modulation data to files? (boolean)

class gnuradio.digital.bpsk.bpsk_mod(mod_code=None, differential=False, *args, **kwargs)

Hierarchical block for RRC-filtered BPSK modulation.

The input is a byte stream (unsigned char) and the output is the complex modulated signal at baseband.

Parameters:

• mod_code – Argument is not used. It exists purely to simplify generation of the block in grc.
• differential – Whether to use differential encoding (boolean).
• samples_per_symbol – samples per baud >= 2 (float)
• excess_bw – Root-raised cosine filter excess bandwidth (float)
• verbose – Print information about modulator? (boolean)
• log – Log modulation data to files? (boolean)

class gnuradio.digital.psk.psk_demod(constellation_points=4, mod_code='gray', differential=True, *args, **kwargs)

Hierarchical block for RRC-filtered PSK modulation.

The input is a byte stream (unsigned char) and the output is the complex modulated signal at baseband.

Parameters:

• constellation_points – Number of constellation points (must be a power of two) (integer).
• mod_code – Whether to use a gray_code (digital.mod_codes.GRAY_CODE) or not (digital.mod_codes.NO_CODE).
• differential – Whether to use differential encoding (boolean).
• samples_per_symbol – samples per baud >= 2 (float)
• excess_bw – Root-raised cosine filter excess bandwidth (float)
• verbose – Print information about modulator? (boolean)
• log – Log modulation data to files? (boolean)

class gnuradio.digital.psk.psk_mod(constellation_points=4, mod_code='gray', differential=True, *args, **kwargs)

Hierarchical block for RRC-filtered PSK modulation.

The input is a byte stream (unsigned char) and the output is the complex modulated signal at baseband.

Parameters:

• constellation_points – Number of constellation points (must be a power of two) (integer).
• mod_code – Whether to use a gray_code (digital.mod_codes.GRAY_CODE) or not (digital.mod_codes.NO_CODE).
• differential – Whether to use differential encoding (boolean).
• samples_per_symbol – samples per baud >= 2 (float)
• excess_bw – Root-raised cosine filter excess bandwidth (float)
• verbose – Print information about modulator? (boolean)
• log – Log modulation data to files? (boolean)

class gnuradio.digital.qam.qam_demod(constellation_points=16, differential=True, mod_code='none', large_ampls_to_corner=False, *args, **kwargs)

Hierarchical block for RRC-filtered QAM modulation.

The input is a byte stream (unsigned char) and the output is the complex modulated signal at baseband.

Parameters:

• constellation_points – Number of constellation points (must be a power of four) (integer).
• mod_code – Whether to use a gray_code (digital.mod_codes.GRAY_CODE) or not (digital.mod_codes.NO_CODE).
• differential – Whether to use differential encoding (boolean).
• samples_per_symbol – samples per baud >= 2 (float)
• excess_bw – Root-raised cosine filter excess bandwidth (float)
• verbose – Print information about modulator? (boolean)
• log – Log modulation data to files? (boolean)

class gnuradio.digital.qam.qam_mod(constellation_points=16, differential=True, mod_code='none', *args, **kwargs)

Hierarchical block for RRC-filtered QAM modulation.

The input is a byte stream (unsigned char) and the output is the complex modulated signal at baseband.

Parameters:

• constellation_points – Number of constellation points (must be a power of four) (integer).
• mod_code – Whether to use a gray_code (digital.mod_codes.GRAY_CODE) or not (digital.mod_codes.NO_CODE).
• differential – Whether to use differential encoding (boolean).
• samples_per_symbol – samples per baud >= 2 (float)
• excess_bw – Root-raised cosine filter excess bandwidth (float)
• verbose – Print information about modulator? (boolean)
• log – Log modulation data to files? (boolean)

class gnuradio.digital.qpsk.qpsk_demod(mod_code='gray', differential=False, *args, **kwargs)

Hierarchical block for RRC-filtered QPSK modulation.

The input is a byte stream (unsigned char) and the output is the complex modulated signal at baseband.

Parameters:

• mod_code – Whether to use a gray_code (digital.mod_codes.GRAY_CODE) or not (digital.mod_codes.NO_CODE).
• differential – Whether to use differential encoding (boolean).
• samples_per_symbol – samples per baud >= 2 (float)
• excess_bw – Root-raised cosine filter excess bandwidth (float)
• freq_bw – loop filter lock-in bandwidth (float)
• timing_bw – timing recovery loop lock-in bandwidth (float)
• phase_bw – phase recovery loop bandwidth (float)
• verbose – Print information about modulator? (boolean)
• log – Log modulation data to files? (boolean)

class gnuradio.digital.qpsk.qpsk_mod(mod_code='gray', differential=False, *args, **kwargs)

Hierarchical block for RRC-filtered QPSK modulation.

The input is a byte stream (unsigned char) and the output is the complex modulated signal at baseband.

Parameters:

• mod_code – Whether to use a gray_code (digital.mod_codes.GRAY_CODE) or not (digital.mod_codes.NO_CODE).
• differential – Whether to use differential encoding (boolean).
• samples_per_symbol – samples per baud >= 2 (float)
• excess_bw – Root-raised cosine filter excess bandwidth (float)
• verbose – Print information about modulator? (boolean)
• log – Log modulation data to files? (boolean)

class gnuradio.digital.cpm.cpm_mod(samples_per_symbol=2, bits_per_symbol=1, h_numerator=1, h_denominator=2, cpm_type=0, bt=0.35, symbols_per_pulse=1, generic_taps=array([ 6.92865263e-310]), verbose=False, log=False)

Hierarchical block for Continuous Phase modulation.

The input is a byte stream (unsigned char) representing packed bits and the output is the complex modulated signal at baseband.

See Proakis for definition of generic CPM signals: s(t)=exp(j phi(t)) phi(t)= 2 pi h int_0^t f(t’) dt’ f(t)=sum_k a_k g(t-kT) (normalizing assumption: int_0^infty g(t) dt = 1/2)

Parameters:

• samples_per_symbol – samples per baud >= 2 (integer)
• bits_per_symbol – bits per symbol (integer)
• h_numerator – numerator of modulation index (integer)
• h_denominator – denominator of modulation index (numerator and denominator must be relative primes) (integer)
• cpm_type – supported types are: 0=CPFSK, 1=GMSK, 2=RC, 3=GENERAL (integer)
• bt – bandwidth symbol time product for GMSK (float)
• symbols_per_pulse – shaping pulse duration in symbols (integer)
• generic_taps – define a generic CPM pulse shape (sum = samples_per_symbol/2) (list/array of floats)
• verbose – Print information about modulator? (boolean)
• debug – Print modulation data to files? (boolean)

static add_options(parser)

Adds CPM modulation-specific options to the standard parser

static extract_kwargs_from_options(options)

Given command line options, create dictionary suitable for passing to __init__

class gnuradio.digital.pkt.mod_pkts(modulator, access_code=None, msgq_limit=2, pad_for_usrp=True, use_whitener_offset=False, modulate=True)

Wrap an arbitrary digital modulator in our packet handling framework.

Send packets by calling send_pkt

send_pkt(payload='', eof=False)

Send the payload.

Parameters:payload – data to send (string)

class gnuradio.digital.pkt.demod_pkts(demodulator, access_code=None, callback=None, threshold=-1)

Wrap an arbitrary digital demodulator in our packet handling framework.

The input is complex baseband. When packets are demodulated, they are passed to the app via the callback.

gnuradio.digital.ofdm_cyclic_prefixer

alias of make

gnuradio.digital.ofdm_frame_acquisition

alias of make

gnuradio.digital.ofdm_frame_sink

alias of make

gnuradio.digital.ofdm_insert_preamble

alias of make

gnuradio.digital.ofdm_mapper_bcv

alias of make

class gnuradio.digital.ofdm_mod(options, msgq_limit=2, pad_for_usrp=True)

Modulates an OFDM stream. Based on the options fft_length, occupied_tones, and cp_length, this block creates OFDM symbols using a specified modulation option.

Send packets by calling send_pkt

static add_options(normal, expert)

Adds OFDM-specific options to the Options Parser

send_pkt(payload='', eof=False)

Send the payload.

Parameters:payload – data to send (string)

class gnuradio.digital.ofdm_demod(options, callback=None)

Demodulates a received OFDM stream. Based on the options fft_length, occupied_tones, and cp_length, this block performs synchronization, FFT, and demodulation of incoming OFDM symbols and passes packets up the a higher layer.

The input is complex baseband. When packets are demodulated, they are passed to the app via the callback.

static add_options(normal, expert)

Adds OFDM-specific options to the Options Parser

class gnuradio.digital.ofdm_receiver(fft_length, cp_length, occupied_tones, snr, ks, logging=False)

Performs receiver synchronization on OFDM symbols.

The receiver performs channel filtering as well as symbol, frequency, and phase synchronization. The synchronization routines are available in three flavors: preamble correlator (Schmidl and Cox), modifid preamble correlator with autocorrelation (not yet working), and cyclic prefix correlator (Van de Beeks).

gnuradio.digital.ofdm_sampler

alias of make

class gnuradio.digital.ofdm_sync_fixed(fft_length, cp_length, nsymbols, freq_offset, logging=False)

class gnuradio.digital.ofdm_sync_ml(fft_length, cp_length, snr, kstime, logging)

class gnuradio.digital.ofdm_sync_pn(fft_length, cp_length, logging=False)

class gnuradio.digital.ofdm_sync_pnac(fft_length, cp_length, kstime, logging=False)