osmocom-sdr March 2018

osmocom-sdr@lists.osmocom.org

6 participants
7 discussions

Start a nNew thread

gr-osmosdr: add clock_source= parameter

by Michael Loeffler

Hello, the attached patch allows to set the clock_source on uhd devices in programs like gqrx. Bye

3 years

[PATCH] gr-osmosdr Microtelecom Perseus HF receiver support (II)

by andrea.montefusco＠gmail.com

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(a)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 ); -- 1.9.1

5 years, 8 months

Re: Meaning of rtl_fm output values

by Müller, Marcus (CEL)

Hi Theodric, no, these values that appear on stdout are already audio samples (PCM to be specific). That is the "job" of rtl_fm: It takes the complex time-domain baseband samples from the hardware, detects FM (which implies detecting a frequency deviation) and convert that to audio amplitude values. The `aplay` command barely takes these samples and hands them over to the sound card (after resampling to fit possible sampling rates, I guess, as 120 kHz isn't something that sound systems usually operate at). The `rtl_fm` command takes a couple of parameters. In your case, `-M wbfm` means that it's demodulating FM in a way compatible to broadcast FM; that implies fixed parameters for deviation, emphasis etc. What you want is really not `rtl_fm`, which primarily is a demo program, not meant to be a flexible do-it-all solution. What you want, showing deviation of a station, does very much sound like a spectrum visualization. Wouldn't a waterfall or even just an instantaneous spectrum visualization be what you want? Best regards, Marcus On Wed, 2018-03-14 at 15:57 -0400, Theodric Young wrote: > Hi, > > I'm new to SDR and I have a question about the data values that are > generated by the rtl_fm program. > > I got rtl_fm running on my system (cygwin running on Windows 7). It is > sending a stream of 16-bit signed integer values to stdout which I can > redirect to a file or pipe to an audio playback system, such as sox. So > when I do this: > > rtl_fm -f 88.1M -M wbfm -s 240k -r120k -g 30 | play -t raw -r 120k -b > 16 -c 1 -e s -V1 - > > I hear sweet, sweet music! Hurray! > > But how do these 16-bit integers relate to the modulation level of the > carrier? I'm assuming that the values are directly proportional to the > instantaneous frequency deviation of the transmitted signal. Is that > right? If so, how do I determine that ratio? I'm hoping to use this to > build a device that shows total modulation (as a percentage of the > maximum modulation of +/- 75kHz) for an FM radio station. > > Also, I'm assuming that the sample-rate of the output data stream needs > to be at least 120kHz because the baseband signal includes the stereo > pilot (19kHz), the stereo subcarrier (38kHz) and an RBDS subcarrier (57 > kHz). > > Any insight would be appreciated. Thanks in advance, > > Theodric Young

6 years, 1 month

None

by None

by outgoing.mit.edu (8.13.8/8.12.4) with ESMTP id w2EJvsmv004135 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES128-SHA bits=128 verify=NOT) for <osmocom-sdr(a)lists.osmocom.org>; Wed, 14 Mar 2018 15:57:55 -0400 To: osmocom-sdr(a)lists.osmocom.org From: Theodric Young <theodric(a)mit.edu> Subject: Meaning of rtl_fm output values Message-ID: <d96cc71b-6d81-d786-ccd1-708c84eba0ff(a)mit.edu> Date: Wed, 14 Mar 2018 15:57:55 -0400 User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; rv:45.0) Gecko/20100101 Thunderbird/45.8.0 MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 7bit X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFjrPIsWRmVeSWpSXmKPExsUixCmqrHusbmWUwc1tLBb7Jl9hcWD0WHXa I4AxissmJTUnsyy1SN8ugSvjx87tbAX7OSv2bJ/G3sC4lr2LkZNDQsBEYvqcdSxdjFwcQgKL mSQWnj/DCuFcZZSY37eNDcKZxizRv/4YI0iLiICixOTf24FaODjYBNQlJv6zAQkLC2hIrL91 jwXE5hWwkvh96Q0TiM0ioCrxdtsWZhBbVCBGomXJB0aIGkGJkzOfgNUzC5hJzNv8kBnClpfY /nYO8wRG3llIymYhKZuFpGwBI/MqRtmU3Crd3MTMnOLUZN3i5MS8vNQiXRO93MwSvdSU0k2M 4FCS5N/BOKfB+xCjAAejEg+vgdrKKCHWxLLiytxDjJIcTEqivPunrIgS4kvKT6nMSCzOiC8q zUktPsQowcGsJMJ7vxConDclsbIqtSgfJiXNwaIkzutuoh0lJJCeWJKanZpakFoEk5Xh4FCS 4D1cC9QoWJSanlqRlplTgpBm4uAEGc4DNFyuDmR4cUFibnFmOkT+FKMxx5+HL9uYOW68eN3G LMSSl5+XKiXO+x5knABIaUZpHtw0UDq4yHbi3CtGcaDnhHkFQAbyAFMJ3LxXQKuYgFZlblsB sqokESEl1cAYvC/tgHRlS0bd5jnmP/RrNsU/5J6oKV7p8ixCsX/y/3f1+69NufA6bvK/ZD3H 9ONOL50fx7tsVejkM1b7PVkywsPsRnRig7Vbm3R4CnNom/9rs3aJA/Oas4WZ3H7tupb8N8np Qy/bcu5Nib3zr84VOPDxw2mnkitF08Nv2O89u0UxJ+n8wa9KLMUZiYZazEXFiQCH7MfT4gIA AA== X-BeenThere: osmocom-sdr(a)lists.osmocom.org X-Mailman-Version: 2.1.26 Precedence: list List-Id: "Discussion on Osmocom SDR projects $OsmoSDR, rtl-sdr$" <osmocom-sdr.lists.osmocom.org> List-Unsubscribe: <https://lists.osmocom.org/mailman/options/osmocom-sdr>, <mailto:osmocom-sdr-request@lists.osmocom.org?subject=unsubscribe> List-Archive: <http://lists.osmocom.org/pipermail/osmocom-sdr/> List-Post: <mailto:osmocom-sdr@lists.osmocom.org> List-Help: <mailto:osmocom-sdr-request@lists.osmocom.org?subject=help> List-Subscribe: <https://lists.osmocom.org/mailman/listinfo/osmocom-sdr>, <mailto:osmocom-sdr-request@lists.osmocom.org?subject=subscribe> X-List-Received-Date: Wed, 14 Mar 2018 19:57:59 -0000 Hi, I'm new to SDR and I have a question about the data values that are generated by the rtl_fm program. I got rtl_fm running on my system (cygwin running on Windows 7). It is sending a stream of 16-bit signed integer values to stdout which I can redirect to a file or pipe to an audio playback system, such as sox. So when I do this: rtl_fm -f 88.1M -M wbfm -s 240k -r120k -g 30 | play -t raw -r 120k -b 16 -c 1 -e s -V1 - I hear sweet, sweet music! Hurray! But how do these 16-bit integers relate to the modulation level of the carrier? I'm assuming that the values are directly proportional to the instantaneous frequency deviation of the transmitted signal. Is that right? If so, how do I determine that ratio? I'm hoping to use this to build a device that shows total modulation (as a percentage of the maximum modulation of +/- 75kHz) for an FM radio station. Also, I'm assuming that the sample-rate of the output data stream needs to be at least 120kHz because the baseband signal includes the stereo pilot (19kHz), the stereo subcarrier (38kHz) and an RBDS subcarrier (57 kHz). Any insight would be appreciated. Thanks in advance, Theodric Young

6 years, 1 month

antenna enquiry/long praise inc

by mary

6 years, 1 month

drop in replacement for nonfunctioning "discover_netsdr"

by dale ranta

The module “discover_netsdr” in “rfspace_source_c.cc” failed everywhere that I tried it, except for MacOS 10.6. Here is a drop in replacement that was tested and found to work on 10.6, 10.11, 10.12, 10.13 and ubuntu 16.04 LTS. #include <net/if.h> #include <ifaddrs.h> class interfaceInformation{ public: std::string name; std::string address; std::string broadcast; }; std::vector<interfaceInformation> interfaceList(); static std::vector < unit_t > discover_netsdr() { std::vector < unit_t > units; std::vector<interfaceInformation> list=interfaceList(); for(int pass=0;pass<2;++pass){ for(size_t n=0;n<list.size();++n){ if(pass == 1){ list[n].broadcast="255.255.255.255"; } //std::cout << "name " << list[n].name << std::endl; //std::cout << "address " << list[n].address << std::endl; //std::cout << "broadcast " << list[n].broadcast << std::endl; int sockTx; int sockRx; if ( (sockTx = socket(AF_INET, SOCK_DGRAM, 0)) < 0 ) continue; if ( (sockRx = socket(AF_INET, SOCK_DGRAM, 0)) < 0 ){ close(sockTx); continue; } int sockoptval = 1; setsockopt(sockTx, SOL_SOCKET, SO_REUSEADDR, &sockoptval, sizeof(int)); sockoptval = 1; setsockopt(sockTx, SOL_SOCKET, SO_BROADCAST, &sockoptval, sizeof(int)); struct sockaddr_in host_sa; /* local address */ struct sockaddr_in peer_sa; /* remote address */ struct sockaddr_in peer_sa2; /* remote address */ /* fill in the server's address and data */ memset((char*)&peer_sa, 0, sizeof(peer_sa)); peer_sa.sin_family = AF_INET; peer_sa.sin_addr.s_addr = htonl(inet_network(list[n].address.c_str())); peer_sa.sin_port = htons(DISCOVER_SERVER_PORT); /* fill in the server's address and data */ memset((char*)&peer_sa2, 0, sizeof(peer_sa2)); peer_sa2.sin_family = AF_INET; peer_sa2.sin_addr.s_addr = htonl(inet_network(list[n].broadcast.c_str())); peer_sa2.sin_port = htons(DISCOVER_SERVER_PORT); /* fill in the hosts's address and data */ memset(&host_sa, 0, sizeof(host_sa)); host_sa.sin_family = AF_INET; host_sa.sin_addr.s_addr = htonl(INADDR_ANY); host_sa.sin_port = htons(DISCOVER_CLIENT_PORT); if ( bind(sockTx, (struct sockaddr *)&peer_sa, sizeof(peer_sa)) < 0 ) { close(sockTx); close(sockRx); continue; } if ( bind(sockRx, (struct sockaddr *)&host_sa, sizeof(host_sa)) < 0 ) { perror("binding datagram sock2"); printf("errno %d DISCOVER_SERVER_PORT %d\n",errno,DISCOVER_SERVER_PORT); close(sockTx); close(sockRx); continue; } struct timeval tv; tv.tv_sec = 0; tv.tv_usec = 100000; if ( setsockopt(sockRx, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)) < 0 ) { close(sockRx); close(sockTx); continue; } discover_common_msg_t tx_msg; memset( (void *)&tx_msg, 0, sizeof(discover_common_msg_t) ); tx_msg.length[0] = sizeof(discover_common_msg_t); tx_msg.length[1] = sizeof(discover_common_msg_t) >> 8; tx_msg.key[0] = KEY0; tx_msg.key[1] = KEY1; tx_msg.op = MSG_REQ; sendto(sockTx, &tx_msg, sizeof(tx_msg), 0, (struct sockaddr *)&peer_sa, sizeof(peer_sa)); sendto(sockTx, &tx_msg, sizeof(tx_msg), 0, (struct sockaddr *)&peer_sa2, sizeof(peer_sa2)); while ( 1 ) { size_t rx_bytes = 0; unsigned char data[1024*2]; socklen_t addrlen = sizeof(host_sa); /* length of addresses */ int nbytes = recvfrom(sockRx, data, sizeof(data), 0, (struct sockaddr *)&host_sa, &addrlen); if ( nbytes <= 0 ) break; rx_bytes = nbytes; if ( rx_bytes >= sizeof(discover_common_msg_t) ) { discover_common_msg_t *rx_msg = (discover_common_msg_t *)data; if ( KEY0 == rx_msg->key[0] && KEY1 == rx_msg->key[1] && MSG_RESP == rx_msg->op ) { void *temp = rx_msg->port; uint16_t port = *((uint16_t *)temp); std::stringstream buffer; buffer << int(rx_msg->ipaddr[3]) << "." << int(rx_msg->ipaddr[2]) << "." << int(rx_msg->ipaddr[1]) << "." << int(rx_msg->ipaddr[0]); std::string addr=buffer.str(); //std::cout << "addr " << addr << std::endl; unit_t unit; unit.name = rx_msg->name; unit.sn = rx_msg->sn; unit.addr = addr; unit.port = port; units.push_back( unit ); } } } close(sockTx); close(sockRx); } } return units; } std::vector<interfaceInformation> interfaceList() { std::vector<interfaceInformation> list; interfaceInformation c1; struct ifaddrs *addrs,*iloop; char buf[64],buf2[64]; struct sockaddr_in *s4; getifaddrs(&addrs); for (iloop = addrs; iloop != NULL; iloop = iloop->ifa_next) { s4 = (struct sockaddr_in *)(iloop->ifa_addr); buf[0]=0; if(s4){ inet_ntop(iloop->ifa_addr->sa_family, (void *)&(s4->sin_addr), buf, sizeof(buf)); }else{ continue; } s4 = (struct sockaddr_in *)(iloop->ifa_dstaddr); buf2[0]=0; if(s4){ inet_ntop(iloop->ifa_dstaddr->sa_family, (void *)&(s4->sin_addr), buf2, sizeof(buf2)); }else{ continue; } if(!(iloop->ifa_flags & IFF_UP) || !(iloop->ifa_flags & IFF_BROADCAST))continue; c1.name = iloop->ifa_name; c1.address = buf; c1.broadcast = buf2; list.push_back(c1); } freeifaddrs(addrs); return list; }

6 years, 1 month

RTL-SDR sample bit depth

by John Ackermann N8UR

Hi -- I'm trying to understand the sampling and decimation structure of the RTL-SDR dongle, to work out the effective number of bits after decimation. From Google and looking at the librtlsdr code (which is beyond my programming depth), I think I've figured out the following. I'd much appreciate verification/correction/amplification. 1. Actual ADC in the RTL-2832U is a single-bit sigma-delta running at some very high rate. 2. This is converted to 28.8 msps at 8 bit depth. 3. 28.8 msps is downsampled to the rate requested by the user and sent over the USB bus as 8 bit unsigned IQ pairs. Based on that, I *think*: a. Any processing gain in the downsample from 28.8 msps/8 bits within the chip is lost because the wire samples are limited to 8 bits. The output is 8 bits dynamic range regardless of the sample rate set. b. THEREFORE... for best dynamic range one wants to set the RTL-2832U to the highest sample rate that avoids lost samples, and do further decimation in the host processor, where the added bits aren't lost on the wire. I'd appreciate any verification or correction of that analysis. Thanks, John

6 years, 1 month

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

osmocom-sdr March 2018