modtool_add.py

modtool_base.py

modtool_disable.py

modtool_info.py

modtool_makexml.py

modtool_newmod.py

templates.py

util_functions.py

DESTINATION ${GR_PYTHON_DIR}/gnuradio/modtool

)

set(GR_PKG_MODTOOL_DATA_DIR ${GR_PKG_DATA_DIR}/modtool)

install(DIRECTORY gr-newmod

DESTINATION ${GR_PKG_MODTOOL_DATA_DIR}

)

install(

FILES ${CMAKE_CURRENT_BINARY_DIR}/modtool.conf

DESTINATION ${GR_PREFSDIR}

)

#

#

# This file is part of GNU Radio

#

#

from cmakefile_editor import CMakeFileEditor

from grc_xml_generator import GRCXMLGenerator

from modtool_add import ModToolAdd

from modtool_disable import ModToolDisable

from modtool_info import ModToolInfo

from modtool_rename import ModToolRename

from templates import Templates

# Leave this at the end

from parser_cc_block import ParserCCBlock

from util_functions import *

#

#

# This file is part of GNU Radio

#

#

""" A code generator (needed by ModToolAdd) """

from templates import Templates

from util_functions import str_to_fancyc_comment

from util_functions import str_to_python_comment

from util_functions import strip_default_values

from util_functions import strip_arg_types

from util_functions import strip_arg_types_grc

# Also handle gnuradio custom naming conventions w/ extras mode.

########################################################################

function(GR_LIBRARY_FOO target)

#set additional target properties

set_target_properties(${target} PROPERTIES SOVERSION ${LIBVER})

#install the generated files like so...

install(TARGETS ${target}

)

#extras mode enabled automatically on linux

FILES

${CMAKE_CURRENT_BINARY_DIR}/lib${target}.so

${CMAKE_CURRENT_BINARY_DIR}/lib${target}-${LIBVER}.so.0

)

endif(LIBRARY_EXTRAS)

endfunction(GR_GEN_TARGET_DEPS)

########################################################################

# Run GRCC to compile .grc files into .py files.

#

# Usage: GRCC(filename, directory)

########################################################################

function(GR_PYTHON_INSTALL)

include(CMakeParseArgumentsCopy)

####################################################################

if(GR_PYTHON_INSTALL_FILES)

set(python_install_gen_targets ${pycfiles} ${pyofiles})

install(FILES ${python_install_gen_targets}

DESTINATION ${GR_PYTHON_INSTALL_DESTINATION}

)

####################################################################

install(PROGRAMS ${pyexefile} RENAME ${pyfile_name}

DESTINATION ${GR_PYTHON_INSTALL_DESTINATION}

)

endforeach(pyfile)

# GR_SWIG_INSTALL(

# TARGETS target target target...

# [DESTINATION destination]

# )

########################################################################

macro(GR_SWIG_INSTALL)

include(CMakeParseArgumentsCopy)

foreach(name ${GR_SWIG_INSTALL_TARGETS})

install(TARGETS ${SWIG_MODULE_${name}_REAL_NAME}

DESTINATION ${GR_SWIG_INSTALL_DESTINATION}

)

include(GrPython)

GR_PYTHON_INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${name}.py

DESTINATION ${GR_SWIG_INSTALL_DESTINATION}

)

GR_LIBTOOL(

# Install built library files

########################################################################

include(GrMiscUtils)

########################################################################

# Build and register unit test

########################################################################

message(STATUS "Using install prefix: ${CMAKE_INSTALL_PREFIX}")

message(STATUS "Building for version: ${VERSION} / ${LIBVER}")

#

#

# This file is part of GNU Radio

#

import os

import re

from util_functions import append_re_line_sequence, ask_yes_no

from cmakefile_editor import CMakeFileEditor

from modtool_base import ModTool, ModToolException

from templates import Templates

class ModToolAdd(ModTool):

""" Add block to the out-of-tree module. """

name = 'add'

_block_types = ('sink', 'source', 'sync', 'decimator', 'interpolator',

'general', 'tagged_stream', 'hier', 'noblock')

self._skip_cmakefiles = False

self._license_file = None

help="File containing the license header for every source code file.")

help="Name of the copyright holder (you or your company) MUST be a quoted string.")

help="The argument list for the constructor and make functions.")

help="If given, Python QA code is automatically added if possible.")

help="If given, C++ QA code is automatically added if possible.")

help="If given, only source files are written, but CMakeLists.txt files are left unchanged.")

