(
alias(), "b",
&foo::set_b,
pmt::mp(0.0f), pmt::mp(20.0f), pmt::mp(10.0f),
"", "Set value of b", RPC_PRIVLVL_MIN,
DISPNULL)));
#endif /* GR_CTRLPORT */
}
int
foo_impl::work(int noutput_items,
gr_vector_const_void_star &input_items,
gr_vector_void_star &output_items)
{ .... }
} /* namespace blocks */
} /* namespace gr */
\endcode
In the above example, we're ignoring some of the basic semantics of
the class as a GNU Radio block and focus just on the call to set up
the get and set functions over ControlPort. Each block has a function
that allows us to add a new ControlPort interface object to a list,
the add_rpc_variable. We don't care about that list anymore;
that's for ControlPort to worry about. We just add new variables,
either setters or getters.
Without dissecting every piece of the above calls, notice that we use
the public class, gr::blocks::foo as the class, not the
implementation class. We also use the block's alias, which GNU Radio
uses as a database entry to connect a block by name to the pointer in
memory. This allows ControlPort to know where the object in memory is
at any given time to access the setters and getters.
The three PMTs specified are simply an expected minimum, maximum, and
default value. None of these are strictly enforced and only serve as
guides. The RPC_PRIVLVL_MIN is currently a placeholder for a
privilege level setting. In many cases, reading b might be
fine for everyone, but we want strong restrictions on who has the
ability to set b.
And finally, we can specify display options to hint at the right way
to display this variable when remotely plotting it. More on that in
the following section.
Finally, note that we put \#ifdefs around the code. We always want
setup_rpc to be there and callable, but if ControlPort was not
built for GNU Radio, we cannot register any variables with it. This is
just a nicety to allow us to set up our code for use with ControlPort
without requiring it.
\subsection ctrlport_alt_reg Alternative Registers
If using the concept above, setup_rpc automatically gets called
when the flowgraph is started. In most instances, this is all we ever
need since there's nothing interesting going on until then. However,
if not using a gr::block or needing access before we run the flowgraph,
the above method won't work (it comes down to when the block's alias
has meaning).
There are alternate variable registration functions for the sets and
gets. These take the form:
\code
rpcbasic_register_get(const std::string& name,
const char* functionbase,
T* obj,
Tfrom (T::*function)(),
const pmt::pmt_t &min, const pmt::pmt_t &max, const pmt::pmt_t &def,
const char* units_ = "",
const char* desc_ = "",
priv_lvl_t minpriv_ = RPC_PRIVLVL_MIN,
DisplayType display_ = DISPNULL)
rpcbasic_register_set(const std::string& name,
const char* functionbase,
T* obj,
void (T::*function)(Tto),
const pmt::pmt_t &min, const pmt::pmt_t &max, const pmt::pmt_t &def,
const char* units_ = "",
const char* desc_ = "",
priv_lvl_t minpriv_ = RPC_PRIVLVL_MIN,
DisplayType display_ = DISPNULL)
\endcode
The only thing different about the above code is that instead of
taking a single 'alias()' name, which provides us access to the
objects pointer, we instead provide a unique name
(fucntionbase) and a pointer to the object itself
(obj). These are templated functions, so the class T is known
from that.
If using this method, the recommended way is to create a new function
(not setup_rpc), register the variable using
add_rpc_variable but with the different register_get/set
shown here, and then call this function either in the object's
constructor or make it a public member function to be called when you
need it.
\section ctrlport_disp Display Options
When exporting a new RPC variable over ControlPort, one argument is a
display options mask. These options are useful to a remote client to
tell identify activities like default plotters and initial
conditions. The gr-ctrlport-monitor application uses this
heavily in determining how to plot ControlPort variables.
The options mask is just a 32-bit value with options OR'd
together. Certain options are only appropriate for certain types of
plots. Options on plots where that option is not available will
simply be ignored.
The main caveat to be aware of is that the DISPXY plot type is
specific to complex values. Therefore, DISPOPTCPLX is assumed.
These options are specified in rpccallbackregister_base.h and are
exposed through SWIG to live in the \b gr namespace.
Plot Types
\li DISPNULL: Nothing specified.
\li DISPTIME: Time-domain plot.
\li DISPXY: XY or constellation plot (complex only).
\li DISPPSD: PSD plot.
\li DISPSPEC: Spectrogram plot.
\li DISPRAST: Time raster plot (non-complex only)
Plot Options
\li DISPOPTCPLX: Signal is complex.
\li DISPOPTLOG: Start plot in semilog-y mode (time domain only).
\li DISPOPTSTEM: Start plot in stem mode (time domain only).
\li DISPOPTSTRIP: Run plot as a stripchart (time domain only).
\li DISPOPTSCATTER: Do scatter plot instead of lines (XY plot only).
\section ctrlport_probes ControlPort Probes
ControlPort provides a set of probes that can be used as sinks that
pass vectors of data across ControlPort. These probes are used to
sample or visualize data remotely. We can place a ControlPort probe
anywhere in the flowgraph to grab the latest sample of data from the
block it's connected to.
The main ControlPort probe to use is
blocks.ctrlport_probe2_x. From GRC, this is simply "CtrlPort
Probe", which can handle complex, floats, ints, shorts, and bytes. The
blocks are named and given a description to identify them over
ControlPort. The blocks also take a vector length for how many samples
to pass back at a time. Finally, these blocks take a display hint,
as described in the above section. This allows us to specify the
default behavior for how to display the samples.
Another block that can be used is the fft.ctrlport_probe_psd to
calculate the PSD and pass that over the ControlPort interface.
\section ctrlport_monitors ControlPort Monitors
There are two main ControlPort monitor applications provided with GNU
Radio. Both act similarly. The first is a standard ControlPort monitor
application. This connects to a running flowgraph and displays all
exported interfaces in a table format. The name, unit, latest sample,
and description of all interfaces are display in a
row. Double-clicking will open up the default display. Right clicking
any item will allow the user to select the type of plot to use to
display the data.
When a display is active, using the buttons at the top, the subwindows
can all be tiled or windowed as needed to manage the full
interface. We can then drag-and-drop any other item on top of a
currently running display plot.
To launch the ControlPort monitor application, know the IP address and
port of the ControlPort endpoint established by the flowgraph and run:
gr-ctrlport-monitor \ -p \
\subsection perfmonitor Performance Monitor
A second application is used to locally redraw the flowgraph and
display some of the Performance Counters. In this application, the
nodes are blue boxes where the size of the box is proportional to the
work time and the color depth and line width are proportional to the
output buffer fullness.
The controls at the top of the Performance Monitor application allow
us to select the instantaneous, average, and variance values of the
Performance Counters. And the work time and buffer fullness can be
displayed as a table or bar graph.
To launch the Performance Monitor, run:
gr-perf-monitorx \ -p \
*/
gnuradio-3.7.9.1/docs/doxygen/other/doxypy.py 0000775 0000000 0000000 00000033072 12656154451 0021156 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
__applicationName__ = "doxypy"
__blurb__ = """
doxypy is an input filter for Doxygen. It preprocesses python
files so that docstrings of classes and functions are reformatted
into Doxygen-conform documentation blocks.
"""
__doc__ = __blurb__ + \
"""
In order to make Doxygen preprocess files through doxypy, simply
add the following lines to your Doxyfile:
FILTER_SOURCE_FILES = YES
INPUT_FILTER = "python /path/to/doxypy.py"
"""
__version__ = "0.4.1"
__date__ = "5th December 2008"
__website__ = "http://code.foosel.org/doxypy"
__author__ = (
"Philippe 'demod' Neumann (doxypy at demod dot org)",
"Gina 'foosel' Haeussge (gina at foosel dot net)"
)
__licenseName__ = "GPL v2"
__license__ = """This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
"""
import sys
import re
from optparse import OptionParser, OptionGroup
class FSM(object):
"""Implements a finite state machine.
Transitions are given as 4-tuples, consisting of an origin state, a target
state, a condition for the transition (given as a reference to a function
which gets called with a given piece of input) and a pointer to a function
to be called upon the execution of the given transition.
"""
"""
@var transitions holds the transitions
@var current_state holds the current state
@var current_input holds the current input
@var current_transition hold the currently active transition
"""
def __init__(self, start_state=None, transitions=[]):
self.transitions = transitions
self.current_state = start_state
self.current_input = None
self.current_transition = None
def setStartState(self, state):
self.current_state = state
def addTransition(self, from_state, to_state, condition, callback):
self.transitions.append([from_state, to_state, condition, callback])
def makeTransition(self, input):
""" Makes a transition based on the given input.
@param input input to parse by the FSM
"""
for transition in self.transitions:
[from_state, to_state, condition, callback] = transition
if from_state == self.current_state:
match = condition(input)
if match:
self.current_state = to_state
self.current_input = input
self.current_transition = transition
if options.debug:
print >>sys.stderr, "# FSM: executing (%s -> %s) for line '%s'" % (from_state, to_state, input)
callback(match)
return
class Doxypy(object):
def __init__(self):
string_prefixes = "[uU]?[rR]?"
self.start_single_comment_re = re.compile("^\s*%s(''')" % string_prefixes)
self.end_single_comment_re = re.compile("(''')\s*$")
self.start_double_comment_re = re.compile("^\s*%s(\"\"\")" % string_prefixes)
self.end_double_comment_re = re.compile("(\"\"\")\s*$")
self.single_comment_re = re.compile("^\s*%s(''').*(''')\s*$" % string_prefixes)
self.double_comment_re = re.compile("^\s*%s(\"\"\").*(\"\"\")\s*$" % string_prefixes)
self.defclass_re = re.compile("^(\s*)(def .+:|class .+:)")
self.empty_re = re.compile("^\s*$")
self.hashline_re = re.compile("^\s*#.*$")
self.importline_re = re.compile("^\s*(import |from .+ import)")
self.multiline_defclass_start_re = re.compile("^(\s*)(def|class)(\s.*)?$")
self.multiline_defclass_end_re = re.compile(":\s*$")
## Transition list format
# ["FROM", "TO", condition, action]
transitions = [
### FILEHEAD
# single line comments
["FILEHEAD", "FILEHEAD", self.single_comment_re.search, self.appendCommentLine],
["FILEHEAD", "FILEHEAD", self.double_comment_re.search, self.appendCommentLine],
# multiline comments
["FILEHEAD", "FILEHEAD_COMMENT_SINGLE", self.start_single_comment_re.search, self.appendCommentLine],
["FILEHEAD_COMMENT_SINGLE", "FILEHEAD", self.end_single_comment_re.search, self.appendCommentLine],
["FILEHEAD_COMMENT_SINGLE", "FILEHEAD_COMMENT_SINGLE", self.catchall, self.appendCommentLine],
["FILEHEAD", "FILEHEAD_COMMENT_DOUBLE", self.start_double_comment_re.search, self.appendCommentLine],
["FILEHEAD_COMMENT_DOUBLE", "FILEHEAD", self.end_double_comment_re.search, self.appendCommentLine],
["FILEHEAD_COMMENT_DOUBLE", "FILEHEAD_COMMENT_DOUBLE", self.catchall, self.appendCommentLine],
# other lines
["FILEHEAD", "FILEHEAD", self.empty_re.search, self.appendFileheadLine],
["FILEHEAD", "FILEHEAD", self.hashline_re.search, self.appendFileheadLine],
["FILEHEAD", "FILEHEAD", self.importline_re.search, self.appendFileheadLine],
["FILEHEAD", "DEFCLASS", self.defclass_re.search, self.resetCommentSearch],
["FILEHEAD", "DEFCLASS_MULTI", self.multiline_defclass_start_re.search, self.resetCommentSearch],
["FILEHEAD", "DEFCLASS_BODY", self.catchall, self.appendFileheadLine],
### DEFCLASS
# single line comments
["DEFCLASS", "DEFCLASS_BODY", self.single_comment_re.search, self.appendCommentLine],
["DEFCLASS", "DEFCLASS_BODY", self.double_comment_re.search, self.appendCommentLine],
# multiline comments
["DEFCLASS", "COMMENT_SINGLE", self.start_single_comment_re.search, self.appendCommentLine],
["COMMENT_SINGLE", "DEFCLASS_BODY", self.end_single_comment_re.search, self.appendCommentLine],
["COMMENT_SINGLE", "COMMENT_SINGLE", self.catchall, self.appendCommentLine],
["DEFCLASS", "COMMENT_DOUBLE", self.start_double_comment_re.search, self.appendCommentLine],
["COMMENT_DOUBLE", "DEFCLASS_BODY", self.end_double_comment_re.search, self.appendCommentLine],
["COMMENT_DOUBLE", "COMMENT_DOUBLE", self.catchall, self.appendCommentLine],
# other lines
["DEFCLASS", "DEFCLASS", self.empty_re.search, self.appendDefclassLine],
["DEFCLASS", "DEFCLASS", self.defclass_re.search, self.resetCommentSearch],
["DEFCLASS", "DEFCLASS_MULTI", self.multiline_defclass_start_re.search, self.resetCommentSearch],
["DEFCLASS", "DEFCLASS_BODY", self.catchall, self.stopCommentSearch],
### DEFCLASS_BODY
["DEFCLASS_BODY", "DEFCLASS", self.defclass_re.search, self.startCommentSearch],
["DEFCLASS_BODY", "DEFCLASS_MULTI", self.multiline_defclass_start_re.search, self.startCommentSearch],
["DEFCLASS_BODY", "DEFCLASS_BODY", self.catchall, self.appendNormalLine],
### DEFCLASS_MULTI
["DEFCLASS_MULTI", "DEFCLASS", self.multiline_defclass_end_re.search, self.appendDefclassLine],
["DEFCLASS_MULTI", "DEFCLASS_MULTI", self.catchall, self.appendDefclassLine],
]
self.fsm = FSM("FILEHEAD", transitions)
self.outstream = sys.stdout
self.output = []
self.comment = []
self.filehead = []
self.defclass = []
self.indent = ""
def __closeComment(self):
"""Appends any open comment block and triggering block to the output."""
if options.autobrief:
if len(self.comment) == 1 \
or (len(self.comment) > 2 and self.comment[1].strip() == ''):
self.comment[0] = self.__docstringSummaryToBrief(self.comment[0])
if self.comment:
block = self.makeCommentBlock()
self.output.extend(block)
if self.defclass:
self.output.extend(self.defclass)
def __docstringSummaryToBrief(self, line):
"""Adds \\brief to the docstrings summary line.
A \\brief is prepended, provided no other doxygen command is at the
start of the line.
"""
stripped = line.strip()
if stripped and not stripped[0] in ('@', '\\'):
return "\\brief " + line
else:
return line
def __flushBuffer(self):
"""Flushes the current outputbuffer to the outstream."""
if self.output:
try:
if options.debug:
print >>sys.stderr, "# OUTPUT: ", self.output
print >>self.outstream, "\n".join(self.output)
self.outstream.flush()
except IOError:
# Fix for FS#33. Catches "broken pipe" when doxygen closes
# stdout prematurely upon usage of INPUT_FILTER, INLINE_SOURCES
# and FILTER_SOURCE_FILES.
pass
self.output = []
def catchall(self, input):
"""The catchall-condition, always returns true."""
return True
def resetCommentSearch(self, match):
"""Restarts a new comment search for a different triggering line.
Closes the current commentblock and starts a new comment search.
"""
if options.debug:
print >>sys.stderr, "# CALLBACK: resetCommentSearch"
self.__closeComment()
self.startCommentSearch(match)
def startCommentSearch(self, match):
"""Starts a new comment search.
Saves the triggering line, resets the current comment and saves
the current indentation.
"""
if options.debug:
print >>sys.stderr, "# CALLBACK: startCommentSearch"
self.defclass = [self.fsm.current_input]
self.comment = []
self.indent = match.group(1)
def stopCommentSearch(self, match):
"""Stops a comment search.
Closes the current commentblock, resets the triggering line and
appends the current line to the output.
"""
if options.debug:
print >>sys.stderr, "# CALLBACK: stopCommentSearch"
self.__closeComment()
self.defclass = []
self.output.append(self.fsm.current_input)
def appendFileheadLine(self, match):
"""Appends a line in the FILEHEAD state.
Closes the open comment block, resets it and appends the current line.
"""
if options.debug:
print >>sys.stderr, "# CALLBACK: appendFileheadLine"
self.__closeComment()
self.comment = []
self.output.append(self.fsm.current_input)
def appendCommentLine(self, match):
"""Appends a comment line.
The comment delimiter is removed from multiline start and ends as
well as singleline comments.
"""
if options.debug:
print >>sys.stderr, "# CALLBACK: appendCommentLine"
(from_state, to_state, condition, callback) = self.fsm.current_transition
# single line comment
if (from_state == "DEFCLASS" and to_state == "DEFCLASS_BODY") \
or (from_state == "FILEHEAD" and to_state == "FILEHEAD"):
# remove comment delimiter from begin and end of the line
activeCommentDelim = match.group(1)
line = self.fsm.current_input
self.comment.append(line[line.find(activeCommentDelim)+len(activeCommentDelim):line.rfind(activeCommentDelim)])
if (to_state == "DEFCLASS_BODY"):
self.__closeComment()
self.defclass = []
# multiline start
elif from_state == "DEFCLASS" or from_state == "FILEHEAD":
# remove comment delimiter from begin of the line
activeCommentDelim = match.group(1)
line = self.fsm.current_input
self.comment.append(line[line.find(activeCommentDelim)+len(activeCommentDelim):])
# multiline end
elif to_state == "DEFCLASS_BODY" or to_state == "FILEHEAD":
# remove comment delimiter from end of the line
activeCommentDelim = match.group(1)
line = self.fsm.current_input
self.comment.append(line[0:line.rfind(activeCommentDelim)])
if (to_state == "DEFCLASS_BODY"):
self.__closeComment()
self.defclass = []
# in multiline comment
else:
# just append the comment line
self.comment.append(self.fsm.current_input)
def appendNormalLine(self, match):
"""Appends a line to the output."""
if options.debug:
print >>sys.stderr, "# CALLBACK: appendNormalLine"
self.output.append(self.fsm.current_input)
def appendDefclassLine(self, match):
"""Appends a line to the triggering block."""
if options.debug:
print >>sys.stderr, "# CALLBACK: appendDefclassLine"
self.defclass.append(self.fsm.current_input)
def makeCommentBlock(self):
"""Indents the current comment block with respect to the current
indentation level.
@returns a list of indented comment lines
"""
doxyStart = "##"
commentLines = self.comment
commentLines = map(lambda x: "%s# %s" % (self.indent, x), commentLines)
l = [self.indent + doxyStart]
l.extend(commentLines)
return l
def parse(self, input):
"""Parses a python file given as input string and returns the doxygen-
compatible representation.
@param input the python code to parse
@returns the modified python code
"""
lines = input.split("\n")
for line in lines:
self.fsm.makeTransition(line)
if self.fsm.current_state == "DEFCLASS":
self.__closeComment()
return "\n".join(self.output)
def parseFile(self, filename):
"""Parses a python file given as input string and returns the doxygen-
compatible representation.
@param input the python code to parse
@returns the modified python code
"""
f = open(filename, 'r')
for line in f:
self.parseLine(line.rstrip('\r\n'))
if self.fsm.current_state == "DEFCLASS":
self.__closeComment()
self.__flushBuffer()
f.close()
def parseLine(self, line):
"""Parse one line of python and flush the resulting output to the
outstream.
@param line the python code line to parse
"""
self.fsm.makeTransition(line)
self.__flushBuffer()
def optParse():
"""Parses commandline options."""
parser = OptionParser(prog=__applicationName__, version="%prog " + __version__)
parser.set_usage("%prog [options] filename")
parser.add_option("--autobrief",
action="store_true", dest="autobrief",
help="use the docstring summary line as \\brief description"
)
parser.add_option("--debug",
action="store_true", dest="debug",
help="enable debug output on stderr"
)
## parse options
global options
(options, filename) = parser.parse_args()
if not filename:
print >>sys.stderr, "No filename given."
sys.exit(-1)
return filename[0]
def main():
"""Starts the parser on the file given by the filename as the first
argument on the commandline.
"""
filename = optParse()
fsm = Doxypy()
fsm.parseFile(filename)
if __name__ == "__main__":
main()
gnuradio-3.7.9.1/docs/doxygen/other/group_defs.dox 0000664 0000000 0000000 00000005517 12656154451 0022121 0 ustar 00root root 0000000 0000000 /*!
* \defgroup block GNU Radio C++ Signal Processing Blocks
* \brief All C++ blocks that can be used in GR graphs are listed here or in
* the subcategories below.
*
* Sorry, at this time the Python hierarchical blocks are not included
* in this index.
* @{
*/
/*! \defgroup container_blk Top Block and Hierarchical Block Base Classes */
/*! \defgroup audio_blk Audio Signals */
/*! \defgroup boolean_operators_blk Boolean Operators */
/*! \defgroup byte_operators_blk Byte Operators */
/*! \defgroup channel_models_blk Channel Models */
/*! \defgroup channelizers_blk Channelizers */
/*! \defgroup coding_blk Information Coding and Decoding */
/*! \defgroup controlport_blk ControlPort */
/*! \defgroup debug_tools_blk Debug Tools */
/*! \defgroup deprecated_blk Deprecated */
/*! \defgroup equalizers_blk Equalizers */
/*! \defgroup error_coding_blk Error Coding and Decoding */
/*! \defgroup fcd_blk FCD Interface */
/*! \defgroup file_operators_blk File Operators */
/*! \defgroup filter_blk Filters */
/*! \defgroup fourier_analysis_blk Fourier Analysis */
/*! \defgroup instrumentation_blk Instrumentation Tools */
/*! \defgroup level_controllers_blk Level Controllers */
/*! \defgroup math_operators_blk Math Operators */
/*! \defgroup measurement_tools_blk Measurement Tools */
/*! \defgroup message_tools_blk Message Tools */
/*! \defgroup misc_blk Miscellaneous */
/*! \defgroup modulators_blk Modulators and Demodulators */
/*! \defgroup networking_tools_blk Networking Tools */
/*! \defgroup noaa_blk NOAA Blocks */
/*! \defgroup ofdm_blk OFDM Blocks */
/*! \defgroup packet_operators_blk Packet/Frame Operators */
/*! \defgroup peak_detectors_blk Peak Detectors */
/*! \defgroup pager_blk Pager Blocks */
/*! \defgroup qtgui_blk QT Graphical Interfaces */
/*! \defgroup resamplers_blk Resamplers */
/*! \defgroup stream_operators_blk Streams Operators */
/*! \defgroup stream_tag_tools_blk Stream Tag Tools */
/*! \defgroup symbol_coding_blk Symbol Coding */
/*! \defgroup synchronizers_blk Synchronizers */
/*! \defgroup trellis_coding_blk Trellis Coding */
/*! \defgroup type_converters_blk Data Type Converters */
/*! \defgroup uhd_blk UHD Interface */
/*! \defgroup waveform_generators_blk Waveform Generators */
/*! \defgroup wavelet_blk Wavelet Transforms */
/*! \defgroup wxgui_blk WX Graphical Interfaces */
/*!
* \defgroup base_blk Base classes for GR Blocks
* \brief All C++ blocks are derived from these base classes
*/
/*! @} */
/*! \defgroup filter_design Digital Filter Design */
/*! \defgroup misc Miscellaneous */
/*! \defgroup internal Implementation Details */
/*!
* \defgroup applications Applications
* These are some applications build using gnuradio...
* @{
*/
/*!
* \defgroup atsc ATSC
* ATSC Applications...
*/
/*!
* \defgroup pager Pager
* Pager Applications
*/
/*! @} */
/*! \defgroup hardware Misc Hardware Control */
gnuradio-3.7.9.1/docs/doxygen/other/logger.dox 0000664 0000000 0000000 00000021113 12656154451 0021231 0 ustar 00root root 0000000 0000000 /*! \page page_logger Logging
\section logging Logging
GNU Radio has a logging interface to enable various levels of logging
information to be printed to the console or a file. The logger derives
from log4cpp (http://log4cpp.sourceforge.net/) which is readily
available in most Linux distributions. This is an optional dependency
and GNU Radio will work without it.
When configuring GNU Radio, the -DENABLE_GR_LOG=On|Off option to cmake
will allow the user to toggle use of the logger on and off. The logger
defaults to "on" and will use log4cpp if it is available. If log4cpp
is not found, the default logging will output to standard output or
standard error, depending on the level of the log message.
Logging is useful for blocks to print out certain amounts of data at
different levels. These levels are:
DEBUG < INFO < WARN < TRACE < ERROR < ALERT < CRIT < FATAL < EMERG
The order here determines the level of output. These levels are
hierarchical in that specifying any level also includes any level
above it. For example, when using the INFO level, all INFO and
higher messages are logged and DEBUG is ignored. A level NOTSET is provided
to disable a logger.
\subsection configfile Logging Configuration
The logging configuration can be found in the gnuradio-runtime.conf file
under the [LOG] section. This allows us fairly complete control over
the logging facilities. The main configuration functions are to set up
the level of the loggers and set the default output behavior of the
loggers.
There are two default loggers that all gr_block's have access to:
d_logger and d_debug_logger. The first is a standard logger meant to
output simple information about the block while it is running. The
debug logger is meant for debugging purposes and is added to make it
convenient to use a secondary logger that outputs to a different
stream or file.
The four main configure options are:
log_level = debug
debug_level = debug
log_file = stdout
debug_file = stderr
This establishes the two loggers as having access to all levels of
logging events (DEBUG through EMERG). They are also configured not to
use files but instead output to the console. The standard logger will
output to standard out while the debug logger outputs to standard
error.
Changing these last two lines to another value will create files that
are used to store the log messages. All messages are appended to the
file.
When using either standard error or standard out, the messages for the
two different loggers will look like:
gr::log :\: \ - \
gr::debug :\: \ - \
When using a file, the only difference in the format is that the
message prefix of "gr::log" or "gr::debug" is not used. Instead, the
time in milliseconds from the start of the program is inserted.
Remember that a local "~/.gnuradio/config.conf" file can be used to
override any parameter in the global file (see \ref prefs for more
details).
To use these loggers inside of a GNU Radio block, we use the protected
data members of d_logger and d_debug_logger of gr_block and pass them
to our pre-defined macros:
\code
GR_LOG_(, "");
\endcode
Where \ is one of the levels as mentioned above, \ is
either d_logger or d_debug_logger, and \ is the
message we want to output. If we wanted to output an INFO level
message to the standard logger and a WARN level message to the debug
logger, it would look like this:
\code
GR_LOG_INFO(d_logger, "Some info about the block");
GR_LOG_WARN(d_debug_logger, "Some warning about the block");
\endcode
When this is printed to wherever you are directing the output of the
logger, it will look like:
gr::log :INFO: - Some info about the block
gr::debug :WARN: