This is merely a historical archive of years 2008-2021, before the migration to mailman3.
A maintained and still updated list archive can be found at https://lists.osmocom.org/hyperkitty/list/osmocom-sdr@lists.osmocom.org/.
andrea montefusco andrea.montefusco at gmail.comOk, just give me few days, currently I'm on vacation far away from computers and radios. Andrea Montefusco IW0HDV On Wed, Aug 15, 2018, 20:30 horizon <horiz0n at gmx.net> wrote: > Hi Andrea, > > could you please provide a signed-off patch with your latest changes > ongithub and a proper commit message? > > Feel free to add information to AUTHORS, README and the > grc/gen_osmosdr_blocks.py files just like we did for other radios and > ideally include a link where libperseus is hosted (I understand this is > https://github.com/Microtelecom/libperseus-sdr ?). > > Best regards, > > Dimitri > > > On 02/03/2018 10:38 AM, andrea.montefusco at gmail.com wrote: > > Second attempt: I removed all the changes not related to Perseus. > > > > @Sylvain: thanks for take time to review. > > > > > > --- > > CMakeLists.txt | 1 + > > cmake/Modules/FindLibPERSEUS.cmake | 24 ++ > > lib/CMakeLists.txt | 8 + > > lib/config.h.in | 1 + > > lib/device.cc | 8 + > > lib/perseus/CMakeLists.txt | 37 +++ > > lib/perseus/perseus_source_c.cc | 613 > +++++++++++++++++++++++++++++++++++++ > > lib/perseus/perseus_source_c.h | 135 ++++++++ > > lib/source_impl.cc | 18 +- > > 9 files changed, 844 insertions(+), 1 deletion(-) > > create mode 100644 cmake/Modules/FindLibPERSEUS.cmake > > create mode 100644 lib/perseus/CMakeLists.txt > > create mode 100644 lib/perseus/perseus_source_c.cc > > create mode 100644 lib/perseus/perseus_source_c.h > > > > diff --git a/CMakeLists.txt b/CMakeLists.txt > > index 296456d..94acd4c 100644 > > --- a/CMakeLists.txt > > +++ b/CMakeLists.txt > > @@ -173,6 +173,7 @@ find_package(Volk) > > find_package(LibbladeRF) > > find_package(SoapySDR NO_MODULE) > > find_package(LibFreeSRP) > > +find_package(LibPERSEUS) > > find_package(Doxygen) > > > > if(NOT GNURADIO_RUNTIME_FOUND) > > diff --git a/cmake/Modules/FindLibPERSEUS.cmake > b/cmake/Modules/FindLibPERSEUS.cmake > > new file mode 100644 > > index 0000000..5477327 > > --- /dev/null > > +++ b/cmake/Modules/FindLibPERSEUS.cmake > > @@ -0,0 +1,24 @@ > > +INCLUDE(FindPkgConfig) > > +PKG_CHECK_MODULES(PC_LIBPERSEUS libperseus-sdr) > > + > > +FIND_PATH( > > + LIBPERSEUS_INCLUDE_DIRS > > + NAMES perseus-sdr.h > > + HINTS $ENV{LIBPERSEUS_DIR}/include > > + ${PC_LIBPERSEUS_INCLUDEDIR} > > + PATHS /usr/local/include > > + /usr/include > > +) > > + > > +FIND_LIBRARY( > > + LIBPERSEUS_LIBRARIES > > + NAMES perseus-sdr > > + HINTS $ENV{LIBPERSEUS_DIR}/lib > > + ${PC_LIBPERSEUS_LIBDIR} > > + PATHS /usr/local/lib > > + /usr/lib > > +) > > + > > +INCLUDE(FindPackageHandleStandardArgs) > > +FIND_PACKAGE_HANDLE_STANDARD_ARGS(LIBPERSEUS DEFAULT_MSG > LIBPERSEUS_LIBRARIES LIBPERSEUS_INCLUDE_DIRS) > > +MARK_AS_ADVANCED(LIBPERSEUS_LIBRARIES LIBPERSEUS_INCLUDE_DIRS) > > diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt > > index c05b8d9..f555816 100644 > > --- a/lib/CMakeLists.txt > > +++ b/lib/CMakeLists.txt > > @@ -249,6 +249,14 @@ GR_INCLUDE_SUBDIRECTORY(freesrp) > > endif(ENABLE_FREESRP) > > > > > ######################################################################## > > +# Setup PERSEUS component > > +######################################################################## > > +GR_REGISTER_COMPONENT("Microtelecom Perseus Receiver" ENABLE_PERSEUS > LIBPERSEUS_FOUND) > > +if(ENABLE_PERSEUS) > > +GR_INCLUDE_SUBDIRECTORY(perseus) > > +endif(ENABLE_PERSEUS) > > + > > +######################################################################## > > # Setup configuration file > > > ######################################################################## > > ADD_DEFINITIONS(-DHAVE_CONFIG_H=1) > > diff --git a/lib/config.h.in b/lib/config.h.in > > index 42e72f1..dac7e39 100644 > > --- a/lib/config.h.in > > +++ b/lib/config.h.in > > @@ -19,6 +19,7 @@ > > #cmakedefine ENABLE_SOAPY > > #cmakedefine ENABLE_REDPITAYA > > #cmakedefine ENABLE_FREESRP > > +#cmakedefine ENABLE_PERSEUS > > > > //provide NAN define for MSVC older than VC12 > > #if defined(_MSC_VER) && (_MSC_VER < 1800) > > diff --git a/lib/device.cc b/lib/device.cc > > index 025a22b..df0d734 100644 > > --- a/lib/device.cc > > +++ b/lib/device.cc > > @@ -90,6 +90,10 @@ > > #include <freesrp_source_c.h> > > #endif > > > > +#ifdef ENABLE_PERSEUS > > +#include <perseus_source_c.h> > > +#endif > > + > > #include "arg_helpers.h" > > > > using namespace osmosdr; > > @@ -194,6 +198,10 @@ devices_t device::find(const device_t &hint) > > BOOST_FOREACH( std::string dev, soapy_source_c::get_devices() ) > > devices.push_back( device_t(dev) ); > > #endif > > +#ifdef ENABLE_PERSEUS > > + BOOST_FOREACH( std::string dev, perseus_source_c::get_devices() ) > > + devices.push_back( device_t(dev) ); > > +#endif > > > > /* software-only sources should be appended at the very end, > > * hopefully resulting in hardware sources to be shown first > > diff --git a/lib/perseus/CMakeLists.txt b/lib/perseus/CMakeLists.txt > > new file mode 100644 > > index 0000000..f45a10d > > --- /dev/null > > +++ b/lib/perseus/CMakeLists.txt > > @@ -0,0 +1,37 @@ > > +# Copyright 2017 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. > > + > > +######################################################################## > > +# This file included, use CMake directory variables > > +######################################################################## > > + > > +include_directories( > > + ${CMAKE_CURRENT_SOURCE_DIR} > > + ${LIBPERSEUS_INCLUDE_DIRS} > > +) > > + > > +set(perseus_srcs > > + ${CMAKE_CURRENT_SOURCE_DIR}/perseus_source_c.cc > > +) > > + > > +######################################################################## > > +# Append gnuradio-osmosdr library sources > > +######################################################################## > > +list(APPEND gr_osmosdr_srcs ${perseus_srcs}) > > +list(APPEND gr_osmosdr_libs ${LIBPERSEUS_LIBRARIES} > ${GNURADIO_BLOCKS_LIBRARIES}) > > diff --git a/lib/perseus/perseus_source_c.cc > b/lib/perseus/perseus_source_c.cc > > new file mode 100644 > > index 0000000..bf7c9be > > --- /dev/null > > +++ b/lib/perseus/perseus_source_c.cc > > @@ -0,0 +1,613 @@ > > +/* -*- c++ -*- */ > > +/* > > + * Copyright 2018 Andrea Montefusco IW0HDV > > + * > > + * 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. > > + */ > > + > > +/* > > + * config.h is generated by configure. It contains the results > > + * of probing for features, options etc. It should be the first > > + * file included in your .cc file. > > + */ > > +#ifdef HAVE_CONFIG_H > > +#include "config.h" > > +#endif > > + > > +#include <stdexcept> > > +#include <iostream> > > +#include <algorithm> > > + > > +#include <boost/assign.hpp> > > +#include <boost/format.hpp> > > +#include <boost/detail/endian.hpp> > > +#include <boost/algorithm/string.hpp> > > +#include <boost/thread/thread.hpp> > > + > > +#include <gnuradio/io_signature.h> > > + > > +#include "perseus_source_c.h" > > +#include "arg_helpers.h" > > + > > + > > + > > +using namespace boost::assign; > > + > > +#define PERSEUS_FORMAT_ERROR(ret, msg) \ > > + boost::str( boost::format(msg " (%1%)") % ret ) > > + > > +#define PERSEUS_THROW_ON_ERROR(ret, msg) \ > > + if ( ret != PERSEUS_NOERROR ) \ > > + { \ > > + throw std::runtime_error( PERSEUS_FORMAT_ERROR(ret, msg) ); \ > > + } > > + > > +#define PERSEUS_FUNC_STR(func, arg) \ > > + boost::str(boost::format(func "(%1%)") % arg) + " has failed" > > + > > +perseus_source_c_sptr make_perseus_source_c (const std::string & args) > > +{ > > + return gnuradio::get_initial_sptr(new perseus_source_c (args)); > > +} > > + > > +/* > > + * Specify constraints on number of input and output streams. > > + * This info is used to construct the input and output signatures > > + * (2nd & 3rd args to gr::block's constructor). The input and > > + * output signatures are used by the runtime system to > > + * check that a valid number and type of inputs and outputs > > + * are connected to this block. In this case, we accept > > + * only 0 input and 1 output. > > + */ > > +static const int MIN_IN = 0; // mininum number of input streams > > +static const int MAX_IN = 0; // maximum number of input streams > > +static const int MIN_OUT = 1; // minimum number of output streams > > +static const int MAX_OUT = 1; // maximum number of output streams > > + > > +/* > > + * The private constructor > > + */ > > +perseus_source_c::perseus_source_c (const std::string &args) > > + : gr::sync_block ("perseus_source_c", > > + gr::io_signature::make(MIN_IN, MAX_IN, sizeof (gr_complex)), > > + gr::io_signature::make(MIN_OUT, MAX_OUT, sizeof (gr_complex))), > > + _dev(NULL), > > + _sample_rate(0), > > + _center_freq(0), > > + _freq_corr(0), > > + _frun(false), > > + _cnt(0), > > + _att_value(0), > > + _adc_preamp(false), > > + _adc_dither(false), > > + _preselector(false) > > +{ > > + dict_t dict = params_to_dict(args); > > + > > + _dev = NULL; > > + > > + // Set debug info dumped to stderr to the maximum verbose level > > + perseus_set_debug(3); > > + > > + // Check how many Perseus receivers are connected to the system > > + int num_perseus = perseus_init(); > > + std::cerr << "## Microtelecom Perseus ctor: " << num_perseus << " > Perseus receivers found." << std::endl; > > + > > + if (num_perseus==0) { > > + perseus_exit(); > > + PERSEUS_THROW_ON_ERROR(PERSEUS_DEVNOTFOUND, "No Perseus receivers > detected"); > > + } > > + // Open the first one... > > + if ((_dev = perseus_open(0)) == NULL) { > > + PERSEUS_THROW_ON_ERROR(PERSEUS_DEVNOTFOUND, "Unable to open > Perseus device"); > > + } > > + // Download the standard firmware to the unit > > + std::cerr << "Downloading firmware..." << std::endl; > > + if (int rc = perseus_firmware_download(_dev,NULL)<0) { > > + PERSEUS_THROW_ON_ERROR (rc, "firmware download error"); > > + } > > + > > + // Dump some information about the receiver (S/N and HW rev) > > + int flag; > > + perseus_is_preserie(_dev, &flag); > > + if (flag != 0) > > + fprintf(stderr, "The device is a preserie unit"); > > + else { > > + eeprom_prodid prodid; > > + if (perseus_get_product_id(_dev,&prodid)<0) > > + fprintf(stderr, "get product id error: %s", perseus_errorstr()); > > + else > > + fprintf(stderr, "Receiver S/N: > %05d-%02hX%02hX-%02hX%02hX-%02hX%02hX - HW Release:%hd.%hd\n", > > + (uint16_t) prodid.sn, > > + (uint16_t) prodid.signature[5], > > + (uint16_t) prodid.signature[4], > > + (uint16_t) prodid.signature[3], > > + (uint16_t) prodid.signature[2], > > + (uint16_t) prodid.signature[1], > > + (uint16_t) prodid.signature[0], > > + (uint16_t) prodid.hwrel, > > + (uint16_t) prodid.hwver); > > + } > > + // Printing all sampling rates available ..... > > + { > > + int buf[BUFSIZ]; > > + > > + if (perseus_get_sampling_rates (_dev, buf, > sizeof(buf)/sizeof(buf[0])) < 0) { > > + fprintf(stderr, "get sampling rates error: %s\n", > perseus_errorstr()); > > + } else { > > + int i = 0; > > + while (buf[i]) { > > + fprintf(stderr, "#%d: sample rate: %d\n", i, buf[i]); > > + _sample_rates.push_back( std::pair<double, uint32_t>( > buf[i], i ) ); > > + i++; > > + } > > + /* since they may (and will) give us an unsorted array we > have to sort it here > > + * to play nice with the monotonic requirement of meta-range > later on */ > > + std::sort(_sample_rates.begin(), _sample_rates.end()); > > + > > + for (size_t i = 0; i < _sample_rates.size(); i++) > > + std::cerr << boost::format("%gM ") % > (_sample_rates[i].first / 1e6); > > + > > + std::cerr << std::endl; > > + } > > + } > > + // Configure the receiver for 2 MS/s operations > > + fprintf(stderr, "Configuring FPGA...\n"); > > + if (int ret = perseus_set_sampling_rate(_dev, 96000) < 0) { // > specify the sampling rate value in Samples/second > > + std::cerr << "fpga configuration error: " << perseus_errorstr() > << std::endl; > > + PERSEUS_THROW_ON_ERROR(ret, "Perseus fpga configuration error"); > > + } > > + > > + perseus_set_attenuator_in_db(_dev, _att_value); > > + // Enable ADC Dither, Disable ADC Preamp > > + perseus_set_adc(_dev, _adc_dither == true ? 1:0, _adc_preamp == true > ? 1:0); > > + // set the NCO frequency in the middle of the range allowed > > + set_center_freq( (get_freq_range().start() + get_freq_range().stop()) > / 2.0 ); > > + set_sample_rate( get_sample_rates().start() ); > > + > > + _fifo = new boost::circular_buffer<gr_complex>(5000000); > > + if (!_fifo) { > > + throw std::runtime_error( std::string(__FUNCTION__) + " " + > > + "Failed to allocate a sample FIFO!" ); > > + } > > +} > > + > > +/* > > + * Our virtual destructor. > > + */ > > +perseus_source_c::~perseus_source_c () > > +{ > > + if (_dev) { > > + if (_frun) stop(); > > + int ret = perseus_close(_dev); > > + if ( ret != PERSEUS_NOERROR ) { > > + std::cerr << PERSEUS_FORMAT_ERROR(ret, "Failed to close Perseus") > << std::endl; > > + } else > > + _dev = NULL; > > + } > > + perseus_exit(); > > + > > + if (_fifo) { > > + delete _fifo; > > + _fifo = NULL; > > + } > > +} > > + > > + > > +typedef union { > > + struct { > > + int32_t i; > > + int32_t q; > > + } __attribute__((__packed__)) iq; > > + struct { > > + uint8_t i1; > > + uint8_t i2; > > + uint8_t i3; > > + uint8_t i4; > > + uint8_t q1; > > + uint8_t q2; > > + uint8_t q3; > > + uint8_t q4; > > + } __attribute__((__packed__)) ; > > +} iq_sample; > > + > > + > > +int perseus_source_c::perseus_rx_callback(void *buf, int buf_size) > > +{ > > + size_t i, n_avail, to_copy, num_samples; > > + > > + uint8_t *samplebuf = (uint8_t*)buf; > > + > > + num_samples = buf_size/6; > > + > > + if (buf_size % 6) > > + std::cerr << "FATAL !!!!!!! not on boundary" << std::endl; > > + > > + iq_sample s; > > + > > + _fifo_lock.lock(); > > + > > + n_avail = _fifo->capacity() - _fifo->size(); > > + to_copy = (n_avail < num_samples ? n_avail : num_samples); > > + > > + for (i = 0; i < to_copy; i++ ) { > > + > > + s.i1 = s.q1 = 0; > > + s.i2 = *samplebuf++; > > + s.i3 = *samplebuf++; > > + s.i4 = *samplebuf++; > > + s.q2 = *samplebuf++; > > + s.q3 = *samplebuf++; > > + s.q4 = *samplebuf++; > > + > > + // convert 24 bit two's complements integers to float in [-1.0 - > +1.0] range > > + // Push sample to the fifo > > + _fifo->push_back( gr_complex( (float)(s.iq.i) / (INT_MAX - 256), > (float)(s.iq.q) / (INT_MAX - 256) ) ); > > + > > + } > > + // keep a counter of processed bytes > > + _cnt += buf_size; > > + > > + _fifo_lock.unlock(); > > + > > + /* We have made some new samples available to the consumer in work() > */ > > + if (to_copy) { > > + //std::cerr << "+" << std::flush; > > + _samp_avail.notify_one(); > > + } > > + > > + /* Indicate overrun, if necessary */ > > + if (to_copy < num_samples) > > + std::cerr << "O" << std::flush; > > + > > + return 0; // TODO: return -1 on error/stop > > +} > > + > > +// static method used as callback from the libperseus-sdr library > > +int perseus_source_c::_perseus_rx_callback(void *buf, int buf_size, > void *extra) > > +{ > > + perseus_source_c *obj = (perseus_source_c *)extra; > > + > > + return obj->perseus_rx_callback((float *)buf, buf_size); > > + > > + return 0; > > +} > > + > > + > > +bool perseus_source_c::start() > > +{ > > + int ret; > > + > > + if ( ! _dev ) > > + return false; > > + > > + std::cerr << "***** START COUNTER: " << _cnt > > + << " mod 6 " << (_cnt % 6) << std::endl; > > + > > + _frun = true; > > + > > + // in order to guarantee samples stream synchronization > > + // re-set the sample rate each time the stream is started > > + set_sample_rate( get_sample_rate() ); > > + > > + ret = perseus_start_async_input(_dev, > > + 6 * 1024 * 2 /* buffer size */, > > + > perseus_source_c::_perseus_rx_callback, > > + (void *)this); > > + if (ret != PERSEUS_NOERROR) { > > + std::cerr << "Failed to start RX streaming (" > > + << ret << ")" << std::endl; > > + return false; > > + } else > > + return true; > > +} > > + > > +bool perseus_source_c::stop() > > +{ > > + if ( ! _dev ) > > + return false; > > + > > + _frun = false; > > + > > + std::cerr << "***** STOP COUNTER: " << _cnt > > + << " mod 6 " << (_cnt % 6) << std::endl; > > + > > + int ret = perseus_stop_async_input(_dev); > > + > > + if ( ret != PERSEUS_NOERROR ) { > > + std::cerr << "Failed to stop RX streaming (" << ret << ")" << > std::endl; > > + return false; > > + } else > > + return true; > > +} > > + > > +int perseus_source_c::work( int noutput_items, > > + gr_vector_const_void_star &input_items, > > + gr_vector_void_star &output_items ) > > +{ > > + gr_complex *out = (gr_complex *)output_items[0]; > > + > > + if ( _frun == false ) return WORK_DONE; > > + > > + boost::unique_lock<boost::mutex> lock(_fifo_lock); > > + > > + /* Wait until we have the requested number of samples */ > > + int n_samples_avail = _fifo->size(); > > + > > + while (n_samples_avail < noutput_items) { > > + _samp_avail.wait(lock); > > + n_samples_avail = _fifo->size(); > > + } > > + > > + for(int i = 0; i < noutput_items; ++i) { > > + out[i] = _fifo->at(0); > > + _fifo->pop_front(); > > + } > > + > > + return noutput_items; > > +} > > + > > +std::vector<std::string> perseus_source_c::get_devices() > > +{ > > + std::vector<std::string> devices; > > + std::string label; > > + > > + std::string args = "perseus=0,label='Perseus'"; > > + devices.push_back( args ); > > + > > + return devices; > > +} > > + > > +size_t perseus_source_c::get_num_channels() > > +{ > > + return 1; > > +} > > + > > +osmosdr::meta_range_t perseus_source_c::get_sample_rates() > > +{ > > + osmosdr::meta_range_t range; > > + > > + for (size_t i = 0; i < _sample_rates.size(); i++) { > > + range += osmosdr::range_t( _sample_rates[i].first ); > > + std::cerr << "SR: " << i << " : (" > > + << _sample_rates[i].first << ")" << std::endl; > > + } > > + return range; > > +} > > + > > +double perseus_source_c::set_sample_rate( double rate ) > > +{ > > + int ret; > > + if ((ret = perseus_set_sampling_rate(_dev, rate)) < 0) { > > + PERSEUS_THROW_ON_ERROR(ret, "Unable to set sample rate."); > > + } else > > + _sample_rate = rate; > > + > > + return get_sample_rate(); > > +} > > + > > +double perseus_source_c::get_sample_rate() > > +{ > > + return _sample_rate; > > +} > > + > > +osmosdr::freq_range_t perseus_source_c::get_freq_range( size_t chan ) > > +{ > > + osmosdr::freq_range_t range; > > + > > + range += osmosdr::range_t( PERSEUS_DDC_FREQ_MIN, PERSEUS_DDC_FREQ_MAX > ); > > + > > + return range; > > +} > > + > > +double perseus_source_c::set_center_freq( double freq, size_t chan ) > > +{ > > + int ret; > > + > > + if (_dev) { > > + ret = > > + perseus_set_ddc_center_freq(_dev, > > + (uint64_t)(freq * (1.0 + (_freq_corr * > 10e-6))), > > + _preselector == true ? 1:0); > > + if ( ret == PERSEUS_NOERROR ) { > > + _center_freq = freq; > > + } else { > > + PERSEUS_THROW_ON_ERROR( ret, PERSEUS_FUNC_STR( > "perseus_set_ddc_center_freq", freq ) ) > > + } > > + } > > + > > + return get_center_freq( chan ); > > +} > > + > > +double perseus_source_c::get_center_freq( size_t chan ) > > +{ > > + return _center_freq; > > +} > > + > > +double perseus_source_c::set_freq_corr( double ppm, size_t chan ) > > +{ > > + return _freq_corr = ppm; > > +} > > + > > +double perseus_source_c::get_freq_corr( size_t chan ) > > +{ > > + return _freq_corr; > > +} > > + > > +std::vector<std::string> perseus_source_c::get_gain_names( size_t chan ) > > +{ > > + std::vector< std::string > names; > > + > > + names += "Attenuator"; > > + names += "ADC preamp"; > > + names += "ADC dither"; > > + > > + return names; > > +} > > + > > +// > > +// FIXME > > +// > > +osmosdr::gain_range_t perseus_source_c::get_gain_range( size_t chan ) > > +{ > > + return get_gain_range( "Attenuator", chan ); > > +} > > + > > +osmosdr::gain_range_t perseus_source_c::get_gain_range( const > std::string & name, size_t chan ) > > +{ > > + if ( "Attenuator" == name ) { > > + return osmosdr::gain_range_t( -30, 0, 10 ); > > + } > > + if ( "ADC preamp" == name ) { > > + return osmosdr::gain_range_t( 0, 6, 6 ); > > + } > > + if ( "ADC dither" == name ) { > > + return osmosdr::gain_range_t( 0, 1, 1 ); > > + } > > + > > + return osmosdr::gain_range_t(); > > +} > > + > > + > > +double perseus_source_c::set_attenuator( double gain, size_t chan ) > > +{ > > + int ret; > > + > > + gain = - gain; > > + if (_dev && _att_value != gain) { > > + ret = perseus_set_attenuator_in_db (_dev, gain); > > + > > + if ( PERSEUS_NOERROR == ret ) { > > + _att_value = gain; > > + } else { > > + std::cerr << "ERROR: perseus_set_attenuator_in_db: " << gain << > std::endl; > > + } > > + } > > + > > + return _att_value; > > +} > > + > > +double perseus_source_c::set_adc_preamp( double gain, size_t chan ) > > +{ > > + std::cerr << "set_adc_preamp: " << gain << std::endl; > > + > > + if (_dev) { > > + _adc_preamp = (gain != 0. ? true : false); > > + int ret = > > + perseus_set_adc(_dev, _adc_dither == true ? 1:0, _adc_preamp == > true ? 1:0); > > + if ( PERSEUS_NOERROR != ret ) { > > + std::cerr << "ERROR: perseus_set_adc" << ret << std::endl; > > + } > > + } > > + return gain; > > +} > > + > > +double perseus_source_c::set_adc_dither( double gain, size_t chan ) > > +{ > > + std::cerr << "set_adc_dither: " << gain << std::endl; > > + > > + if (_dev) { > > + _adc_dither = (gain != 0. ? true : false); > > + int ret = > > + perseus_set_adc(_dev, _adc_dither == true ? 1:0, _adc_preamp == > true ? 1:0); > > + if ( PERSEUS_NOERROR != ret ) { > > + std::cerr << "ERROR: perseus_set_adc" << ret << std::endl; > > + } > > + } > > + return gain; > > +} > > + > > +double perseus_source_c::get_attenuator( size_t chan ) > > +{ > > + return _att_value; > > +} > > + > > +double perseus_source_c::get_adc_preamp(size_t chan ) > > +{ > > + double v = _adc_preamp == true ? 6. : 0.; > > + std::cerr << "get_adc_preamp: " << _adc_preamp << " value" << v << > std::endl; > > + return v; > > +} > > + > > +double perseus_source_c::get_adc_dither(size_t chan ) > > +{ > > + double v = _adc_dither == true ? 1. : 0.; > > + std::cerr << "get_adc_dither: " << _adc_dither << " value" << v << > std::endl; > > + return v; > > +} > > + > > + > > +double perseus_source_c::set_gain( double gain, const std::string & > name, size_t chan) > > +{ > > + if ( "Attenuator" == name ) { > > + return set_attenuator( gain, chan ); > > + } > > + if ( "ADC preamp" == name ) { > > + return set_adc_preamp( gain, chan ); > > + } > > + if ( "ADC dither" == name ) { > > + return set_adc_dither( gain, chan ); > > + } > > + return gain; > > +} > > + > > + > > +double perseus_source_c::get_gain( const std::string & name, size_t > chan ) > > +{ > > + if ( "Attenuator" == name ) { > > + return get_attenuator( chan ); > > + } > > + if ( "ADC preamp" == name ) { > > + return get_adc_preamp( chan ); > > + } > > + if ( "ADC dither" == name ) { > > + return get_adc_dither( chan ); > > + } > > + return 0.0; > > +} > > + > > + > > + > > +std::vector< std::string > perseus_source_c::get_antennas( size_t chan ) > > +{ > > + std::vector< std::string > antennas; > > + > > + antennas += "RX"; > > + antennas += "RX+PRESELECTOR"; > > + > > + return antennas; > > +} > > + > > +std::string perseus_source_c::set_antenna( const std::string & antenna, > size_t chan ) > > +{ > > + if ( antenna == "RX" ) { > > + _preselector = false; > > + set_center_freq( get_center_freq() ); > > + return "RX"; > > + } > > + if ( antenna == "RX+PRESELECTOR" ) { > > + _preselector = true; > > + set_center_freq( get_center_freq() ); > > + return "RX+PRESELECTOR"; > > + } > > + return get_antenna( chan ); > > +} > > + > > +std::string perseus_source_c::get_antenna( size_t chan ) > > +{ > > + std::cerr << "perseus_source_c::get_antenna: " << chan << std::endl; > > + return "RX"; > > +} > > diff --git a/lib/perseus/perseus_source_c.h > b/lib/perseus/perseus_source_c.h > > new file mode 100644 > > index 0000000..55d3f89 > > --- /dev/null > > +++ b/lib/perseus/perseus_source_c.h > > @@ -0,0 +1,135 @@ > > +/* -*- c++ -*- */ > > +/* > > + * Copyright 2013 Dimitri Stolnikov <horiz0n at gmx.net> > > + * > > + * 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_PERSEUS_SOURCE_C_H > > +#define INCLUDED_PERSEUS_SOURCE_C_H > > + > > +#include <boost/circular_buffer.hpp> > > +#include <boost/thread/mutex.hpp> > > +#include <boost/thread/condition_variable.hpp> > > + > > +#include <gnuradio/sync_block.h> > > + > > +#include "source_iface.h" > > +#include <perseus-sdr.h> > > + > > +class perseus_source_c; > > + > > +typedef boost::shared_ptr<perseus_source_c> perseus_source_c_sptr; > > + > > +/*! > > + * \brief Return a shared_ptr to a new instance of perseus_source_c. > > + * > > + * To avoid accidental use of raw pointers, perseus_source_c's > > + * constructor is private. make_perseus_source_c is the public > > + * interface for creating new instances. > > + */ > > +perseus_source_c_sptr make_perseus_source_c (const std::string & args = > ""); > > + > > +/*! > > + * \brief Provides a stream of complex samples. > > + * \ingroup block > > + */ > > +class perseus_source_c : > > + public gr::sync_block, > > + public source_iface > > +{ > > +private: > > + // The friend declaration allows make_perseus_source_c to > > + // access the private constructor. > > + > > + friend perseus_source_c_sptr make_perseus_source_c (const std::string > & args); > > + > > + perseus_source_c (const std::string & args); > > + > > +public: > > + ~perseus_source_c (); > > + > > + bool start(); > > + bool stop(); > > + > > + int work( int noutput_items, > > + gr_vector_const_void_star &input_items, > > + gr_vector_void_star &output_items ); > > + > > + static std::vector< std::string > get_devices(); > > + > > + size_t get_num_channels( void ); > > + > > + osmosdr::meta_range_t get_sample_rates( void ); > > + double set_sample_rate( double rate ); > > + double get_sample_rate( void ); > > + > > + osmosdr::freq_range_t get_freq_range( size_t chan = 0 ); > > + double set_center_freq( double freq, size_t chan = 0 ); > > + double get_center_freq( size_t chan = 0 ); > > + double set_freq_corr( double ppm, size_t chan = 0 ); > > + double get_freq_corr( size_t chan = 0 ); > > + > > + std::vector<std::string> get_gain_names( size_t chan = 0 ); > > + osmosdr::gain_range_t get_gain_range( size_t chan = 0 ); > > + osmosdr::gain_range_t get_gain_range( const std::string & name, > size_t chan = 0 ); > > + > > + double set_gain( double gain, size_t chan = 0 ) {return gain; } > > + double get_gain( size_t chan = 0 ) {return _att_value; } > > + > > + double set_attenuator( double gain, size_t chan = 0 ); > > + double get_attenuator( size_t chan = 0 ); > > + > > + double set_adc_preamp( double gain, size_t chan = 0 ); > > + double get_adc_preamp( size_t chan = 0 ); > > + > > + double set_adc_dither( double gain, size_t chan = 0 ); > > + double get_adc_dither( size_t chan = 0 ); > > + > > + double set_gain( double gain, const std::string & name, size_t chan = > 0 ); > > + double get_gain( const std::string & name, size_t chan = 0 ); > > + > > + std::vector< std::string > get_antennas( size_t chan = 0 ); > > + std::string set_antenna( const std::string & antenna, size_t chan = 0 > ); > > + std::string get_antenna( size_t chan = 0 ); > > + > > + > > +private: > > + static int _perseus_rx_callback(void *buf, int buf_size, void *extra); > > + > > + int perseus_rx_callback(void *samples, int sample_count); > > + > > + perseus_descr *_dev; > > + > > + boost::circular_buffer<gr_complex> *_fifo; > > + boost::mutex _fifo_lock; > > + boost::condition_variable _samp_avail; > > + > > + std::vector< std::pair<double, uint32_t> > _sample_rates; > > + double _sample_rate; > > + double _center_freq; > > + double _freq_corr; > > + > > + bool _frun; > > + int _cnt; > > + double _att_value; > > + bool _adc_preamp; > > + bool _adc_dither; > > + bool _preselector; > > +}; > > + > > +#endif /* INCLUDED_PERSEUS_SOURCE_C_H */ > > diff --git a/lib/source_impl.cc b/lib/source_impl.cc > > index a28f314..ead4ef7 100644 > > --- a/lib/source_impl.cc > > +++ b/lib/source_impl.cc > > @@ -92,6 +92,9 @@ > > #include <freesrp_source_c.h> > > #endif > > > > +#ifdef ENABLE_PERSEUS > > +#include <perseus_source_c.h> > > +#endif > > > > #include "arg_helpers.h" > > #include "source_impl.h" > > @@ -171,6 +174,9 @@ source_impl::source_impl( const std::string &args ) > > #ifdef ENABLE_FREESRP > > dev_types.push_back("freesrp"); > > #endif > > +#ifdef ENABLE_PERSEUS > > + dev_types.push_back("perseus"); > > +#endif > > std::cerr << "gr-osmosdr " > > << GR_OSMOSDR_VERSION << " (" << GR_OSMOSDR_LIBVER << ") " > > << "gnuradio " << gr::version() << std::endl; > > @@ -252,7 +258,10 @@ source_impl::source_impl( const std::string &args ) > > BOOST_FOREACH( std::string dev, freesrp_source_c::get_devices() ) > > dev_list.push_back( dev ); > > #endif > > - > > +#ifdef ENABLE_PERSEUS > > + BOOST_FOREACH( std::string dev, perseus_source_c::get_devices() ) > > + dev_list.push_back( dev ); > > +#endif > > // std::cerr << std::endl; > > // BOOST_FOREACH( std::string dev, dev_list ) > > // std::cerr << "'" << dev << "'" << std::endl; > > @@ -383,6 +392,13 @@ source_impl::source_impl( const std::string &args ) > > } > > #endif > > > > +#ifdef ENABLE_PERSEUS > > + if ( dict.count("perseus") ) { > > + perseus_source_c_sptr src = make_perseus_source_c( arg ); > > + block = src; iface = src.get(); > > + } > > +#endif > > + > > if ( iface != NULL && long(block.get()) != 0 ) { > > _devs.push_back( iface ); > > > > -------------- next part -------------- An HTML attachment was scrubbed... URL: <http://lists.osmocom.org/pipermail/osmocom-sdr/attachments/20180816/ee506896/attachment.htm>