return parser

self._info['blocktype'] = options.block_type

if self._info['blocktype'] is None:

# Allow user to specify language interactively if not set

self._info['lang'] = options.lang

if self._info['lang'] is None:

self._info['lang'] = raw_input("Language (python/cpp): ")

if self._info['lang'] == 'c++':

self._info['lang'] = 'cpp'

raise ModToolException('Missing or skipping relevant subdir.')

if self._info['blockname'] is None:

if not re.match('[a-zA-Z0-9_]+', self._info['blockname']):

raise ModToolException('Invalid block name.')

print "Block/code identifier: " + self._info['blockname']

elif self._info['is_component']:

return Templates['grlicense']

else:

def _write_tpl(self, tpl, path, fname):

""" Shorthand for writing a substituted template to a file"""

path_to_file = os.path.join(path, fname)

print "Adding file '%s'..." % path_to_file

self.scm.add_files((path_to_file,))

""" Go, go, go. """

has_swig = (

self._info['lang'] == 'cpp'

and not self._skip_subdirs['swig']

self.scm.mark_files_updated((self._file['qalib'],))

except IOError:

print "Can't add C++ QA files."

fname_cc = None

fname_h = None

if self._info['version'] == '37':

if self._info['version'] == '37':

_add_qa()

elif self._info['version'] == '36':

elif self._info['version'] == 'autofoo':

print "Warning: C++ QA files not supported for autotools."

if not self._skip_cmakefiles:

mod_block_sep = '/'

if self._info['version'] == '36':

mod_block_sep = '_'

open(self._file['swig'], 'a').write(swig_block_magic_str)

include_str = '#include "%s%s%s.h"' % (

{True: 'gnuradio/' + self._info['modname'], False: self._info['modname']}[self._info['is_component']],

import os

import re

from gnuradio import gr

from util_functions import get_modname

class ModTool(object):

""" Base class for all modtool command classes. """

name = 'base'

def __init__(self):

self._subdirs = ['lib', 'include', 'python', 'swig', 'grc'] # List subdirs where stuff happens

self._has_subdirs = {}

for subdir in self._subdirs:

self._has_subdirs[subdir] = False

self._skip_subdirs[subdir] = False

self._dir = None

help="Base directory of the module. Defaults to the cwd.")

help="Don't do anything in the lib/ subdirectory.")

help="Don't do anything in the swig/ subdirectory.")

help="Don't do anything in the python/ subdirectory.")

help="Don't do anything in the grc/ subdirectory.")

default=gr.prefs().get_string('modtool', 'scm_mode', 'no'),

help="Answer all questions with 'yes'. This can overwrite and delete your files, so be careful.")

return parser

""" Initialise all internal variables, such as the module name etc. """

self._dir = options.directory

if not self._check_directory(self._dir):

raise ModToolException('No GNU Radio module found in the given directory.')

self._info['modname'] = options.module_name

else:

self._info['modname'] = get_modname()

self._skip_subdirs['swig'] = True

if options.skip_grc or not self._has_subdirs['grc']:

self._skip_subdirs['grc'] = True

self._setup_files()

self._info['yes'] = options.yes

self.options = options

return fname

return None

""" Override this. """

try:

except (TypeError, AttributeError):

pass

class ModToolDisable(ModTool):

""" Disable block (comments out CMake entries for files) """

name = 'disable'

def __init__(self):

ModTool.__init__(self)

else:

self._info['pattern'] = raw_input('Which blocks do you want to disable? (Regex): ')

if len(self._info['pattern']) == 0:

self._info['pattern'] = '.'

""" Go, go, go! """

def _handle_py_qa(cmake, fname):

""" Do stuff for py qa """

open(self._file['swig'], 'w').write(swigfile)

self.scm.mark_file_updated(self._file['swig'])

return False

# List of special rules: 0: subdir, 1: filename re match, 2: callback

special_treatments = (

('python', 'qa.+py$', _handle_py_qa),

""" Returns information about a module """

import os

from modtool_base import ModTool, ModToolException

from util_functions import get_modname

class ModToolInfo(ModTool):

""" Return information about a given module """

name = 'info'

def __init__(self):

ModTool.__init__(self)

self._python_readable = False

self._suggested_dirs = None

""" Initialise the option parser for 'gr_modtool info' """

help="Return the output in a format that's easier to read for Python scripts.")

help="Suggest typical include dirs if nothing better can be detected.")

return parser

# Won't call parent's setup(), because that's too chatty

self._directory = options.directory

self._python_readable = options.python_readable

self._suggested_dirs = options.suggested_dirs

""" Go, go, go! """

mod_info = dict()

mod_info['base_dir'] = self._get_base_dir(self._directory)

if mod_info['base_dir'] is None:

class ModToolMakeXML(ModTool):

""" Make XML file for GRC block bindings """

name = 'makexml'

def __init__(self):

ModTool.__init__(self)

""" Initialise the option parser for 'gr_modtool makexml' """

Note: This does not work on Python blocks!

else:

self._info['pattern'] = raw_input('Which blocks do you want to parse? (Regex): ')

if len(self._info['pattern']) == 0:

self._info['pattern'] = '.'

""" Go, go, go! """

print "Warning: This is an experimental feature. Don't expect any magic."

# 1) Go through lib/

if not self._skip_subdirs['lib']:

if self._info['version'] == '37':

import shutil

import os

import re

from gnuradio import gr

from modtool_base import ModTool, ModToolException

from scm import SCMRepoFactory

class ModToolNewModule(ModTool):

""" Create a new out-of-tree module """

name = 'newmod'

def __init__(self):

ModTool.__init__(self)

" Initialise the option parser for 'gr_modtool newmod' "

help="Source directory for the module template.")

# Don't call ModTool.setup(), that assumes an existing module.

self._info['modname'] = options.module_name

if self._info['modname'] is None:

else:

self._info['modname'] = raw_input('Name of the new module: ')

if not re.match('[a-zA-Z0-9_]+$', self._info['modname']):

self.options = options

self._setup_scm(mode='new')

"""

* Copy the example dir recursively

* Open all files, rename howto and HOWTO to the module name

* Rename files and directories that contain the word howto

"""

print "Creating out-of-tree module in %s..." % self._dir,

try:

shutil.copytree(self._srcdir, self._dir)

import os

import re

from util_functions import append_re_line_sequence, ask_yes_no

from cmakefile_editor import CMakeFileEditor

from modtool_base import ModTool, ModToolException

from templates import Templates

class ModToolRename(ModTool):

""" Rename a block in the out-of-tree module. """

name = 'rename'

def __init__(self):

ModTool.__init__(self)

self._skip_cmakefiles = False

self._license_file = None

return parser

if ((self._skip_subdirs['lib'] and self._info['lang'] == 'cpp')

or (self._skip_subdirs['python'] and self._info['lang'] == 'python')):

raise ModToolException('Missing or skipping relevant subdir.')

# first make sure the old block name is provided

if self._info['oldname'] is None:

if not re.match('[a-zA-Z0-9_]+', self._info['oldname']):

raise ModToolException('Invalid block name.')

print "Block/code to rename identifier: " + self._info['oldname']

self._info['fulloldname'] = self._info['modname'] + '_' + self._info['oldname']

# now get the new block name

if not re.match('[a-zA-Z0-9_]+', self._info['newname']):

raise ModToolException('Invalid block name.')

print "Block/code identifier: " + self._info['newname']

self._info['fullnewname'] = self._info['modname'] + '_' + self._info['newname']

""" Go, go, go. """

module = self._info['modname']

oldname = self._info['oldname']

newname = self._info['newname']

class ModToolRemove(ModTool):

""" Remove block (delete files and remove Makefile entries) """

name = 'remove'

def __init__(self):

ModTool.__init__(self)

else:

self._info['pattern'] = raw_input('Which blocks do you want to delete? (Regex): ')

if len(self._info['pattern']) == 0:

self._info['pattern'] = '.'

""" Go, go, go! """

def _remove_cc_test_case(filename=None, ed=None):

""" Special function that removes the occurrences of a qa*.cc file

(self._info['modname'], pyblockname, self._info['modname'], filename)

return regexp

# Go, go, go!

if not self._skip_subdirs['lib']:

self._run_subdir('lib', ('*.cc', '*.h'), ('add_library', 'list'),

cmakeedit_func=_remove_cc_test_case)

#

#

# This file is part of GNU Radio

#

''' % datetime.now().year

Templates['grlicense'] = '''

This file is part of GNU Radio

along with GNU Radio; see the file COPYING. If not, write to

the Free Software Foundation, Inc., 51 Franklin Street,

Boston, MA 02110-1301, USA.

# Header file of a sync/decimator/interpolator block

Templates['block_impl_h'] = '''/* -*- c++ -*- */

namespace gr {

namespace ${modname} {

private:

// Nothing to declare in this block.

protected:

int calculate_output_stream_length(const gr_vector_int &ninput_items);

public:

~${blockname}_impl();

// Where all the action really happens

void forecast (int noutput_items, gr_vector_int &ninput_items_required);

int general_work(int noutput_items,

gr_vector_int &ninput_items,

gr_vector_const_void_star &input_items,

gr_vector_void_star &output_items);

};

} // namespace ${modname}

} // namespace gr

'''

# C++ file of a GR block

Templates['block_impl_cpp'] = '''/* -*- c++ -*- */

namespace gr {

namespace ${modname} {

{

}

{

}

${blockname}::sptr

{

return gnuradio::get_initial_sptr

}

/*

* The private constructor

*/

: gr::${grblocktype}("${blockname}",

{

connect(self(), 0, d_firstblock, 0);

// connect other blocks

connect(d_lastblock, 0, self(), 0);

}

{}

/*

* Our virtual destructor.

{

}

void

${blockname}_impl::forecast (int noutput_items, gr_vector_int &ninput_items_required)

{

// Tell runtime system how many output items we produced.

return noutput_items;

}

int

${blockname}_impl::calculate_output_stream_length(const gr_vector_int &ninput_items)

{

// Tell runtime system how many output items we produced.

return noutput_items;

}

int

${blockname}_impl::work(int noutput_items,

gr_vector_const_void_star &input_items,

gr_vector_void_star &output_items)

{

const <+ITYPE+> *in = (const <+ITYPE+> *) input_items[0];

<+OTYPE+> *out = (<+OTYPE+> *) output_items[0];

// Do <+signal processing+>

// Tell runtime system how many output items we produced.

return noutput_items;

}

} /* namespace ${modname} */

} /* namespace gr */

# Block definition header file (for include/)

Templates['block_def_h'] = '''/* -*- c++ -*- */

namespace gr {

namespace ${modname} {

/*!

* \\brief <+description+>

*

*/

{

public:

${blockname}(${arglist});

~${blockname}();

private:

};

/*!

* \\brief <+description of block+>

* \ingroup ${modname}

*

*/

{

public:

typedef boost::shared_ptr<${blockname}> sptr;

* class. ${modname}::${blockname}::make is the public interface for

* creating new instances.

*/

};

} // namespace ${modname}

} // namespace gr

'''

# Python block

# -*- coding: utf-8 -*-

class ${blockname}(${parenttype}):

"""

docstring for block ${blockname}

"""

${parenttype}.__init__(self,

gr.io_signature(${inputsig}), # Input signature

gr.io_signature(${outputsig})) # Output signature

# Define blocks and connect them

self.connect()

name="${blockname}",

in_sig=${inputsig},

out_sig=${outputsig}${deciminterp})

def forecast(self, noutput_items, ninput_items_required):

#setup size of input_items[i] for work call

for i in range(len(ninput_items_required)):

consume(0, len(input_items[0]))

\#self.consume_each(len(input_items[0]))

return len(output_items[0])

def work(self, input_items, output_items):

in0 = input_items[0]

out = output_items[0]

# <+signal processing here+>

out[:] = in0

return len(output_items[0])

return len(input_items[0])

out[:] = whatever

return len(output_items[0])

'''

# C++ file for QA

Templates['qa_cpp'] = '''/* -*- c++ -*- */

namespace gr {

namespace ${modname} {

# Header file for QA

Templates['qa_h'] = '''/* -*- c++ -*- */

namespace gr {

namespace ${modname} {

} /* namespace ${modname} */

} /* namespace gr */

'''

# Python QA code

# -*- coding: utf-8 -*-

#

from gnuradio import gr, gr_unittest

from gnuradio import blocks

import ${modname}_swig as ${modname}

from ${blockname} import ${blockname}

def setUp (self):

self.tb = gr.top_block ()

Templates['grc_xml'] = '''<?xml version="1.0"?>

<block>

<!-- Make one 'param' node for every Parameter you want settable from the GUI.

Sub-nodes:

* name

</block>

'''

# SWIG string

"""

## Old stuff

# C++ file of a GR block

