Interface to the SDR stick. More...

#include <SdrReader.h>

Collaboration diagram for SdrReader:

Public Member Functions
	SdrReader (const libconfig::Config &cfg, size_t rx_channels)
	Default constructor. More...

virtual	~SdrReader ()
	Default destructor. More...

void	enumerateDevices ()
	Prints a list of all available SDR devices. More...

bool	init (const std::string &device_args, const char sample_file, const char write_sample_file, bool repeat_sample_file)
	Initializes the SDR interface and creates a ring buffer according to the params from Cfg. More...

bool	tune (uint32_t frequency, uint32_t sample_rate, uint32_t bandwidth, double gain, const std::string &antenna, bool use_agc)
	Tune the SDR to the desired frequency, and set gain, filter and antenna parameters. More...

void	start ()
	Start reading samples from the SDR. More...

void	stop ()
	Stop reading samples from the SDR. More...

void	clear_buffer ()
	Clear all samples from the rx buffers. More...

int	get_samples (cf_t data[SRSRAN_MAX_CHANNELS], uint32_t nsamples, srsran_timestamp_t rx_time)
	Store nsamples count samples into the buffer at data. More...

double	get_sample_rate ()
	Get current sample rate. More...

double	get_frequency ()
	Get current center frequency. More...

unsigned	get_filter_bw ()
	Get current filter bandwidth. More...

double	get_gain ()
	Get current gain. More...

double	get_buffer_level ()
	Get current ringbuffer level (0 = empty . More...

std::string	get_antenna ()
	Get current antenna port. More...

uint32_t	rssi ()
	Get RSSI estimate (disabled at the moment) More...

double	min_gain ()

double	max_gain ()

void	enableSampleFileWriting ()
	If sample file creation is enabled, writing samples starts after this call. More...

void	disableSampleFileWriting ()
	If sample file creation is enabled, writing samples stops after this call. More...

Private Member Functions
void	init_buffer ()

bool	set_gain (bool use_agc, double gain, uint8_t idx)

bool	set_sample_rate (uint32_t rate, uint8_t idx)

bool	set_filter_bw (uint32_t bandwidth, uint8_t idx)

bool	set_antenna (const std::string &antenna, uint8_t idx)

bool	set_frequency (uint32_t frequency, uint8_t idx)

void	read ()

Private Attributes
void *	_sdr = nullptr

void *	_stream = nullptr

const libconfig::Config &	_cfg

std::unique_ptr< MultichannelRingbuffer >	_buffer

std::unique_ptr< MultichannelRingbuffer >	_buffer_write

std::thread	_readerThread

bool	_running

unsigned	_rx_channels = 1

double	_sampleRate

double	_frequency

unsigned	_filterBw

double	_gain

bool	_use_agc

double	_min_gain

double	_max_gain

std::string	_antenna

unsigned	_overflows

unsigned	_underflows

cf_t *	_read_buffer

srsran_filesource_t	file_source

srsran_filesink_t	file_sink

std::chrono::steady_clock::time_point	_last_read

bool	_high_watermark_reached = false

int	_sleep_adjustment = 0

unsigned	_buffer_ms = 200

bool	_buffer_ready = false

bool	_reading_from_file = false

bool	_writing_to_file = false

bool	_write_samples = false

bool	_repeat_sample_file = false

uint32_t	_rssi = 0

bool	_temp_sensor_available = false

std::string	_temp_sensor_key = {}

std::map< std::string, std::string >	_device_args

Detailed Description

Interface to the SDR stick.

Sets up the SDR, reads samples from it, and handles a ringbuffer for the received samples.

Definition at line 37 of file SdrReader.h.

Constructor & Destructor Documentation

◆ SdrReader()

SdrReader::SdrReader	(	const libconfig::Config &	cfg,
		size_t	rx_channels
	)

inlineexplicit

Default constructor.

Parameters

cfg	Config singleton reference

Definition at line 44 of file SdrReader.h.

45 : _overflows(0), _underflows(0), _cfg(cfg), _rx_channels(rx_channels), _readerThread{} {}

SdrReader::_cfg

const libconfig::Config & _cfg

Definition: SdrReader.h:159

SdrReader::_readerThread

std::thread _readerThread

Definition: SdrReader.h:164

SdrReader::_rx_channels

unsigned _rx_channels

Definition: SdrReader.h:167

SdrReader::_overflows

unsigned _overflows

Definition: SdrReader.h:176

SdrReader::_underflows

unsigned _underflows

Definition: SdrReader.h:177

cfg

static Config cfg

Global configuration object.

Definition: main.cpp:172

◆ ~SdrReader()

SdrReader::~SdrReader ( )

virtual

Default destructor.

Definition at line 32 of file SdrReader.cpp.

                        {
   if (_sdr != nullptr) {
     auto sdr = (SoapySDR::Device*)_sdr;
     sdr->deactivateStream((SoapySDR::Stream*)_stream, 0, 0);
     sdr->closeStream((SoapySDR::Stream*)_stream);
     SoapySDR::Device::unmake( sdr );
   }
  
   if (_reading_from_file) {
     srsran_filesource_free(&file_source);
   }
  
   if (_writing_to_file) {
     srsran_filesink_free(&file_sink);
   }
 }

Member Function Documentation

◆ clear_buffer()

void SdrReader::clear_buffer ( )

Clear all samples from the rx buffers.

Definition at line 109 of file SdrReader.cpp.

                              {
   _buffer->clear();
   _buffer_write->clear();
   _high_watermark_reached = false;
 }

◆ disableSampleFileWriting()

void SdrReader::disableSampleFileWriting ( )

inline

If sample file creation is enabled, writing samples stops after this call.

Definition at line 139 of file SdrReader.h.

139 { _write_samples = false; }

SdrReader::_write_samples

bool _write_samples

Definition: SdrReader.h:193

◆ enableSampleFileWriting()

void SdrReader::enableSampleFileWriting ( )

inline

If sample file creation is enabled, writing samples starts after this call.

Definition at line 134 of file SdrReader.h.

134 { _write_samples = true; }

◆ enumerateDevices()

void SdrReader::enumerateDevices ( )

Prints a list of all available SDR devices.

Definition at line 49 of file SdrReader.cpp.

 {
   auto results = SoapySDR::Device::enumerate();
     SoapySDR::Kwargs::iterator it;
  
     for( int i = 0; i < results.size(); ++i)
     {
         printf("Device #%d:\n", i);
         for( it = results[i].begin(); it != results[i].end(); ++it)
         {
             printf("%s = %s\n", it->first.c_str(), it->second.c_str());
         }
         printf("\n\n");
     }
  
 }

◆ get_antenna()

std::string SdrReader::get_antenna ( )

inline

Get current antenna port.

Definition at line 120 of file SdrReader.h.

120 { return _antenna; }

SdrReader::_antenna

std::string _antenna

Definition: SdrReader.h:175

◆ get_buffer_level()

auto SdrReader::get_buffer_level ( )

Get current ringbuffer level (0 = empty .

. 1 = full)

Definition at line 399 of file SdrReader.cpp.

 { 
   if (!_buffer_ready) { 
     return 0; 
   } 
   return static_cast<double>(_buffer->used_size()) / static_cast<double>(_buffer->capacity()); 
 }

◆ get_filter_bw()

unsigned SdrReader::get_filter_bw ( )

inline

Get current filter bandwidth.

Definition at line 105 of file SdrReader.h.

105 { return _filterBw; }

SdrReader::_filterBw

unsigned _filterBw

Definition: SdrReader.h:170

◆ get_frequency()

double SdrReader::get_frequency ( )

inline

Get current center frequency.

Definition at line 100 of file SdrReader.h.

100 { return _frequency; }

SdrReader::_frequency

double _frequency

Definition: SdrReader.h:169

◆ get_gain()

double SdrReader::get_gain ( )

inline

Get current gain.

Definition at line 110 of file SdrReader.h.

110 { return _gain; }

SdrReader::_gain

double _gain

Definition: SdrReader.h:171

◆ get_sample_rate()

double SdrReader::get_sample_rate ( )

inline

Get current sample rate.

Definition at line 95 of file SdrReader.h.

95 { return _sampleRate; }

SdrReader::_sampleRate

double _sampleRate

Definition: SdrReader.h:168

◆ get_samples()

auto SdrReader::get_samples	(	cf_t *	data[SRSRAN_MAX_CHANNELS],
		uint32_t	nsamples,
		srsran_timestamp_t *	rx_time
	)

Store nsamples count samples into the buffer at data.

Parameters

data	Buffer pointer
nsamples	sample count
rx_time	unused

Definition at line 345 of file SdrReader.cpp.

                                          {
   std::chrono::steady_clock::time_point entered = {};
   entered = std::chrono::steady_clock::now();
  
   int64_t required_time_us = (1000000.0/_sampleRate) * nsamples;
   size_t cnt = nsamples * sizeof(cf_t);
  
   if (_high_watermark_reached &&  _buffer->used_size() < (_sampleRate / 1000.0) * 10 * sizeof(cf_t)) {
     _high_watermark_reached = false;
   }
  
   if (!_high_watermark_reached) {
     while (_buffer->used_size() < (_sampleRate / 1000.0) * (_buffer_ms / 2.0) * sizeof(cf_t)) {
       std::this_thread::sleep_for(std::chrono::microseconds(500));
     }
     spdlog::debug("Filled ringbuffer to half capacity");
     _high_watermark_reached = true;
   }
  
   std::vector<char*> buffers(_rx_channels);
   for (auto ch = 0; ch < _rx_channels; ch++) {
     buffers[ch] = (char*)data[ch];
   }
   _buffer->read(buffers, cnt); // Copy from the ringbuffer to the data array. This also decreases _used.
  
   if (_buffer->used_size() < (_sampleRate / 1000.0) * (_buffer_ms / 4.0) * sizeof(cf_t)) {
     required_time_us += 500;
   } else {
     required_time_us -= 500;
   }
  
   spdlog::debug("took {}, read {} samples, adjusted required {} us, delta {} us, sleep adj {},  sleeping for {} us",
       std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - entered).count(),
       nsamples,
       std::chrono::microseconds(required_time_us).count(),
       std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - _last_read).count(),
       _sleep_adjustment,
       (std::chrono::microseconds(_sleep_adjustment + required_time_us) - std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - _last_read)).count());
  
   std::chrono::microseconds sleep = (std::chrono::microseconds(_sleep_adjustment + required_time_us) - std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - _last_read));
  
   if (sleep.count() > 0) {
     std::this_thread::sleep_for(sleep);
     _sleep_adjustment = 0;
   } else if (sleep.count() > -100000) {
     _sleep_adjustment = sleep.count();
   }
  
   _last_read = std::chrono::steady_clock::now();
   return 0;
 }

◆ init()

auto SdrReader::init	(	const std::string &	device_args,
		const char *	sample_file,
		const char *	write_sample_file,
		bool	repeat_sample_file
	)

Initializes the SDR interface and creates a ring buffer according to the params from Cfg.

Definition at line 66 of file SdrReader.cpp.

                                                                                          {
   if (sample_file != nullptr) {
     if (0 == srsran_filesource_init(&file_source,
                                     const_cast<char*>(sample_file),
                                     SRSRAN_COMPLEX_FLOAT_BIN)) {
       _reading_from_file = true;
       _repeat_sample_file = repeat_sample_file;
     } else {
       spdlog::error("Could not open file {}", sample_file);
       return false;
     }
   } else {
     if (write_sample_file != nullptr) {
       if (0 == srsran_filesink_init(&file_sink,
                                     const_cast<char*>(write_sample_file),
                                     SRSRAN_COMPLEX_FLOAT_BIN)) {
         _writing_to_file = true;
       } else {
         spdlog::error("Could not open file {}", write_sample_file);
         return false;
       }
     }
     _device_args = SoapySDR::KwargsFromString(device_args);
     _sdr = SoapySDR::Device::make(_device_args);
     if (_sdr == nullptr)
     {
       spdlog::error("SoapySDR: failed to open device with args {}", device_args);
       return false;
     }
   }
  
   _cfg.lookupValue("modem.sdr.ringbuffer_size_ms", _buffer_ms);
   return true;
 }

◆ init_buffer()

void SdrReader::init_buffer ( )

private

Definition at line 102 of file SdrReader.cpp.

                             {
   auto buffer_size = (unsigned int)ceil(_sampleRate/1000.0 * _buffer_ms);
   _buffer = std::make_unique<MultichannelRingbuffer>(sizeof(cf_t) * buffer_size, _rx_channels);
   _buffer_write = std::make_unique<MultichannelRingbuffer>(sizeof(cf_t) * buffer_size / 2, _rx_channels); // This is the buffer where we will store the samples to write a big chunk of samples instead many little ones. 1 GB seems to be a sweet amount to write (16e6 * sizeof(cf_t) = 1GB).
   _buffer_ready = true;
 }

◆ max_gain()

double SdrReader::max_gain ( )

inline

Definition at line 129 of file SdrReader.h.

129 { return _max_gain; }

SdrReader::_max_gain

double _max_gain

Definition: SdrReader.h:174

◆ min_gain()

double SdrReader::min_gain ( )

inline

Definition at line 127 of file SdrReader.h.

127 { return _min_gain; }

SdrReader::_min_gain

double _min_gain

Definition: SdrReader.h:173

◆ read()

void SdrReader::read ( )

private

Definition at line 268 of file SdrReader.cpp.

                      {
   std::array<void*, SRSRAN_MAX_CHANNELS> radio_buffers = { nullptr };
   while (_running) {
     int toRead = ceil(_sampleRate / 1000.0);
     //int toRead = 254;
     if (_buffer->free_size() < toRead * sizeof(cf_t)) {
       spdlog::debug("ringbuffer overflow");
       std::this_thread::sleep_for(std::chrono::microseconds(1000));
     } else {
       int read = 0;
       size_t writeable = 0;
       size_t writeable_write = 0;
       auto buffers = _buffer->write_head(&writeable);
       auto buffers_write = _buffer_write->write_head(&writeable_write);
       int writeable_samples = (int)floor(writeable / sizeof(cf_t));
       int writeable_write_samples = (int)floor(writeable_write / sizeof(cf_t));
  
       if (_reading_from_file) {
         std::chrono::steady_clock::time_point entered = {};
         entered = std::chrono::steady_clock::now();
  
         read = srsran_filesource_read_multi(&file_source, buffers.data(), std::min(writeable_samples, toRead), (int)_rx_channels);
         if ( read == 0  ) {
           if (_repeat_sample_file) {
             srsran_filesource_seek(&file_source, 0);
           } else {
             spdlog::info("EOF, exiting...");
             raise(SIGINT); //SIGINT to signal srsran that we want to exit.
           }
         }
         read = read / _rx_channels;
         int64_t required_time_us = (1000000.0/_sampleRate) * read;
  
         if (read > 0) {
           _buffer->commit( read * sizeof(cf_t) );
         }
  
         std::chrono::microseconds sleep = (std::chrono::microseconds(required_time_us) -
             std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - entered));
         std::this_thread::sleep_for(sleep);
       } else {
         auto sdr = (SoapySDR::Device*)_sdr;
         int flags = 0;
         long long time_ns = 0;
         auto rbuff = buffers.data();
         auto wbuff = buffers_write.data();
  
         read = sdr->readStream( (SoapySDR::Stream*)_stream, buffers.data(), std::min(writeable_samples, toRead), flags, time_ns);
  
         if (read> 0 ) {
          
           if (_writing_to_file && _write_samples && writeable_write_samples) { // Only if we are going to write into a file.
             for (int i = 0; i < _rx_channels; i++) {
              memcpy(wbuff[i], rbuff[i], std::min(writeable_write_samples, read) * sizeof(cf_t)); // Copy the data in the input buffer to the toWrite buffer.
             }
             _buffer_write->commit( std::min(writeable_write_samples, read) * sizeof(cf_t)); // We used another ring buffer for the written of the samples, to not block a lot we only write to the disk when the ring buffer is at 90% of its capacity
           }
           _buffer->commit( read * sizeof(cf_t) );
     
           if (_writing_to_file && _write_samples && _buffer_write->used_size() >= 0.90* _buffer_write->capacity()) {
             int toWrite_samples = _buffer_write->used_size() / sizeof(cf_t); // We are going to storage all the info
             auto buff_to_write = _buffer_write->read_head(); // Gives the beggining of the buffer, it also puts _used and _head to 0, to start adding at the beggining again.
             srsran_filesink_write_multi(&file_sink, buff_to_write.data(), toWrite_samples, (int)_rx_channels); // From the beggining of the buffer we write used_size data
           }
               spdlog::debug("buffer: commited {}, requested {}, writeable {}, writeable_write {}, flags {}", read, toRead, writeable_samples, writeable_write_samples, flags);
         }
         else {
           spdlog::error("readStream returned {}", read);
           _buffer->commit( toRead * sizeof(cf_t) );
           _buffer_write->commit(toRead * sizeof(cf_t)); 
         }
       }
     }
   }
   spdlog::debug("Sample reader thread exited");
 }

