AC_INIT

AC_PREREQ(2.57)

AM_CONFIG_HEADER(config.h)

AC_CONFIG_SRCDIR([gnuradio-core/src/lib/runtime/gr_vmcircbuf.cc])

GRC_GR_UTILS dnl this must come after GRC_GR_WXGUI

GRC_GNURADIO_EXAMPLES dnl must come after all GRC_GR_*

GRC_GRC

GRC_DOCS dnl must be last

# Each component is now either to be built, was skipped, will be

@abs_top_builddir@/docs/doxygen/xml-swig \

@abs_top_builddir@/docs/doxygen/other/doxypy.py \

@abs_top_builddir@/dtools \

@abs_top_builddir@/gnuradio-core/src/lib/bug_work_around_6.cc \

@abs_top_builddir@/gnuradio-core/src/lib/filter/assembly.h \

@abs_top_builddir@/gnuradio-core/src/lib/filter/generate_all.py \

@abs_top_builddir@/usrp/host/misc \

@abs_top_builddir@/usrp/host/swig \

@abs_top_builddir@/usrp2/firmware \

# The EXCLUDE_SYMLINKS tag can be used select whether or not files or

# directories that are symbolic links (a Unix filesystem feature) are excluded

gr_descrambler_bb.cc \

gr_scrambler_bb.cc \

gr_probe_mpsk_snr_c.cc \

libgeneral_qa_la_SOURCES = \

qa_general.cc \

gr_descrambler_bb.h \

gr_scrambler_bb.h \

gr_probe_mpsk_snr_c.h \

noinst_HEADERS = \

qa_general.h \

gr_descrambler_bb.i \

gr_scrambler_bb.i \

gr_probe_mpsk_snr_c.i \

endif

#include <gr_copy.h>

#include <gr_fll_band_edge_cc.h>

#include <gr_additive_scrambler_bb.h>

%}

%include "gr_nop.i"

%include "gr_copy.i"

%include "gr_fll_band_edge_cc.i"

%include "gr_additive_scrambler_bb.i"

: gr_block ("keep_one_in_n",

gr_make_io_signature (1, 1, item_size),

gr_make_io_signature (1, 1, item_size)),

{

}

void

d_n = n;

d_count = n;

}

int

gr_udp_source.cc \

gr_wavfile_sink.cc \

gr_wavfile_source.cc \

grinclude_HEADERS = \

gr_file_sink.h \

gr_udp_source.h \

gr_wavfile_source.h \

gr_wavfile_sink.h \

if PYTHON

swiginclude_HEADERS = \

gr_udp_sink.i \

gr_udp_source.i \

gr_wavfile_source.i \

endif

#include <gr_udp_source.h>

#include <gr_wavfile_sink.h>

#include <gr_wavfile_source.h>

%}

%include "gr_file_sink_base.i"

%include "gr_udp_source.i"

%include "gr_wavfile_sink.i"

%include "gr_wavfile_source.i"

gr_vmcircbuf_mmap_tmpfile.cc \

gr_vmcircbuf_createfilemapping.cc \

gr_vmcircbuf_sysv_shm.cc \

libruntime_qa_la_SOURCES = \

qa_gr_block.cc \

qa_gr_top_block.cc \

qa_gr_io_signature.cc \

qa_gr_vmcircbuf.cc \

qa_runtime.cc

grinclude_HEADERS = \

gr_tmp_path.h \

gr_types.h \

gr_unittests.h \

noinst_HEADERS = \

gr_vmcircbuf_mmap_shm_open.h \

qa_gr_io_signature.h \

qa_gr_top_block.h \

qa_gr_vmcircbuf.h \

qa_runtime.h

if PYTHON

/* -*- c++ -*- */

/*

*

* This file is part of GNU Radio

*

d_output_multiple (1),

d_relative_rate (1.0),

d_history(1),

{

}

throw std::runtime_error("Unimplemented");

}

std::ostream&

operator << (std::ostream& os, const gr_block *m)

{

/* -*- c++ -*- */

/*

*

* This file is part of GNU Radio

*

WORK_DONE = -1

};

virtual ~gr_block ();

/*!

*/

virtual int fixed_rate_noutput_to_ninput(int noutput);

// ----------------------------------------------------------------------------

private:

gr_block_detail_sptr d_detail; // implementation details

unsigned d_history;

bool d_fixed_rate;

protected:

void set_fixed_rate(bool fixed_rate){ d_fixed_rate = fixed_rate; }

// These are really only for internal use, but leaving them public avoids

// having to work up an ever-varying list of friends

/* -*- c++ -*- */

/*

*

* This file is part of GNU Radio

*

bool start();

bool stop();

// internal use

gr_block_detail_sptr detail () const { return d_detail; }

void set_detail (gr_block_detail_sptr detail) { d_detail = detail; }

/* -*- c++ -*- */

/*

*

* This file is part of GNU Radio

*

#include <gr_block_detail.h>

#include <gr_buffer.h>

static long s_ncurrently_allocated = 0;

long

void

gr_block_detail::consume (int which_input, int how_many_items)

{

input (which_input)->update_read_pointer (how_many_items);

}

void

gr_block_detail::consume_each (int how_many_items)

{

d_input[i]->update_read_pointer (how_many_items);

}

void

void

gr_block_detail::produce_each (int how_many_items)

{

d_output[i]->update_write_pointer (how_many_items);

d_produce_or |= how_many_items;

}

}

void

{

d_tpb.insert_tail(msg);

}

/* -*- c++ -*- */

/*

*

* This file is part of GNU Radio

*

#include <gr_runtime_types.h>

#include <gr_tpb_detail.h>

#include <stdexcept>

/*!

*/

void _post(pmt::pmt_t msg);

gr_tpb_detail d_tpb; // used by thread-per-block scheduler

int d_produce_or;

std::vector<gr_buffer_sptr> d_output;

bool d_done;

gr_block_detail (unsigned int ninputs, unsigned int noutputs);

friend class gr_tpb_detail;

/* -*- c++ -*- */

/*

*

* This file is part of GNU Radio

*

return min_space;

}

gr_block_executor::gr_block_executor (gr_block_sptr block)

: d_block(block), d_log(0)

d_input_items.resize (0);

d_input_done.resize(0);

d_output_items.resize (d->noutputs ());

// determine the minimum available output space

noutput_items = min_available_space (d, m->output_multiple ());

d_input_items.resize (d->ninputs ());

d_input_done.resize(d->ninputs());

d_output_items.resize (0);

LOG(*d_log << " sink\n");

max_items_avail = 0;

d_input_items.resize (d->ninputs ());

d_input_done.resize(d->ninputs());

d_output_items.resize (d->noutputs ());

max_items_avail = 0;

for (int i = 0; i < d->ninputs (); i++){

for (int i = 0; i < d->noutputs (); i++)

d_output_items[i] = d->output(i)->write_pointer();

// Do the actual work of the block

int n = m->general_work (noutput_items, d_ninput_items,

d_input_items, d_output_items);

LOG(*d_log << " general_work: noutput_items = " << noutput_items

<< " result = " << n << std::endl);

if (n == gr_block::WORK_DONE)

goto were_done;

#include <gr_runtime_types.h>

#include <fstream>

//class gr_block_executor;

//typedef boost::shared_ptr<gr_block_executor> gr_block_executor_sptr;

gr_vector_const_void_star d_input_items;

std::vector<bool> d_input_done;

gr_vector_void_star d_output_items;

public:

gr_block_executor(gr_block_sptr block);

/* -*- c++ -*- */

/*

*

* This file is part of GNU Radio

*

gr_buffer::gr_buffer (int nitems, size_t sizeof_item, gr_block_sptr link)

: d_base (0), d_bufsize (0), d_vmcircbuf (0),

d_sizeof_item (sizeof_item), d_link(link),

{

if (!allocate_buffer (nitems, sizeof_item))

throw std::bad_alloc ();

// Find out the maximum amount of data available to our readers

int most_data = d_readers[0]->items_available ();

most_data = std::max (most_data, d_readers[i]->items_available ());

// The -1 ensures that the case d_write_index == d_read_index is

// unambiguous. It indicates that there is no data for the reader

{

gruel::scoped_lock guard(*mutex());

d_write_index = index_add (d_write_index, nitems);

}

void

d_readers.erase (result);

}

long

gr_buffer_ncurrently_allocated ()

{

gr_buffer_reader::gr_buffer_reader(gr_buffer_sptr buffer, unsigned int read_index,

gr_block_sptr link)

{

s_buffer_reader_count++;

}

{

gruel::scoped_lock guard(*mutex());

d_read_index = d_buffer->index_add (d_read_index, nitems);

}

long

/* -*- c++ -*- */

/*

*

* This file is part of GNU Radio

*

#include <gr_runtime_types.h>

#include <boost/weak_ptr.hpp>

#include <gruel/thread.h>

class gr_vmcircbuf;

gruel::mutex *mutex() { return &d_mutex; }

// -------------------------------------------------------------------------

private:

boost::weak_ptr<gr_block> d_link; // block that writes to this buffer

//

//

gruel::mutex d_mutex;

unsigned int d_write_index; // in items [0,d_bufsize)

bool d_done;

unsigned

index_add (unsigned a, unsigned b)

gruel::mutex *mutex() { return d_buffer->mutex(); }

/*!

* \brief Return the block that reads via this reader.

*/

gr_block_sptr link() { return gr_block_sptr(d_link); }

// -------------------------------------------------------------------------

private:

gr_buffer_sptr d_buffer;

unsigned int d_read_index; // in items [0,d->buffer.d_bufsize)

boost::weak_ptr<gr_block> d_link; // block that reads via this buffer reader

//! constructor is private. Use gr_buffer::add_reader to create instances

int no = detail->noutputs();

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

gr_buffer_sptr buffer = detail->output(i);

}

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

gr_buffer_reader_sptr reader = detail->input(i);

std::cout << " reader " << i << ": " << reader

}

}

#include <qa_gr_hier_block2.h>

#include <qa_gr_hier_block2_derived.h>

#include <qa_gr_buffer.h>

CppUnit::TestSuite *

qa_runtime::suite ()

s->addTest (qa_gr_hier_block2::suite ());

s->addTest (qa_gr_hier_block2_derived::suite ());

s->addTest (qa_gr_buffer::suite ());

return s;

}

MAJOR_VERSION=3

MAINT_VERSION=0

#!/usr/bin/env python

#

#

# This file is part of GNU Radio

#

from optparse import OptionParser

from scipy import log10

class gr_plot_psd:

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

''' Need to do this here and plot later so we can do the fftshift '''

overlap = self.psdfftsize/4

winfunc = scipy.blackman

return (psd, freq)

def make_plots(self):

def draw_psd(self):

self.plot_psd[0].set_data([self.freq, self.iq_psd])

self.sp_psd.set_ylim([min(self.iq_psd)-10, max(self.iq_psd)+10])

def draw_spec(self):

overlap = self.specfftsize/4

usage="%prog: [options] input_filename"

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

parser.add_option("-d", "--data-type", type="string", default="complex64",

help="Specify the data type (complex64, float32, (u)int32, (u)int16, (u)int8) [default=%default]")

parser.add_option("-B", "--block", type="int", default=8192,

help="Specify the block size [default=%default]")

parser.add_option("-s", "--start", type="int", default=0,

help="Specify where to start in the file [default=%default]")

help="Set the sampler rate of the data [default=%default]")

parser.add_option("", "--psd-size", type="int", default=1024,

help="Set the size of the PSD FFT [default=%default]")

try: assert set(opt_keys) == set(option.get_opt_keys())

except AssertionError: raise Exception, 'Opt keys "%s" are not identical across all options.'%opt_keys

#if a value is specified, it must be in the options keys

try: assert self.get_value() in self.get_option_keys()

except AssertionError: raise Exception, 'The value "%s" is not in the possible values of "%s".'%(self.get_value(), self.get_option_keys())

else: self._value = value or ''

def write(self):

#do throttle warning

all_keys = ' '.join(map(lambda b: b.get_key(), self._flow_graph.get_enabled_blocks()))

Messages.send_warning('''\

This flow graph may not have flow control: no audio or usrp blocks found. \

Add a Misc->Throttle block to your flow graph to avoid CPU congestion.''')

*/

std::vector< std::vector<db_base_sptr> > d_db;

void init_db(usrp_basic_sptr u);

MAJOR_VERSION=3