LimeSdrReader.h

// OBECA - Open Broadcast Edge Cache Appliance
// Receive Process
//
// Copyright (C) 2021 Klaus Kühnhammer (Österreichische Rundfunksender GmbH & Co KG)
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program 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 Affero General Public License for more details.
// 
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
 
#pragma once
 
#include <lime/LimeSuite.h>
#include <ring_buffer.h>
#include <string>
#include <thread>
#include <cstdint>
#include <libconfig.h++>
#include "srslte/srslte.h"
 
class LimeSdrReader {
 public:
    explicit LimeSdrReader(const libconfig::Config& cfg)
      : _buffer(bev::linear_ringbuffer::delayed_init {})
      , _overflows(0)
      , _underflows(0)
      , _cfg(cfg)
      , _readerThread{} {}
 
    virtual ~LimeSdrReader();
 
    bool init(uint8_t device_index, const char* sample_file, const char* write_sample_file);
 
    bool setSampleRate(unsigned sample_rate);
 
    bool tune(uint32_t frequency, uint32_t sample_rate, uint32_t bandwidth, double gain, const std::string& antenna);
 
    void start();
 
    void stop();
 
    void clear_buffer();
 
    int getSamples(cf_t* data, uint32_t nsamples, srslte_timestamp_t* rx_time);
 
    double get_sample_rate() { return _sampleRate; }
 
    double get_frequency() { return _frequency; }
 
    unsigned get_filter_bw() { return _filterBw; }
 
    double get_gain() { return _gain; }
 
    double get_buffer_level() { if (!_buffer_ready) { return 0; } return static_cast<double>(_buffer.size()) / static_cast<double>(_buffer.capacity()); }
 
    std::string get_antenna() { return _antenna; }
 
    uint32_t rssi() { return _rssi; }
 
 private:
    void read();
    void* _sdr = nullptr;
 
    const libconfig::Config& _cfg;
    lms_stream_t _stream;
    bev::linear_ringbuffer _buffer;
    std::thread _readerThread;
    bool _running;
 
    double _sampleRate;
    double _frequency;
    unsigned _filterBw;
    double _gain;
    std::string _antenna;
    unsigned _overflows;
    unsigned _underflows;
 
    cf_t* _read_buffer;
 
    srslte_filesource_t          file_source;
    srslte_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;
 
    uint32_t _rssi = 0;
};