Templates['block_cpp36'] = '''/* -*- c++ -*- */

{

}

${modname}_${blockname}::~${modname}_${blockname}()

{

}

${modname}_${blockname}_sptr

{

}

/*

* The private constructor

*/

: gr_${grblocktype} ("${blockname}",

{

connect(self(), 0, d_firstblock, 0);

// <+connect other blocks+>

connect(d_lastblock, 0, self(), 0);

// Put in <+constructor stuff+> here

}

{

// Put in <+destructor stuff+> here

}

void

${modname}_${blockname}::forecast (int noutput_items, gr_vector_int &ninput_items_required)

{

// Tell runtime system how many output items we produced.

return noutput_items;

}

int

${modname}_${blockname}::work(int noutput_items,

gr_vector_const_void_star &input_items,

// Tell runtime system how many output items we produced.

return noutput_items;

}

'''

# Block definition header file (for include/)

Templates['block_h36'] = '''/* -*- c++ -*- */

{

${blockname}(${arglist});

~${blockname}();

private:

};

class ${modname}_${blockname};

typedef boost::shared_ptr<${modname}_${blockname}> ${modname}_${blockname}_sptr;

/*!

* \\brief <+description+>

* \ingroup ${modname}

*

*/

{

private:

public:

~${modname}_${blockname}();

void forecast (int noutput_items, gr_vector_int &ninput_items_required);

// Where all the action really happens

gr_vector_int &ninput_items,

gr_vector_const_void_star &input_items,

gr_vector_void_star &output_items);

// Where all the action really happens

int work (int noutput_items,

gr_vector_const_void_star &input_items,

gr_vector_void_star &output_items);

};

'''

# None of these must depend on other modtool stuff!

def append_re_line_sequence(filename, linepattern, newline):

