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}

)

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 *

# 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}")

import os

import re

from util_functions import append_re_line_sequence, ask_yes_no

from cmakefile_editor import CMakeFileEditor

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']

open(path_to_file, 'w').write(render_template(tpl, **self._info))

self.scm.add_files((path_to_file,))

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

has_swig = (

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

and not self._skip_subdirs['swig']

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

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)

</block>

'''

# SWIG string

Templates['swig_block_magic'] = """% if version == '36':

% if blocktype != 'noblock':

# 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_read_file_metadata

grcc

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.")

import warnings

warnings.simplefilter('ignore')

try:

except ImportError:

class GRCC:

def __init__(self, grcfile, out_dir):

self.out_dir = out_dir

data = self.platform.parse_flow_graph(grcfile)

self.fg = self.platform.get_new_flow_graph()

["Validation failed:"] + self.fg.get_error_messages()

))

self.gen.write()

def exec_program(self):

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: