LimeSdrReader Class Reference

Interface to LimeSDR via LimeSuite. More...

#include <LimeSdrReader.h>

Public Member Functions
	LimeSdrReader (const libconfig::Config &cfg)
	Default constructor. More...
virtual	~LimeSdrReader ()
	Default destructor.
bool	init (uint8_t device_index, const char *sample_file, const char *write_sample_file)
	Initializes the SDR interface and creates a ring buffer according to the params from Cfg.
bool	setSampleRate (unsigned sample_rate)
	Adjust the sample rate.
bool	tune (uint32_t frequency, uint32_t sample_rate, uint32_t bandwidth, double gain, const std::string &antenna)
	Tune the SDR to the desired frequency, and set gain, filter and antenna parameters.
void	start ()
	Start reading samples from the SDR.
void	stop ()
	Stop reading samples from the SDR.
void	clear_buffer ()
	Clear all samples from the rx buffers.
int	getSamples (cf_t *data, uint32_t nsamples, srslte_timestamp_t *rx_time)
	Store nsamples count samples into the buffer at data. More...
double	get_sample_rate ()
	Get current sample rate.
double	get_frequency ()
	Get current center frequency.
unsigned	get_filter_bw ()
	Get current filter bandwidth.
double	get_gain ()
	Get current gain.
double	get_buffer_level ()
	Get current ringbuffer level (0 = empty . More...
std::string	get_antenna ()
	Get current antenna port.
uint32_t	rssi ()
	Get RSSI estimate (disabled at the moment)

Detailed Description

Interface to LimeSDR via LimeSuite.

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

Definition at line 36 of file LimeSdrReader.h.

Constructor & Destructor Documentation

LimeSdrReader()

LimeSdrReader::LimeSdrReader ( const libconfig::Config &  cfg )

inlineexplicit

Default constructor.

Parameters

cfg	Config singleton reference

Definition at line 43 of file LimeSdrReader.h.

      : _buffer(bev::linear_ringbuffer::delayed_init {})
      , _overflows(0)
      , _underflows(0)
      , _cfg(cfg)
      , _readerThread{} {}

Member Function Documentation

get_buffer_level()

double LimeSdrReader::get_buffer_level ( )

inline

Get current ringbuffer level (0 = empty .

. 1 = full)

Definition at line 117 of file LimeSdrReader.h.

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

getSamples()

auto LimeSdrReader::getSamples	(	cf_t *	data,
		uint32_t	nsamples,
		srslte_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 306 of file LimeSdrReader.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.size() < (_sampleRate / 1000.0) * 10 * sizeof(cf_t)) {
    _high_watermark_reached = false;
  }
 
  if (!_high_watermark_reached) {
    while (_buffer.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;
  }
 
  memcpy(data, _buffer.read_head(), cnt);
  _buffer.consume(cnt);
 
  if (_buffer.size() < (_sampleRate / 1000.0) * (_buffer_ms / 2.0) * sizeof(cf_t)) {
    required_time_us += 500;
  } else {
    required_time_us -= 500;
  }
 
  spdlog::debug("read {} samples, adjusted required {} us, delta {} us, sleep adj {},  sleeping for {} us",
      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;
}

---

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

• src/LimeSdrReader.h
• src/LimeSdrReader.cpp