""" Detects the re 'linepattern' in the file. After its last occurrence,

paste 'newline'. If the pattern does not exist, append the new line

pyqt_plot.py

pyqt_filter.py

DESTINATION ${GR_PYTHON_DIR}/gnuradio

)

GR_PYTHON_INSTALL(

gr_plot_short

gr_plot_qt

gr_read_file_metadata

DESTINATION ${GR_RUNTIME_DIR}

)

from gnuradio.modtool import *

def main():

""" Here we go. Parse command, choose class and run. """

except ModToolException as err:

print >> sys.stderr, err

exit(1)

print "Please install SciPy to run this script (http://www.scipy.org/)"

raise SystemExit, 1

from gnuradio.plot_data import plot_data

def main():

description = "Takes a GNU Radio byte/char binary file and displays the samples versus time. You can set the block size to specify how many points to read in at a time and the start position in the file. By default, the system assumes a sample rate of 1, so in time, each sample is plotted versus the sample number. To set a true time axis, set the sample rate (-R or --sample-rate) to the sample rate used when capturing the samples."

if __name__ == "__main__":

try:

print "Please install Matplotlib to run this script (http://matplotlib.sourceforge.net/)"

raise SystemExit, 1

class draw_constellation:

def __init__(self, filename, options):

def main():

description = "Takes a GNU Radio complex binary file and displays the I&Q data versus time and the constellation plot (I vs. Q). You can set the block size to specify how many points to read in at a time and the start position in the file. By default, the system assumes a sample rate of 1, so in time, each sample is plotted versus the sample number. To set a true time axis, set the sample rate (-R or --sample-rate) to the sample rate used when capturing the samples."

if __name__ == "__main__":

try:

def main():

parser = plot_fft_base.setup_options()

if __name__ == "__main__":

try:

def main():

parser = plot_fft_base.setup_options()

if __name__ == "__main__":

try:

def main():

parser = plot_fft_base.setup_options()

if __name__ == "__main__":

try:

print "Please install SciPy to run this script (http://www.scipy.org/)"

raise SystemExit, 1

from gnuradio.plot_data import plot_data

def main():

description = "Takes a GNU Radio floating point binary file and displays the samples versus time. You can set the block size to specify how many points to read in at a time and the start position in the file. By default, the system assumes a sample rate of 1, so in time, each sample is plotted versus the sample number. To set a true time axis, set the sample rate (-R or --sample-rate) to the sample rate used when capturing the samples."

datatype=scipy.float32

if __name__ == "__main__":

try:

print "Please install SciPy to run this script (http://www.scipy.org/)"

raise SystemExit, 1

from gnuradio.plot_data import plot_data

def main():

description = "Takes a GNU Radio integer binary file and displays the samples versus time. You can set the block size to specify how many points to read in at a time and the start position in the file. By default, the system assumes a sample rate of 1, so in time, each sample is plotted versus the sample number. To set a true time axis, set the sample rate (-R or --sample-rate) to the sample rate used when capturing the samples."

datatype=scipy.int32

if __name__ == "__main__":

try:

print "Please install Matplotlib to run this script (http://matplotlib.sourceforge.net/)"

raise SystemExit, 1

class draw_iq:

def __init__(self, filename, options):

return False

def main():

description = "Takes a GNU Radio complex binary file and displays the I&Q data versus time. You can set the block size to specify how many points to read in at a time and the start position in the file. By default, the system assumes a sample rate of 1, so in time, each sample is plotted versus the sample number. To set a true time axis, set the sample rate (-R or --sample-rate) to the sample rate used when capturing the samples."

if __name__ == "__main__":

try:

def main():

parser = plot_psd_base.setup_options()

if __name__ == "__main__":

try:

# Boston, MA 02110-1301, USA.

#

from gnuradio.plot_psd_base import plot_psd_base

# This is a wrapper program for plot_psd_base specifically for complex data

def main():

parser = plot_psd_base.setup_options()

if __name__ == "__main__":

try:

# Boston, MA 02110-1301, USA.

#

from gnuradio.plot_psd_base import plot_psd_base

# This is a wrapper program for gr_plot_psd specifically for floating point data

def main():

parser = plot_psd_base.setup_options()

if __name__ == "__main__":

try:

print "Please install SciPy to run this script (http://www.scipy.org/)"

raise SystemExit, 1

from gnuradio.plot_data import plot_data

def main():

description = "Takes a GNU Radio short integer binary file and displays the samples versus time. You can set the block size to specify how many points to read in at a time and the start position in the file. By default, the system assumes a sample rate of 1, so in time, each sample is plotted versus the sample number. To set a true time axis, set the sample rate (-R or --sample-rate) to the sample rate used when capturing the samples."

datatype=scipy.int16

if __name__ == "__main__":

try:

#

import sys

import pmt

from gnuradio.blocks import parse_file_metadata

handle.seek(nread, 0)

print "\n\n"

if __name__ == "__main__":

description = "Read in a GNU Radio file with meta data, extracts the header and prints it."

help="Used if header is detached.")

print "Please install Matplotlib to run this script (http://matplotlib.sourceforge.net/)"

raise SystemExit, 1

class plot_data:

def __init__(self, datatype, filenames, options):

print "Please install Python Matplotlib (http://matplotlib.sourceforge.net/) and Python TkInter https://wiki.python.org/moin/TkInter to run this script"

raise SystemExit, 1

class plot_fft_base:

def __init__(self, datatype, filename, options):

@staticmethod

def setup_options():

description = "Takes a GNU Radio complex binary file and displays the I&Q data versus time as well as the frequency domain (FFT) plot. The y-axis values are plotted assuming volts as the amplitude of the I&Q streams and converted into dBm in the frequency domain (the 1/N power adjustment out of the FFT is performed internally). The script plots a certain block of data at a time, specified on the command line as -B or --block. This value defaults to 1000. The start position in the file can be set by specifying -s or --start and defaults to 0 (the start of the file). By default, the system assumes a sample rate of 1, so in time, each sample is plotted versus the sample number. To set a true time and frequency axis, set the sample rate (-R or --sample-rate) to the sample rate used when capturing the samples."

return parser

def find(item_in, list_search):

def main():

parser = plot_fft_base.setup_options()

if __name__ == "__main__":

try:

print "Please install Matplotlib to run this script (http://matplotlib.sourceforge.net/)"

raise SystemExit, 1

from scipy import log10

class plot_psd_base:

def __init__(self, datatype, filename, options):

@staticmethod

def setup_options():

description = "Takes a GNU Radio binary file (with specified data type using --data-type) and displays the I&Q data versus time as well as the power spectral density (PSD) plot. The y-axis values are plotted assuming volts as the amplitude of the I&Q streams and converted into dBm in the frequency domain (the 1/N power adjustment out of the FFT is performed internally). The script plots a certain block of data at a time, specified on the command line as -B or --block. The start position in the file can be set by specifying -s or --start and defaults to 0 (the start of the file). By default, the system assumes a sample rate of 1, so in time, each sample is plotted versus the sample number. To set a true time and frequency axis, set the sample rate (-R or --sample-rate) to the sample rate used when capturing the samples. Finally, the size of the FFT to use for the PSD and spectrogram plots can be set independently with --psd-size and --spec-size, respectively. The spectrogram plot does not display by default and is turned on with -S or --enable-spec."

return parser

def main():

parser = plot_psd_base.setup_options()

if __name__ == "__main__":

try: