diff options
26 files changed, 1538 insertions, 60 deletions
diff --git a/gnuradio-runtime/include/gnuradio/rpcregisterhelpers.h b/gnuradio-runtime/include/gnuradio/rpcregisterhelpers.h index 4431d15bd8..92adc0b768 100644 --- a/gnuradio-runtime/include/gnuradio/rpcregisterhelpers.h +++ b/gnuradio-runtime/include/gnuradio/rpcregisterhelpers.h @@ -95,6 +95,36 @@ public: // Specialized Extractor Templates template<typename T> +class rpcbasic_extractor<T,char> : public virtual rpcextractor_base<T,char> +{ +public: + rpcbasic_extractor(T* source, void (T::*func)(char)) + : rpcextractor_base<T,char>(source, func) + {;} + + void post(pmt::pmt_t which_port, pmt::pmt_t msg) + { + (rpcextractor_base<T,char>::_source->*rpcextractor_base<T,char>::_func) + (static_cast<char>(pmt::to_long(msg))); + } +}; + +template<typename T> +class rpcbasic_extractor<T,short> : public virtual rpcextractor_base<T,short> +{ +public: + rpcbasic_extractor(T* source, void (T::*func)(short)) + : rpcextractor_base<T,short>(source, func) + {;} + + void post(pmt::pmt_t which_port, pmt::pmt_t msg) + { + (rpcextractor_base<T,short>::_source->*rpcextractor_base<T,char>::_func) + (static_cast<short>(pmt::to_long(msg))); + } +}; + +template<typename T> class rpcbasic_extractor<T,double> : public virtual rpcextractor_base<T,double> { public: @@ -238,6 +268,50 @@ public: }; template<typename T> +class rpcbasic_inserter<T,std::vector< signed char > > + : public virtual rpcinserter_base<T,std::vector< signed char > > +{ +public: + rpcbasic_inserter(T* source, std::vector< signed char > (T::*func)() const) + : rpcinserter_base<T,std::vector< signed char > >(source, func) + {;} + + rpcbasic_inserter(T* source, std::vector< signed char > (T::*func)()) + : rpcinserter_base<T,std::vector< signed char > >(source, func) + {;} + + pmt::pmt_t retrieve() + { + std::vector< signed char > + vec((rpcinserter_base<T,std::vector< signed char > >:: + _source->*rpcinserter_base<T,std::vector< signed char > >::_func)()); + return pmt::init_s8vector(vec.size(), &vec[0]); + } +}; + +template<typename T> +class rpcbasic_inserter<T,std::vector< short > > + : public virtual rpcinserter_base<T,std::vector< short > > +{ +public: + rpcbasic_inserter(T* source, std::vector< short > (T::*func)() const) + : rpcinserter_base<T,std::vector< short > >(source, func) + {;} + + rpcbasic_inserter(T* source, std::vector< short > (T::*func)()) + : rpcinserter_base<T,std::vector< short > >(source, func) + {;} + + pmt::pmt_t retrieve() + { + std::vector< short > + vec((rpcinserter_base<T,std::vector< short > >:: + _source->*rpcinserter_base<T,std::vector< short > >::_func)()); + return pmt::init_s16vector(vec.size(), &vec[0]); + } +}; + +template<typename T> class rpcbasic_inserter<T,std::vector< int > > : public virtual rpcinserter_base<T,std::vector< int > > { @@ -354,7 +428,7 @@ public: : rpcinserter_base<T,std::complex<double> >(source, func) {;} - pmt::pmt_t retrieve() + pmt::pmt_t retrieve() { std::complex<double > k((rpcinserter_base<T,std::complex<double> >:: _source->*rpcinserter_base<T,std::complex<double> >::_func)()); diff --git a/gnuradio-runtime/lib/controlport/gnuradio.ice b/gnuradio-runtime/lib/controlport/gnuradio.ice index 8318875926..3d6101087a 100644 --- a/gnuradio-runtime/lib/controlport/gnuradio.ice +++ b/gnuradio-runtime/lib/controlport/gnuradio.ice @@ -35,6 +35,7 @@ class Knob {}; class KnobB extends Knob { bool value; }; class KnobC extends Knob { byte value; }; class KnobI extends Knob { int value; }; +class KnobT extends Knob { short value; }; class KnobF extends Knob { float value; }; class KnobD extends Knob { double value; }; class KnobL extends Knob { long value; }; @@ -44,11 +45,12 @@ class KnobZ extends Knob { complex value; }; sequence<bool> VectorB; sequence<byte> VectorC; sequence<int> VectorI; sequence<float> VectorF; sequence<double> VectorD; sequence<string> VectorS; -sequence<long> VectorL; +sequence<long> VectorL; sequence<short> VectorT; class KnobVecB extends Knob { VectorB value; }; class KnobVecC extends Knob { VectorC value; }; class KnobVecI extends Knob { VectorI value; }; +class KnobVecT extends Knob { VectorT value; }; class KnobVecF extends Knob { VectorF value; }; class KnobVecD extends Knob { VectorD value; }; class KnobVecL extends Knob { VectorL value; }; @@ -57,7 +59,7 @@ class KnobVecS extends Knob { VectorS value; }; enum KnobType { KNOBBOOL, KNOBCHAR, KNOBINT, KNOBFLOAT, KNOBDOUBLE, KNOBSTRING, KNOBLONG, KNOBVECBOOL, KNOBVECCHAR, KNOBVECINT, KNOBVECFLOAT, KNOBVECDOUBLE, - KNOBVECSTRING, KNOBVECLONG }; + KNOBVECSTRING, KNOBVECLONG, KNOBSHORT}; const int DISPNULL = 0x0000; const int DISPTIME = 0x0001; diff --git a/gnuradio-runtime/lib/controlport/rpcpmtconverters_ice.cc b/gnuradio-runtime/lib/controlport/rpcpmtconverters_ice.cc index ca6a769f48..efd2a5599c 100644 --- a/gnuradio-runtime/lib/controlport/rpcpmtconverters_ice.cc +++ b/gnuradio-runtime/lib/controlport/rpcpmtconverters_ice.cc @@ -60,6 +60,11 @@ rpcpmtconverter::from_pmt(const pmt::pmt_t& knob, const Ice::Current& c) const int* start((const int*) pmt::s32vector_elements(knob,size)); return new GNURadio::KnobVecI(std::vector<int>(start,start+size)); } + else if (pmt::is_s16vector(knob)) { + size_t size(pmt::length(knob)); + const short* start((const short*) pmt::s16vector_elements(knob,size)); + return new GNURadio::KnobVecT(std::vector<short>(start,start+size)); + } else if(pmt::is_f32vector(knob)) { size_t size(pmt::length(knob)); const float* start((const float*) pmt::f32vector_elements(knob,size)); @@ -70,6 +75,11 @@ rpcpmtconverter::from_pmt(const pmt::pmt_t& knob, const Ice::Current& c) const uint8_t* start((const uint8_t*) pmt::u8vector_elements(knob,size)); return new GNURadio::KnobVecC(std::vector<Ice::Byte>(start,start+size)); } + else if (pmt::is_s8vector(knob)) { + size_t size(pmt::length(knob)); + const int8_t* start((const int8_t*) pmt::s8vector_elements(knob,size)); + return new GNURadio::KnobVecC(std::vector<Ice::Byte>(start,start+size)); + } else { std::cerr << "Error: Don't know how to handle Knob Type (from): " << std::endl; assert(0);} //TODO: VECTORS!!! @@ -92,6 +102,10 @@ rpcpmtconverter::to_pmt(const GNURadio::KnobPtr& knob, const Ice::Current& c) GNURadio::KnobIPtr k(GNURadio::KnobIPtr::dynamicCast(knob)); return pmt::mp(k->value); } + else if(id == "KnobT") { + GNURadio::KnobTPtr k(GNURadio::KnobTPtr::dynamicCast(knob)); + return pmt::mp(k->value); + } else if(id == "KnobS") { GNURadio::KnobSPtr k(GNURadio::KnobSPtr::dynamicCast(knob)); return pmt::string_to_symbol(k->value); diff --git a/gnuradio-runtime/python/gnuradio/ctrlport/GrDataPlotter.py b/gnuradio-runtime/python/gnuradio/ctrlport/GrDataPlotter.py index b240dcb8f2..069f3d90ff 100644 --- a/gnuradio-runtime/python/gnuradio/ctrlport/GrDataPlotter.py +++ b/gnuradio-runtime/python/gnuradio/ctrlport/GrDataPlotter.py @@ -24,7 +24,7 @@ from gnuradio import gr from gnuradio import blocks from gnuradio import filter from gnuradio.ctrlport import GNURadio -import sys, time +import sys, time, struct try: from gnuradio import qtgui @@ -426,12 +426,17 @@ class GrDataPlotterValueTable: numItems = self.treeWidget.topLevelItemCount() # The input knobs variable is a dict of stats to display in the tree. - - # Update tree stat values with new values found in knobs. - # Track found keys and track keys in tree that are not in input knobs. - for i in range(0, numItems): - item = self.treeWidget.topLevelItem(i) - + self.treeWidget.clear() + for k, v in knobs.iteritems(): + val = v.value + if(type(val) == GNURadio.complex): + val = val.re + val.im*1j + + # If it's a byte stream, Python thinks it's a string. + # Unpack and convert to floats for plotting. + # Ignore the edge list knob if it's being exported + elif(type(val) == str and k.find('edge list') == -1): + val = struct.unpack(len(val)*'b', val) # itemKey is the text in the first column of a QTreeWidgetItem itemKey = str(item.text(0)) if itemKey in knobs.keys(): diff --git a/gnuradio-runtime/python/gnuradio/ctrlport/gr-ctrlport-monitor b/gnuradio-runtime/python/gnuradio/ctrlport/gr-ctrlport-monitor index a8732b4c93..5f23a3d5c4 100755 --- a/gnuradio-runtime/python/gnuradio/ctrlport/gr-ctrlport-monitor +++ b/gnuradio-runtime/python/gnuradio/ctrlport/gr-ctrlport-monitor @@ -24,7 +24,7 @@ from gnuradio import gr, ctrlport from PyQt4 import QtCore,Qt import PyQt4.QtGui as QtGui -import os, sys, time +import os, sys, time, struct import Ice from gnuradio.ctrlport.IceRadioClient import * @@ -109,23 +109,8 @@ class MAINWindow(QtGui.QMainWindow): title = "{0}:{1}".format(r[3], r[5]) props = radio.properties([key]) - pmin = props[key].min.value - pmax = props[key].max.value - # Convert from GNURadio::complex to Python complex - if(type(pmin) == GNURadio.complex): - pmin = pmin.re + pmin.im*1j - if(type(pmax) == GNURadio.complex): - pmax = pmax.re + pmax.im*1j - - if pmin == []: - pmin = None - else: - pmin = 1.1*abs(pmin) - if pmax == []: - pmax = None - else: - pmax = 1.1*abs(pmax) + pmin,pmax = get_minmax(props[key]) # Use display option mask of item to set up available plot # types and default options. @@ -197,22 +182,7 @@ class MAINWindow(QtGui.QMainWindow): r = str(tree.radio).split(" ") title = "{0}:{1}".format(r[3], r[5]) - pmin = knobprop.min.value - pmax = knobprop.max.value - - if(type(pmin) == GNURadio.complex): - pmin = pmin.re + pmin.im*1j - if(type(pmax) == GNURadio.complex): - pmax = pmax.re + pmax.im*1j - - if pmin == []: - pmin = None - else: - pmin = 1.1*pmin - if pmax == []: - pmax = None - else: - pmax = 1.1*pmax + pmin,pmax = get_minmax(knobprop) disp = knobprop.display if(disp & gr.DISPTIME): @@ -337,6 +307,13 @@ class MAINWindow(QtGui.QMainWindow): d = knobs[n].value if(type(d) == GNURadio.complex): d = [d.re, d.im] + + # If it's a byte stream, Python thinks it's a string. + # Unpack and convert to floats for plotting. + if(type(d) == str): + d = struct.unpack(len(d)*'b', d) + d = [float(di) for di in d] + data.append(d) plot.update(data) plot.stop() @@ -738,6 +715,33 @@ class MForm(QtGui.QWidget): self.parent.propertiesMenu(itemname, self.radio, self.uid) +def get_minmax(p): + pmin = p.min.value + pmax = p.max.value + + # Find min/max or real or imag for GNURadio::complex + if(type(pmin) == GNURadio.complex): + pmin = min(pmin.re, pmin.im) + if(type(pmax) == GNURadio.complex): + pmax = max(pmax.re, pmax.im) + + # If it's a byte stream, Python thinks it's a string. + if(type(pmin) == str): + pmin = struct.unpack('b', pmin)[0] + if(type(pmax) == str): + pmax = struct.unpack('b', pmax)[0] + + if pmin == []: + pmin = None + else: + pmin = 1.1*float(pmin) + if pmax == []: + pmax = None + else: + pmax = 1.1*float(pmax) + + return pmin, pmax + class MyClient(IceRadioClient): def __init__(self): IceRadioClient.__init__(self, MAINWindow) diff --git a/gr-blocks/grc/blocks_block_tree.xml b/gr-blocks/grc/blocks_block_tree.xml index 150b3f1c93..4ba15e7dbc 100644 --- a/gr-blocks/grc/blocks_block_tree.xml +++ b/gr-blocks/grc/blocks_block_tree.xml @@ -53,6 +53,7 @@ <name>Control Port</name> <block>blocks_ctrlport_monitor</block> <block>blocks_ctrlport_monitor_performance</block> + <block>blocks_ctrlport_probe2_x</block> <block>blocks_ctrlport_probe2_c</block> <block>blocks_ctrlport_probe_c</block> </cat> diff --git a/gr-blocks/grc/blocks_ctrlport_probe2_c.xml b/gr-blocks/grc/blocks_ctrlport_probe2_c.xml index 3add69aa7b..b5f0b089a7 100644 --- a/gr-blocks/grc/blocks_ctrlport_probe2_c.xml +++ b/gr-blocks/grc/blocks_ctrlport_probe2_c.xml @@ -1,7 +1,7 @@ <?xml version="1.0"?> <!-- - Copyright 2012 Free Software Foundation, Inc. + Copyright 2012-2013 Free Software Foundation, Inc. This file is part of GNU Radio @@ -22,23 +22,23 @@ --> <block> - <name>Ctrlport Complex Probe (fixed len)</name> + <name>Ctrlport Probe</name> <key>blocks_ctrlport_probe2_c</key> <import>from gnuradio import blocks</import> - <make>blocks.ctrlport_probe2_c($name, $desc, $len)</make> + <make>blocks.ctrlport_probe2_c($name, $desc, $len, $disp_mask)</make> <callback>set_length($len)</callback> <param> <name>Name</name> <key>name</key> - <value>constellation</value> + <value>samples</value> <type>string</type> </param> <param> <name>Description</name> <key>desc</key> - <value>Constellation Points</value> + <value>Sample Points</value> <type>string</type> </param> @@ -49,6 +49,32 @@ <type>int</type> </param> + <param> + <name>Display Mask</name> + <key>disp_mask</key> + <value>gr.DISPTIME</value> + <type>int</type> + <option> + <name>Constellation</name> + <key>gr.DISPXY | gr.DISPOPTSCATTER</key> + </option> + <option> + <name>Time</name> + <key>gr.DISPTIME</key> + </option> + <option> + <name>PSD</name> + <key>gr.DISPPSD</key> + </option> + <option> + <name>Spectrogram</name> + <key>gr.DISPSPEC</key> + </option> + <option> + <name>Raster</name> + <key>gr.DISPRAST</key> + </option> + </param> <sink> <name>in</name> @@ -56,9 +82,10 @@ </sink> <doc> - Place this in a graph to export complex values to a GRCP port probe. + Place this in a graph to export vectors of samples to a GRCP port probe. - * Version 2 allows you to specify a length in samples that you wish to get every probe + * Specify the number of samples to transmit at once and the type + of default display to use. </doc> </block> diff --git a/gr-blocks/grc/blocks_ctrlport_probe2_x.xml b/gr-blocks/grc/blocks_ctrlport_probe2_x.xml new file mode 100644 index 0000000000..b9b1660bc9 --- /dev/null +++ b/gr-blocks/grc/blocks_ctrlport_probe2_x.xml @@ -0,0 +1,123 @@ +<?xml version="1.0"?> + +<!-- + Copyright 2013 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, + Boston, MA 02110-1301, USA. +--> + +<block> + <name>Ctrlport Probe</name> + <key>blocks_ctrlport_probe2_x</key> + <import>from gnuradio import blocks</import> + <make>blocks.ctrlport_probe2_$(type.fcn)($name, $desc, $len, $disp_mask)</make> + <callback>set_length($len)</callback> + + <param> + <name>Input Type</name> + <key>type</key> + <type>enum</type> + <option> + <name>Complex</name> + <key>complex</key> + <opt>fcn:c</opt> + </option> + <option> + <name>Float</name> + <key>float</key> + <opt>fcn:f</opt> + </option> + <option> + <name>Int</name> + <key>int</key> + <opt>fcn:i</opt> + </option> + <option> + <name>Short</name> + <key>short</key> + <opt>fcn:s</opt> + </option> + <option> + <name>Byte</name> + <key>byte</key> + <opt>fcn:b</opt> + </option> + </param> + + <param> + <name>Name</name> + <key>name</key> + <value>samples</value> + <type>string</type> + </param> + + <param> + <name>Description</name> + <key>desc</key> + <value>Sample Points</value> + <type>string</type> + </param> + + <param> + <name>Length</name> + <key>len</key> + <value>1024</value> + <type>int</type> + </param> + + <param> + <name>Display Mask</name> + <key>disp_mask</key> + <value>gr.DISPTIME</value> + <type>int</type> + <option> + <name>Constellation</name> + <key>gr.DISPXY | gr.DISPOPTSCATTER</key> + </option> + <option> + <name>Time</name> + <key>gr.DISPTIME</key> + </option> + <option> + <name>PSD</name> + <key>gr.DISPPSD</key> + </option> + <option> + <name>Spectrogram</name> + <key>gr.DISPSPEC</key> + </option> + <option> + <name>Raster</name> + <key>gr.DISPRAST</key> + </option> + </param> + + <sink> + <name>in</name> + <type>$type</type> + </sink> + + <doc> + Place this in a graph to export vectors of samples to a GRCP port probe. + + * Specify the number of samples to transmit at once and the type + of default display to use. + </doc> + +</block> + diff --git a/gr-blocks/include/gnuradio/blocks/CMakeLists.txt b/gr-blocks/include/gnuradio/blocks/CMakeLists.txt index 13e1ac71b8..fb0b6a2a1c 100644 --- a/gr-blocks/include/gnuradio/blocks/CMakeLists.txt +++ b/gr-blocks/include/gnuradio/blocks/CMakeLists.txt @@ -213,6 +213,10 @@ if(ENABLE_GR_CTRLPORT) install(FILES ctrlport_probe_c.h ctrlport_probe2_c.h + ctrlport_probe2_f.h + ctrlport_probe2_s.h + ctrlport_probe2_i.h + ctrlport_probe2_b.h DESTINATION ${GR_INCLUDE_DIR}/gnuradio/blocks COMPONENT "blocks_devel" ) diff --git a/gr-blocks/include/gnuradio/blocks/ctrlport_probe2_b.h b/gr-blocks/include/gnuradio/blocks/ctrlport_probe2_b.h new file mode 100644 index 0000000000..5ad31655cf --- /dev/null +++ b/gr-blocks/include/gnuradio/blocks/ctrlport_probe2_b.h @@ -0,0 +1,69 @@ +/* -*- c++ -*- */ +/* + * Copyright 2013 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, + * Boston, MA 02110-1301, USA. + */ + +#ifndef INCLUDED_CTRLPORT_PROBE2_B_H +#define INCLUDED_CTRLPORT_PROBE2_B_H + +#include <gnuradio/blocks/api.h> +#include <gnuradio/sync_block.h> + +namespace gr { + namespace blocks { + + /*! + * \brief A ControlPort probe to export vectors of signals. + * \ingroup measurement_tools_blk + * \ingroup controlport_blk + * + * \details + * This block acts as a sink in the flowgraph but also exports + * vectors of complex samples over ControlPort. This block holds + * the latest \p len number of complex samples so that every query + * by a ControlPort client will get the same length vector. + */ + class BLOCKS_API ctrlport_probe2_b : virtual public sync_block + { + public: + // gr::blocks::ctrlport_probe2_b::sptr + typedef boost::shared_ptr<ctrlport_probe2_b> sptr; + + /*! + * \brief Make a ControlPort probe block. + * \param id A string ID to name the probe over ControlPort. + * \param desc A string describing the probe. + * \param len Number of samples to transmit. + * \param disp_mask Mask to set default display params. + */ + static sptr make(const std::string &id, const std::string &desc, + int len, unsigned int disp_mask); + + virtual std::vector<signed char> get() = 0; + + virtual void set_length(int len) = 0; + virtual int length() const = 0; + }; + + } /* namespace blocks */ +} /* namespace gr */ + +#endif /* INCLUDED_CTRLPORT_PROBE2_B_H */ + diff --git a/gr-blocks/include/gnuradio/blocks/ctrlport_probe2_c.h b/gr-blocks/include/gnuradio/blocks/ctrlport_probe2_c.h index 3841c43b74..51d908b47a 100644 --- a/gr-blocks/include/gnuradio/blocks/ctrlport_probe2_c.h +++ b/gr-blocks/include/gnuradio/blocks/ctrlport_probe2_c.h @@ -51,8 +51,10 @@ namespace gr { * \param id A string ID to name the probe over ControlPort. * \param desc A string describing the probe. * \param len Number of samples to transmit. + * \param disp_mask Mask to set default display params. */ - static sptr make(const std::string &id, const std::string &desc, int len); + static sptr make(const std::string &id, const std::string &desc, + int len, unsigned int disp_mask); virtual std::vector<gr_complex> get() = 0; diff --git a/gr-blocks/include/gnuradio/blocks/ctrlport_probe2_f.h b/gr-blocks/include/gnuradio/blocks/ctrlport_probe2_f.h new file mode 100644 index 0000000000..38d1906ed0 --- /dev/null +++ b/gr-blocks/include/gnuradio/blocks/ctrlport_probe2_f.h @@ -0,0 +1,69 @@ +/* -*- c++ -*- */ +/* + * Copyright 2013 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, + * Boston, MA 02110-1301, USA. + */ + +#ifndef INCLUDED_CTRLPORT_PROBE2_F_H +#define INCLUDED_CTRLPORT_PROBE2_F_H + +#include <gnuradio/blocks/api.h> +#include <gnuradio/sync_block.h> + +namespace gr { + namespace blocks { + + /*! + * \brief A ControlPort probe to export vectors of signals. + * \ingroup measurement_tools_blk + * \ingroup controlport_blk + * + * \details + * This block acts as a sink in the flowgraph but also exports + * vectors of complex samples over ControlPort. This block holds + * the latest \p len number of complex samples so that every query + * by a ControlPort client will get the same length vector. + */ + class BLOCKS_API ctrlport_probe2_f : virtual public sync_block + { + public: + // gr::blocks::ctrlport_probe2_f::sptr + typedef boost::shared_ptr<ctrlport_probe2_f> sptr; + + /*! + * \brief Make a ControlPort probe block. + * \param id A string ID to name the probe over ControlPort. + * \param desc A string describing the probe. + * \param len Number of samples to transmit. + * \param disp_mask Mask to set default display params. + */ + static sptr make(const std::string &id, const std::string &desc, + int len, unsigned int disp_mask); + + virtual std::vector<float> get() = 0; + + virtual void set_length(int len) = 0; + virtual int length() const = 0; + }; + + } /* namespace blocks */ +} /* namespace gr */ + +#endif /* INCLUDED_CTRLPORT_PROBE2_F_H */ + diff --git a/gr-blocks/include/gnuradio/blocks/ctrlport_probe2_i.h b/gr-blocks/include/gnuradio/blocks/ctrlport_probe2_i.h new file mode 100644 index 0000000000..cdfb1b86a4 --- /dev/null +++ b/gr-blocks/include/gnuradio/blocks/ctrlport_probe2_i.h @@ -0,0 +1,69 @@ +/* -*- c++ -*- */ +/* + * Copyright 2013 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, + * Boston, MA 02110-1301, USA. + */ + +#ifndef INCLUDED_CTRLPORT_PROBE2_I_H +#define INCLUDED_CTRLPORT_PROBE2_I_H + +#include <gnuradio/blocks/api.h> +#include <gnuradio/sync_block.h> + +namespace gr { + namespace blocks { + + /*! + * \brief A ControlPort probe to export vectors of signals. + * \ingroup measurement_tools_blk + * \ingroup controlport_blk + * + * \details + * This block acts as a sink in the flowgraph but also exports + * vectors of complex samples over ControlPort. This block holds + * the latest \p len number of complex samples so that every query + * by a ControlPort client will get the same length vector. + */ + class BLOCKS_API ctrlport_probe2_i : virtual public sync_block + { + public: + // gr::blocks::ctrlport_probe2_i::sptr + typedef boost::shared_ptr<ctrlport_probe2_i> sptr; + + /*! + * \brief Make a ControlPort probe block. + * \param id A string ID to name the probe over ControlPort. + * \param desc A string describing the probe. + * \param len Number of samples to transmit. + * \param disp_mask Mask to set default display params. + */ + static sptr make(const std::string &id, const std::string &desc, + int len, unsigned int disp_mask); + + virtual std::vector<int> get() = 0; + + virtual void set_length(int len) = 0; + virtual int length() const = 0; + }; + + } /* namespace blocks */ +} /* namespace gr */ + +#endif /* INCLUDED_CTRLPORT_PROBE2_I_H */ + diff --git a/gr-blocks/include/gnuradio/blocks/ctrlport_probe2_s.h b/gr-blocks/include/gnuradio/blocks/ctrlport_probe2_s.h new file mode 100644 index 0000000000..676a24822a --- /dev/null +++ b/gr-blocks/include/gnuradio/blocks/ctrlport_probe2_s.h @@ -0,0 +1,69 @@ +/* -*- c++ -*- */ +/* + * Copyright 2013 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, + * Boston, MA 02110-1301, USA. + */ + +#ifndef INCLUDED_CTRLPORT_PROBE2_S_H +#define INCLUDED_CTRLPORT_PROBE2_S_H + +#include <gnuradio/blocks/api.h> +#include <gnuradio/sync_block.h> + +namespace gr { + namespace blocks { + + /*! + * \brief A ControlPort probe to export vectors of signals. + * \ingroup measurement_tools_blk + * \ingroup controlport_blk + * + * \details + * This block acts as a sink in the flowgraph but also exports + * vectors of complex samples over ControlPort. This block holds + * the latest \p len number of complex samples so that every query + * by a ControlPort client will get the same length vector. + */ + class BLOCKS_API ctrlport_probe2_s : virtual public sync_block + { + public: + // gr::blocks::ctrlport_probe2_s::sptr + typedef boost::shared_ptr<ctrlport_probe2_s> sptr; + + /*! + * \brief Make a ControlPort probe block. + * \param id A string ID to name the probe over ControlPort. + * \param desc A string describing the probe. + * \param len Number of samples to transmit. + * \param disp_mask Mask to set default display params. + */ + static sptr make(const std::string &id, const std::string &desc, + int len, unsigned int disp_mask); + + virtual std::vector<short> get() = 0; + + virtual void set_length(int len) = 0; + virtual int length() const = 0; + }; + + } /* namespace blocks */ +} /* namespace gr */ + +#endif /* INCLUDED_CTRLPORT_PROBE2_S_H */ + diff --git a/gr-blocks/lib/CMakeLists.txt b/gr-blocks/lib/CMakeLists.txt index 529c6de054..1f16d10a0a 100644 --- a/gr-blocks/lib/CMakeLists.txt +++ b/gr-blocks/lib/CMakeLists.txt @@ -253,6 +253,10 @@ if(ENABLE_GR_CTRLPORT) list(APPEND gr_blocks_sources ctrlport_probe_c_impl.cc ctrlport_probe2_c_impl.cc + ctrlport_probe2_f_impl.cc + ctrlport_probe2_s_impl.cc + ctrlport_probe2_i_impl.cc + ctrlport_probe2_b_impl.cc ) endif(ENABLE_GR_CTRLPORT) diff --git a/gr-blocks/lib/ctrlport_probe2_b_impl.cc b/gr-blocks/lib/ctrlport_probe2_b_impl.cc new file mode 100644 index 0000000000..74c2980a7a --- /dev/null +++ b/gr-blocks/lib/ctrlport_probe2_b_impl.cc @@ -0,0 +1,162 @@ +/* -*- c++ -*- */ +/* + * Copyright 2013 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, + * Boston, MA 02110-1301, USA. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "ctrlport_probe2_b_impl.h" +#include <gnuradio/io_signature.h> + +namespace gr { + namespace blocks { + + ctrlport_probe2_b::sptr + ctrlport_probe2_b::make(const std::string &id, const std::string &desc, + int len, unsigned int disp_mask) + { + return gnuradio::get_initial_sptr + (new ctrlport_probe2_b_impl(id, desc, len, disp_mask)); + } + + ctrlport_probe2_b_impl::ctrlport_probe2_b_impl(const std::string &id, + const std::string &desc, + int len, unsigned int disp_mask) + : sync_block("probe2_b", + io_signature::make(1, 1, sizeof(char)), + io_signature::make(0, 0, 0)), + d_id(id), d_desc(desc), d_len(len), d_disp_mask(disp_mask) + { + set_length(len); + } + + ctrlport_probe2_b_impl::~ctrlport_probe2_b_impl() + { + } + + void + ctrlport_probe2_b_impl::forecast(int noutput_items, + gr_vector_int &ninput_items_required) + { + // make sure all inputs have noutput_items available + unsigned ninputs = ninput_items_required.size(); + for(unsigned i = 0; i < ninputs; i++) + ninput_items_required[i] = d_len; + } + + // boost::shared_mutex mutex_buffer; + // mutable boost::mutex mutex_notify; + // boost::condition_variable condition_buffer_ready; + std::vector<signed char> + ctrlport_probe2_b_impl::get() + { + mutex_buffer.lock(); + d_buffer.clear(); + mutex_buffer.unlock(); + + // wait for condition + boost::mutex::scoped_lock lock(mutex_notify); + condition_buffer_ready.wait(lock); + + mutex_buffer.lock(); + std::vector<signed char> buf_copy = d_buffer; + assert(buf_copy.size() == d_len); + mutex_buffer.unlock(); + + return buf_copy; + } + + void + ctrlport_probe2_b_impl::set_length(int len) + { + if(len > 8191) { + std::cerr << "probe2_b: length " << len + << " exceeds maximum buffer size of 8191" << std::endl; + len = 8191; + } + + d_len = len; + d_buffer.reserve(d_len); + } + + int + ctrlport_probe2_b_impl::length() const + { + return (int)d_len; + } + + int + ctrlport_probe2_b_impl::work(int noutput_items, + gr_vector_const_void_star &input_items, + gr_vector_void_star &output_items) + { + const char *in = (const char*)input_items[0]; + + // copy samples to get buffer if we need samples + mutex_buffer.lock(); + if(d_buffer.size() < d_len) { + // copy smaller of remaining buffer space and num inputs to work() + int num_copy = std::min( (int)(d_len - d_buffer.size()), noutput_items ); + + // TODO: convert this to a copy operator for speed... + for(int i = 0; i < num_copy; i++) { + d_buffer.push_back(in[i]); + } + + // notify the waiting get() if we fill up the buffer + if(d_buffer.size() == d_len) { + condition_buffer_ready.notify_one(); + } + } + mutex_buffer.unlock(); + + return noutput_items; + } + + void + ctrlport_probe2_b_impl::setup_rpc() + { +#ifdef GR_CTRLPORT + int len = static_cast<int>(d_len); + d_rpc_vars.push_back( + rpcbasic_sptr(new rpcbasic_register_get<ctrlport_probe2_b, std::vector<signed char> >( + alias(), d_id.c_str(), &ctrlport_probe2_b::get, + pmt::mp(-128), pmt::mp(127), pmt::mp(0), + "volts", d_desc.c_str(), RPC_PRIVLVL_MIN, + d_disp_mask))); + + d_rpc_vars.push_back( + rpcbasic_sptr(new rpcbasic_register_get<ctrlport_probe2_b, int>( + alias(), "length", &ctrlport_probe2_b::length, + pmt::mp(1), pmt::mp(10*len), pmt::mp(len), + "samples", "get vector length", RPC_PRIVLVL_MIN, DISPNULL))); + + d_rpc_vars.push_back( + rpcbasic_sptr(new rpcbasic_register_set<ctrlport_probe2_b, int>( + alias(), "length", &ctrlport_probe2_b::set_length, + pmt::mp(1), pmt::mp(10*len), pmt::mp(len), + "samples", "set vector length", RPC_PRIVLVL_MIN, DISPNULL))); +#endif /* GR_CTRLPORT */ + } + + } /* namespace blocks */ +} /* namespace gr */ diff --git a/gr-blocks/lib/ctrlport_probe2_b_impl.h b/gr-blocks/lib/ctrlport_probe2_b_impl.h new file mode 100644 index 0000000000..155dd4c23c --- /dev/null +++ b/gr-blocks/lib/ctrlport_probe2_b_impl.h @@ -0,0 +1,69 @@ +/* -*- c++ -*- */ +/* + * Copyright 2013 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, + * Boston, MA 02110-1301, USA. + */ + +#ifndef INCLUDED_CTRLPORT_PROBE2_B_IMPL_H +#define INCLUDED_CTRLPORT_PROBE2_B_IMPL_H + +#include <gnuradio/blocks/ctrlport_probe2_b.h> +#include <gnuradio/rpcregisterhelpers.h> +#include <boost/thread/shared_mutex.hpp> + +namespace gr { + namespace blocks { + + class ctrlport_probe2_b_impl : public ctrlport_probe2_b + { + private: + std::string d_id; + std::string d_desc; + size_t d_len; + unsigned int d_disp_mask; + boost::shared_mutex mutex_buffer; + mutable boost::mutex mutex_notify; + boost::condition_variable condition_buffer_ready; + + std::vector<signed char> d_buffer; + + public: + ctrlport_probe2_b_impl(const std::string &id, const std::string &desc, + int len, unsigned int disp_mask); + ~ctrlport_probe2_b_impl(); + + void setup_rpc(); + + void forecast(int noutput_items, gr_vector_int &ninput_items_required); + + std::vector<signed char> get(); + + void set_length(int len); + int length() const; + + int work(int noutput_items, + gr_vector_const_void_star &input_items, + gr_vector_void_star &output_items); + }; + + } /* namespace blocks */ +} /* namespace gr */ + +#endif /* INCLUDED_CTRLPORT_PROBE2_C_IMPL_H */ + diff --git a/gr-blocks/lib/ctrlport_probe2_c_impl.cc b/gr-blocks/lib/ctrlport_probe2_c_impl.cc index bc6febdb2d..3e324b0d00 100644 --- a/gr-blocks/lib/ctrlport_probe2_c_impl.cc +++ b/gr-blocks/lib/ctrlport_probe2_c_impl.cc @@ -32,18 +32,20 @@ namespace gr { ctrlport_probe2_c::sptr ctrlport_probe2_c::make(const std::string &id, - const std::string &desc, int len) + const std::string &desc, + int len, unsigned int disp_mask) { return gnuradio::get_initial_sptr - (new ctrlport_probe2_c_impl(id, desc, len)); + (new ctrlport_probe2_c_impl(id, desc, len, disp_mask)); } ctrlport_probe2_c_impl::ctrlport_probe2_c_impl(const std::string &id, - const std::string &desc, int len) + const std::string &desc, + int len, unsigned int disp_mask) : sync_block("probe2_c", io_signature::make(1, 1, sizeof(gr_complex)), io_signature::make(0, 0, 0)), - d_id(id), d_desc(desc), d_len(len) + d_id(id), d_desc(desc), d_len(len), d_disp_mask(disp_mask) { set_length(len); } @@ -139,11 +141,9 @@ namespace gr { d_rpc_vars.push_back( rpcbasic_sptr(new rpcbasic_register_get<ctrlport_probe2_c, std::vector<std::complex<float> > >( alias(), d_id.c_str(), &ctrlport_probe2_c::get, - pmt::make_c32vector(0,-2), - pmt::make_c32vector(0,2), - pmt::make_c32vector(0,0), + pmt::mp(-2), pmt::mp(2), pmt::mp(0), "volts", d_desc.c_str(), RPC_PRIVLVL_MIN, - DISPXY | DISPOPTSCATTER))); + d_disp_mask | DISPOPTCPLX))); d_rpc_vars.push_back( rpcbasic_sptr(new rpcbasic_register_get<ctrlport_probe2_c, int>( diff --git a/gr-blocks/lib/ctrlport_probe2_c_impl.h b/gr-blocks/lib/ctrlport_probe2_c_impl.h index c58d97f078..15ff0f4ea2 100644 --- a/gr-blocks/lib/ctrlport_probe2_c_impl.h +++ b/gr-blocks/lib/ctrlport_probe2_c_impl.h @@ -36,6 +36,7 @@ namespace gr { std::string d_id; std::string d_desc; size_t d_len; + unsigned int d_disp_mask; boost::shared_mutex mutex_buffer; mutable boost::mutex mutex_notify; boost::condition_variable condition_buffer_ready; @@ -43,7 +44,8 @@ namespace gr { std::vector<gr_complex> d_buffer; public: - ctrlport_probe2_c_impl(const std::string &id, const std::string &desc, int len); + ctrlport_probe2_c_impl(const std::string &id, const std::string &desc, + int len, unsigned int disp_mask); ~ctrlport_probe2_c_impl(); void setup_rpc(); diff --git a/gr-blocks/lib/ctrlport_probe2_f_impl.cc b/gr-blocks/lib/ctrlport_probe2_f_impl.cc new file mode 100644 index 0000000000..3c723f8834 --- /dev/null +++ b/gr-blocks/lib/ctrlport_probe2_f_impl.cc @@ -0,0 +1,164 @@ +/* -*- c++ -*- */ +/* + * Copyright 2013 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, + * Boston, MA 02110-1301, USA. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "ctrlport_probe2_f_impl.h" +#include <gnuradio/io_signature.h> + +namespace gr { + namespace blocks { + + ctrlport_probe2_f::sptr + ctrlport_probe2_f::make(const std::string &id, const std::string &desc, + int len, unsigned int disp_mask) + { + return gnuradio::get_initial_sptr + (new ctrlport_probe2_f_impl(id, desc, len, disp_mask)); + } + + ctrlport_probe2_f_impl::ctrlport_probe2_f_impl(const std::string &id, const std::string &desc, + int len, unsigned int disp_mask) + : sync_block("probe2_f", + io_signature::make(1, 1, sizeof(float)), + io_signature::make(0, 0, 0)), + d_id(id), d_desc(desc), d_len(len), d_disp_mask(disp_mask) + { + set_length(len); + } + + ctrlport_probe2_f_impl::~ctrlport_probe2_f_impl() + { + } + + void + ctrlport_probe2_f_impl::forecast(int noutput_items, + gr_vector_int &ninput_items_required) + { + // make sure all inputs have noutput_items available + unsigned ninputs = ninput_items_required.size(); + for(unsigned i = 0; i < ninputs; i++) + ninput_items_required[i] = d_len; + } + + // boost::shared_mutex mutex_buffer; + // mutable boost::mutex mutex_notify; + // boost::condition_variable condition_buffer_ready; + std::vector<float> + ctrlport_probe2_f_impl::get() + { + mutex_buffer.lock(); + d_buffer.clear(); + mutex_buffer.unlock(); + + // wait for condition + boost::mutex::scoped_lock lock(mutex_notify); + condition_buffer_ready.wait(lock); + + mutex_buffer.lock(); + std::vector<float> buf_copy = d_buffer; + assert(buf_copy.size() == d_len); + mutex_buffer.unlock(); + + return buf_copy; + } + + void + ctrlport_probe2_f_impl::set_length(int len) + { + if(len > 8191) { + std::cerr << "probe2_f: length " << len + << " exceeds maximum buffer size of 8191" << std::endl; + len = 8191; + } + + d_len = len; + d_buffer.reserve(d_len); + } + + int + ctrlport_probe2_f_impl::length() const + { + return (int)d_len; + } + + int + ctrlport_probe2_f_impl::work(int noutput_items, + gr_vector_const_void_star &input_items, + gr_vector_void_star &output_items) + { + const float *in = (const float*)input_items[0]; + + // copy samples to get buffer if we need samples + mutex_buffer.lock(); + if(d_buffer.size() < d_len) { + // copy smaller of remaining buffer space and num inputs to work() + int num_copy = std::min( (int)(d_len - d_buffer.size()), noutput_items ); + + // TODO: convert this to a copy operator for speed... + for(int i = 0; i < num_copy; i++) { + d_buffer.push_back(in[i]); + } + + // notify the waiting get() if we fill up the buffer + if(d_buffer.size() == d_len) { + condition_buffer_ready.notify_one(); + } + } + mutex_buffer.unlock(); + + return noutput_items; + } + + void + ctrlport_probe2_f_impl::setup_rpc() + { +#ifdef GR_CTRLPORT + int len = static_cast<int>(d_len); + d_rpc_vars.push_back( + rpcbasic_sptr(new rpcbasic_register_get<ctrlport_probe2_f, std::vector<float> >( + alias(), d_id.c_str(), &ctrlport_probe2_f::get, + pmt::mp(-2.0f), pmt::mp(2.0f), pmt::mp(0.0f), +// pmt::make_f32vector(1,-2), +// pmt::make_f32vector(1,2), +// pmt::make_f32vector(1,0), + "volts", d_desc.c_str(), RPC_PRIVLVL_MIN, + d_disp_mask))); + + d_rpc_vars.push_back( + rpcbasic_sptr(new rpcbasic_register_get<ctrlport_probe2_f, int>( + alias(), "length", &ctrlport_probe2_f::length, + pmt::mp(1), pmt::mp(10*len), pmt::mp(len), + "samples", "get vector length", RPC_PRIVLVL_MIN, DISPNULL))); + + d_rpc_vars.push_back( + rpcbasic_sptr(new rpcbasic_register_set<ctrlport_probe2_f, int>( + alias(), "length", &ctrlport_probe2_f::set_length, + pmt::mp(1), pmt::mp(10*len), pmt::mp(len), + "samples", "set vector length", RPC_PRIVLVL_MIN, DISPNULL))); +#endif /* GR_CTRLPORT */ + } + + } /* namespace blocks */ +} /* namespace gr */ diff --git a/gr-blocks/lib/ctrlport_probe2_f_impl.h b/gr-blocks/lib/ctrlport_probe2_f_impl.h new file mode 100644 index 0000000000..a4aa099237 --- /dev/null +++ b/gr-blocks/lib/ctrlport_probe2_f_impl.h @@ -0,0 +1,69 @@ +/* -*- c++ -*- */ +/* + * Copyright 2013 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, + * Boston, MA 02110-1301, USA. + */ + +#ifndef INCLUDED_CTRLPORT_PROBE2_F_IMPL_H +#define INCLUDED_CTRLPORT_PROBE2_F_IMPL_H + +#include <gnuradio/blocks/ctrlport_probe2_f.h> +#include <gnuradio/rpcregisterhelpers.h> +#include <boost/thread/shared_mutex.hpp> + +namespace gr { + namespace blocks { + + class ctrlport_probe2_f_impl : public ctrlport_probe2_f + { + private: + std::string d_id; + std::string d_desc; + size_t d_len; + unsigned int d_disp_mask; + boost::shared_mutex mutex_buffer; + mutable boost::mutex mutex_notify; + boost::condition_variable condition_buffer_ready; + + std::vector<float> d_buffer; + + public: + ctrlport_probe2_f_impl(const std::string &id, const std::string &desc, + int len, unsigned int disp_mask); + ~ctrlport_probe2_f_impl(); + + void setup_rpc(); + + void forecast(int noutput_items, gr_vector_int &ninput_items_required); + + std::vector<float> get(); + + void set_length(int len); + int length() const; + + int work(int noutput_items, + gr_vector_const_void_star &input_items, + gr_vector_void_star &output_items); + }; + + } /* namespace blocks */ +} /* namespace gr */ + +#endif /* INCLUDED_CTRLPORT_PROBE2_F_IMPL_H */ + diff --git a/gr-blocks/lib/ctrlport_probe2_i_impl.cc b/gr-blocks/lib/ctrlport_probe2_i_impl.cc new file mode 100644 index 0000000000..be7ae4d9d3 --- /dev/null +++ b/gr-blocks/lib/ctrlport_probe2_i_impl.cc @@ -0,0 +1,163 @@ +/* -*- c++ -*- */ +/* + * Copyright 2013 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, + * Boston, MA 02110-1301, USA. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "ctrlport_probe2_i_impl.h" +#include <gnuradio/io_signature.h> + +namespace gr { + namespace blocks { + + ctrlport_probe2_i::sptr + ctrlport_probe2_i::make(const std::string &id, + const std::string &desc, + int len, unsigned int disp_mask) + { + return gnuradio::get_initial_sptr + (new ctrlport_probe2_i_impl(id, desc, len, disp_mask)); + } + + ctrlport_probe2_i_impl::ctrlport_probe2_i_impl(const std::string &id, + const std::string &desc, + int len, unsigned int disp_mask) + : sync_block("probe2_i", + io_signature::make(1, 1, sizeof(int)), + io_signature::make(0, 0, 0)), + d_id(id), d_desc(desc), d_len(len), d_disp_mask(disp_mask) + { + set_length(len); + } + + ctrlport_probe2_i_impl::~ctrlport_probe2_i_impl() + { + } + + void + ctrlport_probe2_i_impl::forecast(int noutput_items, + gr_vector_int &ninput_items_required) + { + // make sure all inputs have noutput_items available + unsigned ninputs = ninput_items_required.size(); + for(unsigned i = 0; i < ninputs; i++) + ninput_items_required[i] = d_len; + } + + // boost::shared_mutex mutex_buffer; + // mutable boost::mutex mutex_notify; + // boost::condition_variable condition_buffer_ready; + std::vector<int> + ctrlport_probe2_i_impl::get() + { + mutex_buffer.lock(); + d_buffer.clear(); + mutex_buffer.unlock(); + + // wait for condition + boost::mutex::scoped_lock lock(mutex_notify); + condition_buffer_ready.wait(lock); + + mutex_buffer.lock(); + std::vector<int> buf_copy = d_buffer; + assert(buf_copy.size() == d_len); + mutex_buffer.unlock(); + + return buf_copy; + } + + void + ctrlport_probe2_i_impl::set_length(int len) + { + if(len > 8191) { + std::cerr << "probe2_i: length " << len + << " exceeds maximum buffer size of 8191" << std::endl; + len = 8191; + } + + d_len = len; + d_buffer.reserve(d_len); + } + + int + ctrlport_probe2_i_impl::length() const + { + return (int)d_len; + } + + int + ctrlport_probe2_i_impl::work(int noutput_items, + gr_vector_const_void_star &input_items, + gr_vector_void_star &output_items) + { + const int *in = (const int*)input_items[0]; + + // copy samples to get buffer if we need samples + mutex_buffer.lock(); + if(d_buffer.size() < d_len) { + // copy smaller of remaining buffer space and num inputs to work() + int num_copy = std::min( (int)(d_len - d_buffer.size()), noutput_items ); + + // TODO: convert this to a copy operator for speed... + for(int i = 0; i < num_copy; i++) { + d_buffer.push_back(in[i]); + } + + // notify the waiting get() if we fill up the buffer + if(d_buffer.size() == d_len) { + condition_buffer_ready.notify_one(); + } + } + mutex_buffer.unlock(); + + return noutput_items; + } + + void + ctrlport_probe2_i_impl::setup_rpc() + { +#ifdef GR_CTRLPORT + int len = static_cast<int>(d_len); + d_rpc_vars.push_back( + rpcbasic_sptr(new rpcbasic_register_get<ctrlport_probe2_i, std::vector<int> >( + alias(), d_id.c_str(), &ctrlport_probe2_i::get, + pmt::mp(-32768), pmt::mp(32767), pmt::mp(0), + "volts", d_desc.c_str(), RPC_PRIVLVL_MIN, + d_disp_mask))); + + d_rpc_vars.push_back( + rpcbasic_sptr(new rpcbasic_register_get<ctrlport_probe2_i, int>( + alias(), "length", &ctrlport_probe2_i::length, + pmt::mp(1), pmt::mp(10*len), pmt::mp(len), + "samples", "get vector length", RPC_PRIVLVL_MIN, DISPNULL))); + + d_rpc_vars.push_back( + rpcbasic_sptr(new rpcbasic_register_set<ctrlport_probe2_i, int>( + alias(), "length", &ctrlport_probe2_i::set_length, + pmt::mp(1), pmt::mp(10*len), pmt::mp(len), + "samples", "set vector length", RPC_PRIVLVL_MIN, DISPNULL))); +#endif /* GR_CTRLPORT */ + } + + } /* namespace blocks */ +} /* namespace gr */ diff --git a/gr-blocks/lib/ctrlport_probe2_i_impl.h b/gr-blocks/lib/ctrlport_probe2_i_impl.h new file mode 100644 index 0000000000..06493ac23a --- /dev/null +++ b/gr-blocks/lib/ctrlport_probe2_i_impl.h @@ -0,0 +1,69 @@ +/* -*- c++ -*- */ +/* + * Copyright 2013 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, + * Boston, MA 02110-1301, USA. + */ + +#ifndef INCLUDED_CTRLPORT_PROBE2_I_IMPL_H +#define INCLUDED_CTRLPORT_PROBE2_I_IMPL_H + +#include <gnuradio/blocks/ctrlport_probe2_i.h> +#include <gnuradio/rpcregisterhelpers.h> +#include <boost/thread/shared_mutex.hpp> + +namespace gr { + namespace blocks { + + class ctrlport_probe2_i_impl : public ctrlport_probe2_i + { + private: + std::string d_id; + std::string d_desc; + size_t d_len; + unsigned int d_disp_mask; + boost::shared_mutex mutex_buffer; + mutable boost::mutex mutex_notify; + boost::condition_variable condition_buffer_ready; + + std::vector<int> d_buffer; + + public: + ctrlport_probe2_i_impl(const std::string &id, const std::string &desc, + int len, unsigned int disp_mask); + ~ctrlport_probe2_i_impl(); + + void setup_rpc(); + + void forecast(int noutput_items, gr_vector_int &ninput_items_required); + + std::vector<int> get(); + + void set_length(int len); + int length() const; + + int work(int noutput_items, + gr_vector_const_void_star &input_items, + gr_vector_void_star &output_items); + }; + + } /* namespace blocks */ +} /* namespace gr */ + +#endif /* INCLUDED_CTRLPORT_PROBE2_I_IMPL_H */ + diff --git a/gr-blocks/lib/ctrlport_probe2_s_impl.cc b/gr-blocks/lib/ctrlport_probe2_s_impl.cc new file mode 100644 index 0000000000..b10c419eb5 --- /dev/null +++ b/gr-blocks/lib/ctrlport_probe2_s_impl.cc @@ -0,0 +1,163 @@ +/* -*- c++ -*- */ +/* + * Copyright 2013 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, + * Boston, MA 02110-1301, USA. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "ctrlport_probe2_s_impl.h" +#include <gnuradio/io_signature.h> + +namespace gr { + namespace blocks { + + ctrlport_probe2_s::sptr + ctrlport_probe2_s::make(const std::string &id, + const std::string &desc, + int len, unsigned disp_mask) + { + return gnuradio::get_initial_sptr + (new ctrlport_probe2_s_impl(id, desc, len, disp_mask)); + } + + ctrlport_probe2_s_impl::ctrlport_probe2_s_impl(const std::string &id, + const std::string &desc, + int len, unsigned disp_mask) + : sync_block("probe2_s", + io_signature::make(1, 1, sizeof(short)), + io_signature::make(0, 0, 0)), + d_id(id), d_desc(desc), d_len(len), d_disp_mask(disp_mask) + { + set_length(len); + } + + ctrlport_probe2_s_impl::~ctrlport_probe2_s_impl() + { + } + + void + ctrlport_probe2_s_impl::forecast(int noutput_items, + gr_vector_int &ninput_items_required) + { + // make sure all inputs have noutput_items available + unsigned ninputs = ninput_items_required.size(); + for(unsigned i = 0; i < ninputs; i++) + ninput_items_required[i] = d_len; + } + + // boost::shared_mutex mutex_buffer; + // mutable boost::mutex mutex_notify; + // boost::condition_variable condition_buffer_ready; + std::vector<short> + ctrlport_probe2_s_impl::get() + { + mutex_buffer.lock(); + d_buffer.clear(); + mutex_buffer.unlock(); + + // wait for condition + boost::mutex::scoped_lock lock(mutex_notify); + condition_buffer_ready.wait(lock); + + mutex_buffer.lock(); + std::vector<short> buf_copy = d_buffer; + assert(buf_copy.size() == d_len); + mutex_buffer.unlock(); + + return buf_copy; + } + + void + ctrlport_probe2_s_impl::set_length(int len) + { + if(len > 8191) { + std::cerr << "probe2_s: length " << len + << " exceeds maximum buffer size of 8191" << std::endl; + len = 8191; + } + + d_len = len; + d_buffer.reserve(d_len); + } + + int + ctrlport_probe2_s_impl::length() const + { + return (int)d_len; + } + + int + ctrlport_probe2_s_impl::work(int noutput_items, + gr_vector_const_void_star &input_items, + gr_vector_void_star &output_items) + { + const short *in = (const short*)input_items[0]; + + // copy samples to get buffer if we need samples + mutex_buffer.lock(); + if(d_buffer.size() < d_len) { + // copy smaller of remaining buffer space and num inputs to work() + int num_copy = std::min( (int)(d_len - d_buffer.size()), noutput_items ); + + // TODO: convert this to a copy operator for speed... + for(int i = 0; i < num_copy; i++) { + d_buffer.push_back(in[i]); + } + + // notify the waiting get() if we fill up the buffer + if(d_buffer.size() == d_len) { + condition_buffer_ready.notify_one(); + } + } + mutex_buffer.unlock(); + + return noutput_items; + } + + void + ctrlport_probe2_s_impl::setup_rpc() + { +#ifdef GR_CTRLPORT + int len = static_cast<int>(d_len); + d_rpc_vars.push_back( + rpcbasic_sptr(new rpcbasic_register_get<ctrlport_probe2_s, std::vector<short> >( + alias(), d_id.c_str(), &ctrlport_probe2_s::get, + pmt::mp(-32768), pmt::mp(32767), pmt::mp(0), + "volts", d_desc.c_str(), RPC_PRIVLVL_MIN, + d_disp_mask))); + + d_rpc_vars.push_back( + rpcbasic_sptr(new rpcbasic_register_get<ctrlport_probe2_s, int>( + alias(), "length", &ctrlport_probe2_s::length, + pmt::mp(1), pmt::mp(10*len), pmt::mp(len), + "samples", "get vector length", RPC_PRIVLVL_MIN, DISPNULL))); + + d_rpc_vars.push_back( + rpcbasic_sptr(new rpcbasic_register_set<ctrlport_probe2_s, int>( + alias(), "length", &ctrlport_probe2_s::set_length, + pmt::mp(1), pmt::mp(10*len), pmt::mp(len), + "samples", "set vector length", RPC_PRIVLVL_MIN, DISPNULL))); +#endif /* GR_CTRLPORT */ + } + + } /* namespace blocks */ +} /* namespace gr */ diff --git a/gr-blocks/lib/ctrlport_probe2_s_impl.h b/gr-blocks/lib/ctrlport_probe2_s_impl.h new file mode 100644 index 0000000000..078dd56b73 --- /dev/null +++ b/gr-blocks/lib/ctrlport_probe2_s_impl.h @@ -0,0 +1,69 @@ +/* -*- c++ -*- */ +/* + * Copyright 2013 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, + * Boston, MA 02110-1301, USA. + */ + +#ifndef INCLUDED_CTRLPORT_PROBE2_S_IMPL_H +#define INCLUDED_CTRLPORT_PROBE2_S_IMPL_H + +#include <gnuradio/blocks/ctrlport_probe2_s.h> +#include <gnuradio/rpcregisterhelpers.h> +#include <boost/thread/shared_mutex.hpp> + +namespace gr { + namespace blocks { + + class ctrlport_probe2_s_impl : public ctrlport_probe2_s + { + private: + std::string d_id; + std::string d_desc; + size_t d_len; + unsigned int d_disp_mask; + boost::shared_mutex mutex_buffer; + mutable boost::mutex mutex_notify; + boost::condition_variable condition_buffer_ready; + + std::vector<short> d_buffer; + + public: + ctrlport_probe2_s_impl(const std::string &id, const std::string &desc, + int len, unsigned int disp_mask); + ~ctrlport_probe2_s_impl(); + + void setup_rpc(); + + void forecast(int noutput_items, gr_vector_int &ninput_items_required); + + std::vector<short> get(); + + void set_length(int len); + int length() const; + + int work(int noutput_items, + gr_vector_const_void_star &input_items, + gr_vector_void_star &output_items); + }; + + } /* namespace blocks */ +} /* namespace gr */ + +#endif /* INCLUDED_CTRLPORT_PROBE2_S_IMPL_H */ + diff --git a/gr-blocks/swig/blocks_swig0.i b/gr-blocks/swig/blocks_swig0.i index ec5b75b0d1..28e14fea35 100644 --- a/gr-blocks/swig/blocks_swig0.i +++ b/gr-blocks/swig/blocks_swig0.i @@ -103,12 +103,24 @@ GR_SWIG_BLOCK_MAGIC2(blocks, null_source); %{ #include "gnuradio/blocks/ctrlport_probe_c.h" #include "gnuradio/blocks/ctrlport_probe2_c.h" +#include "gnuradio/blocks/ctrlport_probe2_f.h" +#include "gnuradio/blocks/ctrlport_probe2_s.h" +#include "gnuradio/blocks/ctrlport_probe2_i.h" +#include "gnuradio/blocks/ctrlport_probe2_b.h" %} %include "gnuradio/blocks/ctrlport_probe_c.h" %include "gnuradio/blocks/ctrlport_probe2_c.h" +%include "gnuradio/blocks/ctrlport_probe2_f.h" +%include "gnuradio/blocks/ctrlport_probe2_s.h" +%include "gnuradio/blocks/ctrlport_probe2_i.h" +%include "gnuradio/blocks/ctrlport_probe2_b.h" GR_SWIG_BLOCK_MAGIC2(blocks, ctrlport_probe_c); GR_SWIG_BLOCK_MAGIC2(blocks, ctrlport_probe2_c); +GR_SWIG_BLOCK_MAGIC2(blocks, ctrlport_probe2_f); +GR_SWIG_BLOCK_MAGIC2(blocks, ctrlport_probe2_s); +GR_SWIG_BLOCK_MAGIC2(blocks, ctrlport_probe2_i); +GR_SWIG_BLOCK_MAGIC2(blocks, ctrlport_probe2_b); #endif /* GR_CTRLPORT */ |