◆ rssi()

uint32_t SdrReader::rssi ( )

inline

Get RSSI estimate (disabled at the moment)

Definition at line 125 of file SdrReader.h.

125 { return _rssi; }

SdrReader::_rssi

uint32_t _rssi

Definition: SdrReader.h:196

◆ set_antenna()

auto SdrReader::set_antenna	(	const std::string &	antenna,
		uint8_t	idx
	)

private

Definition at line 115 of file SdrReader.cpp.

                                                                          {
   auto sdr = (SoapySDR::Device*)_sdr;
   auto antenna_list = sdr->listAntennas(SOAPY_SDR_RX, idx);
   if (std::find(antenna_list.begin(), antenna_list.end(), antenna) != antenna_list.end()) {
     sdr->setAntenna( SOAPY_SDR_RX, idx, antenna);
     _antenna = sdr->getAntenna( SOAPY_SDR_RX, idx);
     return true;
   } else {
     spdlog::error("Unknown antenna \"{}\". Available: {}.", antenna, boost::algorithm::join(antenna_list, ", ") );
     return false;
   }
 }

◆ set_filter_bw()

auto SdrReader::set_filter_bw	(	uint32_t	bandwidth,
		uint8_t	idx
	)

private

Definition at line 134 of file SdrReader.cpp.

                                                                      {
   auto sdr = (SoapySDR::Device*)_sdr;
   sdr->setBandwidth( SOAPY_SDR_RX, idx, bandwidth);
   return true;
 }

◆ set_frequency()

auto SdrReader::set_frequency	(	uint32_t	frequency,
		uint8_t	idx
	)

private

Definition at line 128 of file SdrReader.cpp.

                                                                      {
   auto sdr = (SoapySDR::Device*)_sdr;
   sdr->setFrequency( SOAPY_SDR_RX, idx, frequency);
   return true;
 }

◆ set_gain()

auto SdrReader::set_gain	(	bool	use_agc,
		double	gain,
		uint8_t	idx
	)

private

Definition at line 146 of file SdrReader.cpp.

                                                                        {
   auto sdr = (SoapySDR::Device*)_sdr;
   if (sdr->hasGainMode(SOAPY_SDR_RX, idx)) {
 //    spdlog::info("{} AGC", use_agc ? "Enabling" : "Disabling");
     sdr->setGainMode(SOAPY_SDR_RX, idx, use_agc);
   } else if (use_agc) {
 //    spdlog::info("AGC is not supported by this device, please set gain manually");
   }
   auto gain_range = sdr->getGainRange(SOAPY_SDR_RX, idx);
   _min_gain = gain_range.minimum();
   _max_gain = gain_range.maximum();
   if (gain >= gain_range.minimum() && gain <= gain_range.maximum()) {
     sdr->setGain( SOAPY_SDR_RX, idx, gain);
     if (idx == 0) {
       _gain = sdr->getGain( SOAPY_SDR_RX, idx);
     }
     return true;
   } else {
     spdlog::error("Invalid gain setting {}. Allowed range is: {} - {}.", gain, gain_range.minimum(), gain_range.maximum());
     return false;
   }
 }

◆ set_sample_rate()

auto SdrReader::set_sample_rate	(	uint32_t	rate,
		uint8_t	idx
	)

private

Definition at line 140 of file SdrReader.cpp.

                                                                   {
   auto sdr = (SoapySDR::Device*)_sdr;
   sdr->setSampleRate( SOAPY_SDR_RX, idx, rate);
   return true;
 }

◆ start()

void SdrReader::start ( )

Start reading samples from the SDR.

Definition at line 216 of file SdrReader.cpp.

                       {
   if (_sdr != nullptr) {
     auto sdr = (SoapySDR::Device*)_sdr;
     std::vector<size_t> channels(_rx_channels);
     for (auto ch = 0; ch < _rx_channels; ch++) {
       channels[ch] = ch;
     }
     sdr->setHardwareTime(0); // Set SDR timestamp to zero.
     _stream = sdr->setupStream( SOAPY_SDR_RX, SOAPY_SDR_CF32, channels, _device_args);
     if( _stream == nullptr)
     {
       spdlog::error("Failed to set up RX stream");
       SoapySDR::Device::unmake( sdr );
       return ;
     }
     sdr->activateStream( (SoapySDR::Stream*)_stream, SOAPY_SDR_HAS_TIME, 100000000, 0); // Delayed start of the SDR reception, to avoid overfloas at the beggining.
   }
   _running = true;
  
   // Start the reader thread and elevate its priority to realtime
   _readerThread = std::thread{&SdrReader::read, this};
   struct sched_param thread_param = {};
   thread_param.sched_priority = 50;
   int min_prio = sched_get_priority_min(SCHED_RR);
   int max_prio = sched_get_priority_max(SCHED_RR);
   
   if (min_prio == -1 or max_prio == -1) 
       spdlog::error("Something went wrong, error in sched_get_priority_min/max");
  
   _cfg.lookupValue("modem.sdr.reader_thread_priority_rt", thread_param.sched_priority);
  
   spdlog::debug("Launching sample reader thread with realtime scheduling priority {}, available priorities, max: {}, min: {}", thread_param.sched_priority, max_prio, min_prio);
  
   int error = pthread_setschedparam(_readerThread.native_handle(), SCHED_RR, &thread_param);
   if (error != 0) {
     spdlog::warn("Cannot set reader thread priority to realtime: {}. Thread will run at default priority with a high probability of dropped samples and loss of synchronisation.", strerror(error));
   }
 }

◆ stop()

void SdrReader::stop ( )

Stop reading samples from the SDR.

Definition at line 255 of file SdrReader.cpp.

                      {
   _running = false;
  
   _readerThread.join();
   if (_sdr != nullptr) {
     auto sdr = (SoapySDR::Device*)_sdr;
     sdr->deactivateStream((SoapySDR::Stream*)_stream, 0, 0);
     sdr->closeStream((SoapySDR::Stream*)_stream);
   }
  
   clear_buffer();
 }

◆ tune()

auto SdrReader::tune	(	uint32_t	frequency,
		uint32_t	sample_rate,
		uint32_t	bandwidth,
		double	gain,
		const std::string &	antenna,
		bool	use_agc
	)

Tune the SDR to the desired frequency, and set gain, filter and antenna parameters.

Definition at line 169 of file SdrReader.cpp.

                                                                                      {
   _frequency = frequency;
   _filterBw = bandwidth;
   _sampleRate = sample_rate;
   _use_agc = use_agc;
  
   init_buffer();
  
   if (_reading_from_file) {
     return true;
   }
  
   if (_sdr == nullptr) {
     return false;
   }
  
   spdlog::info("Tuning to {} MHz, filter bandwidth {} MHz, sample rate {}, gain {}, antenna path {} with AGC set to {}",
       frequency/1000000.0, bandwidth/1000000.0, sample_rate/1000000.0, gain, antenna, use_agc);
  
   auto sdr = (SoapySDR::Device*)_sdr;
  
   for (auto ch = 0; ch < _rx_channels; ch++) {
     set_antenna(antenna, ch);
     set_gain(_use_agc, gain, ch);
     set_frequency(frequency, ch);
     set_filter_bw(bandwidth, ch);
     set_sample_rate(sample_rate, ch);
   }
  
   _frequency = sdr->getFrequency( SOAPY_SDR_RX, 0);
   bandwidth = sdr->getBandwidth( SOAPY_SDR_RX, 0);
   _sampleRate = sdr->getSampleRate( SOAPY_SDR_RX, 0);
  
   spdlog::info("SDR tuned to {} MHz, filter bandwidth {} MHz, sample rate {}, gain {}, antenna path {}",
       _frequency/1000000.0, bandwidth/1000000.0, _sampleRate/1000000.0, _gain, _antenna);
  
  
   auto sensors = sdr->listSensors();
   if (std::find(sensors.begin(), sensors.end(), "lms7_temp") != sensors.end()) {
     _temp_sensor_available = true;
     _temp_sensor_key = "lms7_temp";
   }
  
   return true;
 }

Member Data Documentation

◆ _antenna

std::string SdrReader::_antenna

private

Definition at line 175 of file SdrReader.h.

◆ _buffer

std::unique_ptr<MultichannelRingbuffer> SdrReader::_buffer

private

Definition at line 161 of file SdrReader.h.

◆ _buffer_ms

unsigned SdrReader::_buffer_ms = 200

private

Definition at line 189 of file SdrReader.h.

◆ _buffer_ready

bool SdrReader::_buffer_ready = false

private

Definition at line 190 of file SdrReader.h.

◆ _buffer_write

std::unique_ptr<MultichannelRingbuffer> SdrReader::_buffer_write

private

Definition at line 162 of file SdrReader.h.

◆ _cfg

const libconfig::Config& SdrReader::_cfg

private

Definition at line 159 of file SdrReader.h.

◆ _device_args

std::map<std::string, std::string> SdrReader::_device_args

private

Definition at line 201 of file SdrReader.h.

◆ _filterBw

unsigned SdrReader::_filterBw

private

Definition at line 170 of file SdrReader.h.

◆ _frequency

double SdrReader::_frequency

private

Definition at line 169 of file SdrReader.h.

◆ _gain

double SdrReader::_gain

private

Definition at line 171 of file SdrReader.h.

◆ _high_watermark_reached

bool SdrReader::_high_watermark_reached = false

private

Definition at line 186 of file SdrReader.h.

◆ _last_read

std::chrono::steady_clock::time_point SdrReader::_last_read

private

Definition at line 184 of file SdrReader.h.

◆ _max_gain

double SdrReader::_max_gain

private

Definition at line 174 of file SdrReader.h.

◆ _min_gain

double SdrReader::_min_gain

private

Definition at line 173 of file SdrReader.h.

◆ _overflows

unsigned SdrReader::_overflows

private

Definition at line 176 of file SdrReader.h.

◆ _read_buffer

cf_t* SdrReader::_read_buffer

private

Definition at line 179 of file SdrReader.h.

◆ _readerThread

std::thread SdrReader::_readerThread

private

Definition at line 164 of file SdrReader.h.

◆ _reading_from_file

bool SdrReader::_reading_from_file = false

private

Definition at line 191 of file SdrReader.h.

◆ _repeat_sample_file

bool SdrReader::_repeat_sample_file = false

private

Definition at line 194 of file SdrReader.h.

◆ _rssi

uint32_t SdrReader::_rssi = 0

private

Definition at line 196 of file SdrReader.h.

◆ _running

bool SdrReader::_running

private

Definition at line 165 of file SdrReader.h.

◆ _rx_channels

unsigned SdrReader::_rx_channels = 1

private

Definition at line 167 of file SdrReader.h.

◆ _sampleRate

double SdrReader::_sampleRate

private

Definition at line 168 of file SdrReader.h.

◆ _sdr

void* SdrReader::_sdr = nullptr

private

Definition at line 156 of file SdrReader.h.

◆ _sleep_adjustment

int SdrReader::_sleep_adjustment = 0

private

Definition at line 187 of file SdrReader.h.

◆ _stream

void* SdrReader::_stream = nullptr

private

Definition at line 157 of file SdrReader.h.

◆ _temp_sensor_available

bool SdrReader::_temp_sensor_available = false

private

Definition at line 198 of file SdrReader.h.

◆ _temp_sensor_key

std::string SdrReader::_temp_sensor_key = {}

private

Definition at line 199 of file SdrReader.h.

◆ _underflows

unsigned SdrReader::_underflows

private

Definition at line 177 of file SdrReader.h.

◆ _use_agc

bool SdrReader::_use_agc

private

Definition at line 172 of file SdrReader.h.

◆ _write_samples

bool SdrReader::_write_samples = false

private

Definition at line 193 of file SdrReader.h.

◆ _writing_to_file

bool SdrReader::_writing_to_file = false

private

Definition at line 192 of file SdrReader.h.

◆ file_sink

srsran_filesink_t SdrReader::file_sink

private

Definition at line 182 of file SdrReader.h.

◆ file_source

srsran_filesource_t SdrReader::file_source

private

Definition at line 181 of file SdrReader.h.

The documentation for this class was generated from the following files:

src/SdrReader.h
src/SdrReader.cpp

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ SdrReader()

◆ ~SdrReader()

Member Function Documentation

◆ clear_buffer()

◆ disableSampleFileWriting()

◆ enableSampleFileWriting()

◆ enumerateDevices()

◆ get_antenna()

◆ get_buffer_level()

◆ get_filter_bw()

◆ get_frequency()

◆ get_gain()

◆ get_sample_rate()

◆ get_samples()

◆ init()

◆ init_buffer()

◆ max_gain()

◆ min_gain()

◆ read()

◆ rssi()

◆ set_antenna()

◆ set_filter_bw()

◆ set_frequency()

◆ set_gain()

◆ set_sample_rate()

◆ start()

◆ stop()

◆ tune()

Member Data Documentation

◆ _antenna

◆ _buffer

◆ _buffer_ms

◆ _buffer_ready

◆ _buffer_write

◆ _cfg

◆ _device_args

◆ _filterBw

◆ _frequency

◆ _gain

◆ _high_watermark_reached

◆ _last_read

◆ _max_gain

◆ _min_gain

◆ _overflows

◆ _read_buffer

◆ _readerThread

◆ _reading_from_file

◆ _repeat_sample_file

◆ _rssi

◆ _running

◆ _rx_channels

◆ _sampleRate

◆ _sdr

◆ _sleep_adjustment

◆ _stream

◆ _temp_sensor_available

◆ _temp_sensor_key

◆ _underflows

◆ _use_agc

◆ _write_samples

◆ _writing_to_file

◆ file_sink

◆ file_source