add_definitions(/bigobj) #allow for larger object files

endif(MSVC)

# Record Compiler Info for record

STRING(TOUPPER ${CMAKE_BUILD_TYPE} GRCBTU)

set(COMPILER_INFO "")

When writing programs that are executable from the command line,

please follow these guidelines for command line argument names (short

and long) and types of the arguments. We list them below using the

** Mandatory options by gr::block

Any program using an audio source shall include:

help="pcm input device name. E.g., hw:0,0 or /dev/dsp")

The default must be "". This allows an audio module-dependent default

*** Audio sink

help="pcm output device name. E.g., hw:0,0 or /dev/dsp")

The default must be "". This allows an audio module-dependent default

To specify a frequency (typically an RF center frequency) use:

To specify a decimation factor use:

To specify an interpolation factor use:

To specify a gain setting use:

If your application specifies both a tx and an rx gain, use:

To specify the number of channels of something use:

To specify an output filename use:

To specify a rate use:

or

If your application has a verbose option, use:

If your application allows the user to specify the "fast USB" options, use:

/usr/include/qwt6

/usr/include/qwt-${QWT_QT_VERSION}

/usr/include/qwt

/usr/include/qwt5

/opt/local/include/qwt

/sw/include/qwt

)

find_library (QWT_LIBRARIES

HINTS

${CMAKE_INSTALL_PREFIX}/lib

${CMAKE_INSTALL_PREFIX}/lib64

filesystem

system

regex

)

if(UNIX AND NOT BOOST_ROOT AND EXISTS "/usr/lib64")

list(APPEND BOOST_LIBRARYDIR "/usr/lib64") #fedora 64-bit fix

endif(UNIX AND NOT BOOST_ROOT AND EXISTS "/usr/lib64")

if(NOT DEFINED LIB_SUFFIX AND LIB64_CONVENTION AND CMAKE_SYSTEM_PROCESSOR MATCHES "64$")

set(LIB_SUFFIX 64)

endif()

set(LIB_SUFFIX ${LIB_SUFFIX} CACHE STRING "lib directory suffix")

////////////////////////////////////////////////////////////////////////

// rint functions

////////////////////////////////////////////////////////////////////////

#include <math.h>

#if _MSC_VER < 1800

static inline long lrint(double x){return (long)(x > 0.0 ? x + 0.5 : x - 0.5);}

static inline long int random (void) { return rand(); }

static inline void srandom (unsigned int seed) { srand(seed); }

#endif // _MSC_CONFIG_H_ ]

INPUT_FILTER = "python /path/to/doxypy.py"

"""

__date__ = "5th December 2008"

__website__ = "http://code.foosel.org/doxypy"

import sys

import re

class FSM(object):

"""Implements a finite state machine.

self.current_state = to_state

self.current_input = input

self.current_transition = transition

print >>sys.stderr, "# FSM: executing (%s -> %s) for line '%s'" % (from_state, to_state, input)

callback(match)

return

def __closeComment(self):

"""Appends any open comment block and triggering block to the output."""

if len(self.comment) == 1 \

or (len(self.comment) > 2 and self.comment[1].strip() == ''):

self.comment[0] = self.__docstringSummaryToBrief(self.comment[0])

"""Flushes the current outputbuffer to the outstream."""

if self.output:

try:

print >>sys.stderr, "# OUTPUT: ", self.output

print >>self.outstream, "\n".join(self.output)

self.outstream.flush()

Closes the current commentblock and starts a new comment search.

"""

print >>sys.stderr, "# CALLBACK: resetCommentSearch"

self.__closeComment()

self.startCommentSearch(match)

Saves the triggering line, resets the current comment and saves

the current indentation.

"""

print >>sys.stderr, "# CALLBACK: startCommentSearch"

self.defclass = [self.fsm.current_input]

self.comment = []

Closes the current commentblock, resets the triggering line and

appends the current line to the output.

"""

print >>sys.stderr, "# CALLBACK: stopCommentSearch"

self.__closeComment()

Closes the open comment block, resets it and appends the current line.

"""

print >>sys.stderr, "# CALLBACK: appendFileheadLine"

self.__closeComment()

self.comment = []

The comment delimiter is removed from multiline start and ends as

well as singleline comments.

"""

print >>sys.stderr, "# CALLBACK: appendCommentLine"

(from_state, to_state, condition, callback) = self.fsm.current_transition

def appendNormalLine(self, match):

"""Appends a line to the output."""

print >>sys.stderr, "# CALLBACK: appendNormalLine"

self.output.append(self.fsm.current_input)

def appendDefclassLine(self, match):

"""Appends a line to the triggering block."""

print >>sys.stderr, "# CALLBACK: appendDefclassLine"

self.defclass.append(self.fsm.current_input)

self.fsm.makeTransition(line)

self.__flushBuffer()

help="use the docstring summary line as \\brief description"

)

help="enable debug output on stderr"

)

def main():

"""Starts the parser on the file given by the filename as the first

argument on the commandline.

"""

fsm = Doxypy()

if __name__ == "__main__":

main()

.. autoblock:: gnuradio.digital.kurtotic_equalizer_cc

.. autoblock:: gnuradio.digital.lms_dd_equalizer_cc

.. autoblock:: gnuradio.digital.map_bb

.. autoblock:: gnuradio.digital.mpsk_snr_est_cc

.. autoblock:: gnuradio.digital.msk_timing_recovery_cc

.. autoblock:: gnuradio.digital.ofdm_carrier_allocator_cvc

gnuradio.digital.corr_est_cc

gnuradio.digital.costas_loop_cc

gnuradio.digital.fll_band_edge_cc

gnuradio.digital.msk_timing_recovery_cc

gnuradio.analog.pll_carriertracking_cc

gnuradio.analog.pll_freqdet_cf

import os

import os.path

import sys

dry_run = False

modified_files = []

def main():

global dry_run

handle_file_or_dir(file_or_dir)

for f in modified_files:

sys.stdout.write(f + '\n')

def main():

parser = ArgumentParser()

args = parser.parse_args()

if __name__ == '__main__':

from gnuradio import gr, eng_notation

from gnuradio import blocks, filter

import os

gr.top_block.__init__(self)

default_nsamples = 10e6

help=("the number of samples to run through the graph (default=%s)" %

(eng_notation.num_to_str(default_nsamples))))

help="enable machine readable output")

ntaps = 256

# Something vaguely like floating point ops

src = blocks.null_source(gr.sizeof_float)

self.connect(src, head)

def time_it(tb):

from gnuradio import audio

from gnuradio import analog

from gnuradio import blocks

import sys

import math

def __init__(self):

gr.top_block.__init__(self)

self.vol = 0

# build graph

adc_rate = 64e6 # 64 MS/s

usrp_decim = 200

# wave file as final sink

if 1:

else:

sink = audio.sink (int (audio_rate),

False) # ok_to_block

# now wire it all together

pass

#print "FYI: This implementation of the stereo_carrier_pll_recovery has no squelch implementation yet"

g = self.volume_range()

# set initial values

try:

except:

pass

#print "FYI: This implementation of the stereo_carrier_pll_recovery has no squelch implementation yet"

from gnuradio import gr

from gnuradio import blocks

import sys

try:

self.connect(src, dst)

if __name__ == '__main__':

help="local host name (domain name or IP address)")

help="port value to listen to for connection")

help="packet size.")

help="don't send EOF on disconnect")

# Create an instance of a hierarchical block

try:

# Run forever

from gnuradio import gr

from gnuradio import blocks

import sys

try:

def __init__(self, host, port, pkt_size, sample_rate, eof):

gr.top_block.__init__(self, "audio_source")

self.audio = audio.source(sample_rate)

self.connect(self.audio, self.sink)

if __name__ == '__main__':

help="Remote host name (domain name or IP address")

help="port number to connect to")

help="packet size.")

help="don't send EOF on disconnect")

# Create an instance of a hierarchical block

try:

# Run forever

from gnuradio import gr, audio

from gnuradio import blocks

class dial_tone_sink(gr.top_block):

def __init__(self, host, port, pkt_size, sample_rate, eof):

self.connect(udp, sink)

if __name__ == '__main__':

help="local host name (domain name or IP address)")

help="port value to listen to for connection")

help="packet size.")

help="don't send EOF on disconnect")

# Create an instance of a hierarchical block

try:

# Run forever

#

from gnuradio import gr

import sys

try:

add = blocks.add_ff()

# Throttle needed here to account for the other side's audio card sampling rate

if __name__ == '__main__':

help="Remote host name (domain name or IP address")

help="port number to connect to")

help="packet size.")

help="don't send EOF on disconnect")

# Create an instance of a hierarchical block

try:

# Run forever

from gnuradio import gr

from gnuradio import blocks

class vector_sink(gr.top_block):

def __init__(self, host, port, pkt_size, eof):

self.connect(udp, sink)

if __name__ == "__main__":

help="local host name (domain name or IP address)")

help="port value to listen to for connection")

help="packet size.")

help="don't send EOF on disconnect")

# Create an instance of a hierarchical block

try:

# Run forever

from gnuradio import gr

from gnuradio import blocks

class vector_source(gr.top_block):

def __init__(self, host, port, pkt_size, eof):

self.connect(vec, udp)

if __name__ == '__main__':

help="Remote host name (domain name or IP address")

help="port number to connect to")

help="packet size.")

help="don't send EOF on disconnect")

# Create an instance of a hierarchical block

try:

# Run forever

#include <config.h>

#endif

#include <gnuradio/constants.h>

namespace gr {

const std::string

prefix()

{

return "@prefix@";

}

const std::string

sysconfdir()

{

return "@SYSCONFDIR@";

}

const std::string

prefsdir()

{

return "@GR_PREFSDIR@";

}

#include <iostream>

#include <stdexcept>

rpcmanager::rpcmanager() {;}

rpcmanager::~rpcmanager() {;}

#include <gnuradio/rpcserver_selector.h>

bool rpcmanager::make_aggregator(false);

#ifdef GR_RPCSERVER_ENABLED

rpcmanager manager_instance;

setup_buffer_alignment(block);

}

// Now deal with the fact that the block details might have

// changed numbers of inputs and outputs vs. in the old

// flowgraph.

if (name == _symbol(sym)->name())

return sym; // Yes. Return it

}

// Nope. Make a new one.

pmt_t sym = pmt_t(new pmt_symbol(name));

_symbol(sym)->set_next((*get_symbol_hash_table())[hash]);

void

top_block::start(int max_noutput_items)

{

d_impl->start(max_noutput_items);

if(prefs::singleton()->get_bool("ControlPort", "on", false)) {

}

#ifdef GNURADIO_HRT_USE_CLOCK_GETTIME

add_rpc_variable(

rpcbasic_sptr(new rpcbasic_register_variable_rw<int>(

alias(), "perfcounter_clock",

"Please check that they are installed and try again."

sys.exit(1)

import PyQt4.QtGui as QtGui

import itertools

from gnuradio import filter, analog, blocks

from gnuradio import uhd

from gnuradio.fft import window

from gnuradio.filter import firdes

class uhd_burst_detector(gr.top_block):

def __init__(self, uhd_address, options):

self.uhd_src_0.set_samp_rate(self.samp_rate)

if __name__ == '__main__':

# help="select Rx Antenna (only on RFX-series boards)")

help="set frequency to FREQ", metavar="FREQ")

tb.run()

</cat>

<cat>

<name>Modulators</name>

<block>analog_frequency_modulator_fc</block>

<block>analog_phase_modulator_fc</block>

<block>analog_quadrature_demod_cf</block>

<block>

<name>CPFSK</name>

<key>analog_cpfsk_bc</key>

<import>from gnuradio import analog</import>

<make>analog.cpfsk_bc($k, $amplitude, $samples_per_symbol)</make>

<callback>set_amplitude($amplitude)</callback>

* \brief Perform continuous phase 2-level frequency shift keying modulation

* on an input stream of unpacked bits.

* \ingroup modulators_blk

*/

class ANALOG_API cpfsk_bc : virtual public sync_interpolator

{

@TYPE@ @IMPL_NAME@::sample()

{

size_t idx = lrand48() % d_samples.size();

#else

size_t idx = rand() % d_samples.size();

}

#ifndef FASTNOISE_RANDOM_SIGN

#define FASTNOISE_RANDOM_SIGN ((rand()%2==0)?1:-1)

#else

#define FASTNOISE_RANDOM_SIGN ((lrand48()%2==0)?1:-1)

\section audio_usage Usage

like:

\code

help="pcm device name. E.g., hw:0,0 or surround51 or /dev/dsp")

audio_rate = 32e3

audio_sink = audio.sink (int (audio_rate), options.audio_output)

\endcode

its use would look like:

\code

help="pcm input device name. E.g., hw:0,0 or /dev/dsp")

audio_rate = 32e3

audio_source = audio.source(int(audio_rate), audio_input)

from gnuradio import gr

from gnuradio import audio

class my_top_block(gr.top_block):

def __init__(self):

gr.top_block.__init__(self)

help="pcm input device name. E.g., hw:0,0 or /dev/dsp")

help="pcm output device name. E.g., hw:0,0 or /dev/dsp")

# Determine the maximum number of outputs on the source and

# maximum number of inputs on the sink, then connect together

from gnuradio import gr

from gnuradio import audio

from gnuradio import blocks

class my_top_block(gr.top_block):

def __init__(self):

gr.top_block.__init__(self)

help="pcm output device name. E.g., hw:0,0 or /dev/dsp")

self.connect(src, dst)

from gnuradio import gr

from gnuradio import audio

from gnuradio import blocks

class my_top_block(gr.top_block):

def __init__(self):

gr.top_block.__init__(self)

help="pcm input device name. E.g., hw:0,0 or /dev/dsp")

help="number of samples to collect [default=+inf]")

self.connect((src, 0), dst)

else:

self.connect((src, 0), head, dst)

from gnuradio import gr

from gnuradio import audio

try:

from gnuradio import analog

def __init__(self):

gr.top_block.__init__(self)

help="pcm output device name. E.g., hw:0,0 or /dev/dsp")

ampl = 0.1

src0 = analog.sig_source_f(sample_rate, analog.GR_SIN_WAVE, 350, ampl)

src1 = analog.sig_source_f(sample_rate, analog.GR_SIN_WAVE, 440, ampl)

self.connect(src0, (dst, 0))

self.connect(src1, (dst, 1))

from gnuradio import gr, gru

from gnuradio import audio

import os

try:

def __init__(self):

gr.top_block.__init__(self)

help="pcm output device name. E.g., hw:0,0 or /dev/dsp")

ampl = 0.1

src0 = analog.sig_source_f(sample_rate, analog.GR_SIN_WAVE, 350, ampl)

src1 = analog.sig_source_f(sample_rate, analog.GR_SIN_WAVE, 440, ampl)

self.connect(src0, (dst, 0))

self.connect(src1, (dst, 1))

from gnuradio import gr

from gnuradio import blocks

try:

from gnuradio import analog

def __init__(self):

gr.top_block.__init__(self)

ampl = 0.1

src0 = analog.sig_source_f(sample_rate, analog.GR_SIN_WAVE, 350, ampl)

src1 = analog.sig_source_f(sample_rate, analog.GR_SIN_WAVE, 440, ampl)

self.connect(src0, head0, (dst, 0))

self.connect(src1, head1, (dst, 1))

from gnuradio import gr

from gnuradio import audio

try:

from gnuradio import analog

def __init__(self):

gr.top_block.__init__(self)

help="pcm output device name. E.g., hw:0,0 or /dev/dsp")

dest="ok_to_block")

src0 = analog.sig_source_f(sample_rate, analog.GR_SIN_WAVE, 650, ampl)

dst = audio.sink(sample_rate,

self.connect (src0, (dst, 0))

from gnuradio import gr

from gnuradio import audio

try:

from gnuradio import analog

def __init__(self):

gr.top_block.__init__(self)

help="pcm output device name. E.g., hw:0,0 or /dev/dsp")

help="set maximum channels to use")

dest="ok_to_block")

ampl = 0.1

progression = (7, 11, 1, 5, 9)

dst = audio.sink(sample_rate,

max_chan = dst.input_signature().max_streams()

if (max_chan == -1) or (max_chan > limit_channels):

from gnuradio import gr

from gnuradio import audio

from gnuradio import digital

class my_top_block(gr.top_block):

def __init__(self):

gr.top_block.__init__(self)

help="pcm output device name. E.g., hw:0,0 or /dev/dsp")

help="set sample rate to RATE (48000)")

ampl = 0.1

src = digital.glfsr_source_b(32) # Pseudorandom noise source

b2f = digital.chunks_to_symbols_bf([ampl, -ampl], 1)

self.connect(src, b2f, dst)

if __name__ == '__main__':

from gnuradio import gr

from gnuradio import audio

from gnuradio import blocks

class my_top_block(gr.top_block):

def __init__(self):

gr.top_block.__init__(self)

help="pcm input device name. E.g., hw:0,0 or /dev/dsp")

help="pcm output device name. E.g., hw:0,0 or /dev/dsp")

vec1 = [1, -1]

vsource = blocks.vector_source_f(vec1, True)

from gnuradio import gr, gru

from gnuradio import audio

from gnuradio import filter

try:

from gnuradio import analog

def __init__(self):

gr.top_block.__init__(self)

help="pcm output device name. E.g., hw:0,0 or /dev/dsp")

interp = gru.lcm(input_rate, output_rate) / input_rate

decim = gru.lcm(input_rate, output_rate) / output_rate

ampl = 0.1

src0 = analog.sig_source_f(input_rate, analog.GR_SIN_WAVE, 650, ampl)

rr = filter.rational_resampler_fff(interp, decim)

self.connect(src0, rr, (dst, 0))

if __name__ == '__main__':

sink::sptr

windows_sink_fcn(int sampling_rate,

const std::string &device_name,

{

return sink::sptr

}

static const double CHUNK_TIME = prefs::singleton()->get_double("audio_windows", "period_time", 0.1); // 100 ms (below 3ms distortion will likely occur regardless of number of buffers, will likely be a higher limit on slower machines)

return (default_device == "default" ? "WAVE_MAPPER" : default_device);

}

: sync_block("audio_windows_sink",

io_signature::make(1, 2, sizeof(float)),

io_signature::make(0, 0, 0)),

d_sampling_freq(sampling_freq),

d_device_name(device_name.empty() ? default_device_name() : device_name),

{

/* Initialize the WAVEFORMATEX for 16-bit, 44KHz, stereo */

wave_format.wFormatTag = WAVE_FORMAT_PCM;

}

}

if (!chosen_header) {

}

if (c++ > 10) {

for (int i = 0; i < nPeriods; i++) {

printf("%d: %d\n", i, d_buffers[i]->dwFlags);

}

int d_fd;

LPWAVEHDR *d_buffers;

DWORD d_chunk_size;

HWAVEOUT d_h_waveout;

HANDLE d_wave_write_event;

protected:

int string_to_int(const std::string & s);

int open_waveout_device(void);

int write_waveout(LPWAVEHDR lp_wave_hdr);

public:

windows_sink(int sampling_freq,

~windows_sink();

int work(int noutput_items,

#include "audio_registry.h"

#include <windows_source.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <stdio.h>

#include <iostream>

#include <stdexcept>

namespace gr {

} /* namespace gr */

#ifndef INCLUDED_AUDIO_WINDOWS_SOURCE_H

#define INCLUDED_AUDIO_WINDOWS_SOURCE_H

#include <gnuradio/audio/source.h>

#include <string>

namespace gr {

namespace audio {

*/

class windows_source : public source

{

public:

windows_source(int sampling_freq,

gr_vector_void_star & output_items);

};

} /* namespace audio */

} /* namespace gr */

#endif(ENABLE_TESTING)

if(ENABLE_PYTHON)

add_subdirectory(python/blocks)

add_subdirectory(swig)

add_subdirectory(grc)

add_subdirectory(doc)

import sys

import pmt

from gnuradio.ctrlport.GNURadioControlPortClient import GNURadioControlPortClient

port = 'command'

if(cmd == "tune" or cmd == "time"):

sys.stderr.write("This application currently does not support the 'tune' or 'time' UHD "

else:

val = pmt.from_double(float(val))

radiosys = GNURadioControlPortClient(argv=argv, rpcmethod='thrift')

radio = radiosys.client

import sys

import pmt

from gnuradio.ctrlport.GNURadioControlPortClient import GNURadioControlPortClient

port = 'command'

if(cmd == "tune" or cmd == "time"):

sys.stderr.write("This application currently does not support the 'tune' or 'time' UHD "

else:

val = pmt.from_double(float(val))

radiosys = GNURadioControlPortClient(argv=argv, rpcmethod='thrift')

radio = radiosys.client

" HAVE_COSF

)

GR_ADD_COND_DEF(HAVE_COSF)

#include "nlog10_ff_impl.h"

#include <gnuradio/io_signature.h>

namespace gr {

namespace blocks {

: sync_block("nlog10_ff",

io_signature::make (1, 1, sizeof(float)*vlen),

io_signature::make (1, 1, sizeof(float)*vlen)),

{

}

int

const float *in = (const float *) input_items[0];

float *out = (float *) output_items[0];

int noi = noutput_items * d_vlen;

return noutput_items;

}

class BLOCKS_API nlog10_ff_impl : public nlog10_ff

{

size_t d_vlen;

float d_k;

public:

nlog10_ff_impl(float n, size_t vlen, float k);

int work(int noutput_items,

gr_vector_const_void_star &input_items,

d_new_in = 0;

d_last_out = 0;

srand48(time(NULL));

}

test_tag_variable_rate_ff_impl::~test_tag_variable_rate_ff_impl()

GR_LOG_DEBUG(d_logger, boost::format("noutput_items: %1%") % noutput_items);

if(d_update_once) {

if(drand48() > 0.5) {

d_rrate += d_update_step;

}

else {

while(i < ninput_items[0]) {

if(!d_update_once) {

if(drand48() > 0.5) {

d_rrate += d_update_step;

}

else {

self.tb = None

def test_001(self):

src = blocks.vector_source_f(src_data)

op = blocks.nlog10_ff(10)

dst = blocks.vector_sink_f()

self.tb.connect (src, op, dst)

self.tb.run()

result_data = dst.data()

if __name__ == '__main__':

# Copyright 2011 Free Software Foundation, Inc.

# This file is part of GNU Radio

# GNU Radio 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 3, or (at your option)

# any later version.

# GNU Radio 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 GNU Radio; see the file COPYING. If not, write to

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

if(ENABLE_PYTHON)

add_subdirectory(swig)

add_subdirectory(python/digital)

add_subdirectory(grc)

add_subdirectory(examples)

endif(ENABLE_PYTHON)

# OFDM

GR_PYTHON_INSTALL(PROGRAMS

ofdm/benchmark_add_channel.py

ofdm/receive_path.py

ofdm/transmit_path.py

ofdm/uhd_interface.py

DESTINATION ${GR_PKG_DIGITAL_EXAMPLES_DIR}/ofdm

)

demod/mpsk_demod.grc

demod/pam_sync.grc

demod/pam_timing.grc

demod/test_corr_est.grc

DESTINATION ${GR_PKG_DIGITAL_EXAMPLES_DIR}/demod

)