gnuradio.gr

class gnuradio.gr.top_block(name='top_block')

Top-level hierarchical block representing a flow-graph.

This is a python wrapper around the C++ implementation to allow python subclassing.

class gnuradio.gr.basic_block(name, in_sig, out_sig)

class gnuradio.gr.block(*args, **kwargs)

Proxy of C++ gr::block class

class gnuradio.gr.sync_block(name, in_sig, out_sig)

class gnuradio.gr.sync_decimator(*args, **kwargs)

Proxy of C++ gr::sync_decimator class

class gnuradio.gr.sync_interpolator(*args, **kwargs)

Proxy of C++ gr::sync_interpolator class

class gnuradio.gr.tagged_stream_block(*args, **kwargs)

Proxy of C++ gr::tagged_stream_block class

class gnuradio.gr.hier_block2(name, input_signature, output_signature)

Subclass this to create a python hierarchical block.

This is a python wrapper around the C++ hierarchical block implementation. Provides convenience functions and allows proper Python subclassing.

gnuradio.gr.high_res_timer_now() → gr::high_res_timer_type

gnuradio.gr.high_res_timer_now_perfmon() → gr::high_res_timer_type

gnuradio.gr.high_res_timer_epoch() → gr::high_res_timer_type

gnuradio.gr.high_res_timer_tps() → gr::high_res_timer_type

gnuradio.gr.io_signature

alias of make

gnuradio.gr.io_signature2

alias of make2

gnuradio.gr.io_signature3

alias of make3

gnuradio.gr.io_signaturev

alias of makev

gnuradio.gr.prefix() → std::string const

gnuradio.gr.prefsdir() → std::string const

gnuradio.gr.sysconfdir() → std::string const

gnuradio.gr.version() → std::string const

gnuradio.gr.major_version() → std::string const

gnuradio.gr.api_version() → std::string const

gnuradio.gr.minor_version() → std::string const

gnuradio.gr.prefs

alias of singleton

class gnuradio.gr.logger(gr::logger self, std::string logger_name)

Proxy of C++ gr::logger class

gnuradio.gr.logger_config(std::string const config_filename, unsigned int watch_period=0)

gnuradio.gr.logger_get_names() → std::vector< std::string,std::allocator< std::string > >

gnuradio.gr.logger_reset_config()

class gnuradio.gr.tag_t(gr::tag_t self)

Proxy of C++ gr::tag_t class

gnuradio.gr.tag_t_offset_compare(tag_t x, tag_t y) → bool

gnuradio.gr.tag_t_offset_compare_key()

Convert a tag_t_offset_compare function into a key=function This method is modeled after functools.cmp_to_key(_func_). It can be used by functions that accept a key function, such as sorted(), min(), max(), etc. to compare tags by their offsets, e.g., sorted(tag_list, key=gr.tag_t_offset_compare_key()).

gnuradio.gr.tag_to_pmt(tag)

Convert a Python-readable object to a stream tag

gnuradio.gr.tag_to_python(tag)

Convert a stream tag to a Python-readable object

gnuradio.gr.tag_utils

alias of gnuradio.gr.tag_utils

gnuradio.gr.sizeof_gr_complex

gnuradio.gr.sizeof_float

gnuradio.gr.sizeof_int

gnuradio.gr.sizeof_short

gnuradio.gr.sizeof_char

gnuradio.gr.sizeof_double

gnuradio.gr.branchless_binary_slicer(float x) → unsigned int

gnuradio.gr.binary_slicer(float x) → unsigned int

gnuradio.gr.branchless_clip(float x, float clip) → float

gnuradio.gr.clip(float x, float clip) → float

gnuradio.gr.branchless_quad_0deg_slicer(float r, float i) → unsigned int

branchless_quad_0deg_slicer(gr_complex x) -> unsigned int

gnuradio.gr.quad_0deg_slicer(float r, float i) → unsigned int

quad_0deg_slicer(gr_complex x) -> unsigned int

gnuradio.gr.branchless_quad_45deg_slicer(float r, float i) → unsigned int

branchless_quad_45deg_slicer(gr_complex x) -> unsigned int

gnuradio.gr.quad_45deg_slicer(float r, float i) → unsigned int

quad_45deg_slicer(gr_complex x) -> unsigned int

class gnuradio.gr.feval(gr::py_feval self)

Proxy of C++ gr::py_feval class

class gnuradio.gr.feval_cc(gr::py_feval_cc self)

Proxy of C++ gr::py_feval_cc class

class gnuradio.gr.feval_dd(gr::py_feval_dd self)

Proxy of C++ gr::py_feval_dd class

class gnuradio.gr.feval_ll(gr::py_feval_ll self)

Proxy of C++ gr::py_feval_ll class

class gnuradio.gr.feval_p(gr::py_feval_p self)

Proxy of C++ gr::py_feval_p class

gnuradio.gr.gateway

alias of gnuradio.gr.gateway