srsLTE/lib/include/srslte/radio/radio.h

/*
 * Copyright 2013-2019 Software Radio Systems Limited
 *
 * This file is part of srsLTE.
 *
 * srsLTE 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.
 *
 * srsLTE 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.
 *
 * A copy of the GNU Affero General Public License can be found in
 * the LICENSE file in the top-level directory of this distribution
 * and at http://www.gnu.org/licenses/.
 *
 */

#include <string.h>

#include "srslte/common/log_filter.h"
#include "srslte/common/trace.h"
#include "srslte/phy/rf/rf.h"
#include "srslte/srslte.h"

#ifndef SRSLTE_RADIO_H
#define SRSLTE_RADIO_H

namespace srslte {

/* Interface to the RF frontend. 
  */
class radio {
 public:
   radio() : tr_local_time(1024 * 10), tr_usrp_time(1024 * 10), tr_tx_time(1024 * 10), tr_is_eob(1024 * 10), zeros(NULL)
   {
     bzero(&rf_device, sizeof(srslte_rf_t));
     bzero(&end_of_burst_time, sizeof(srslte_timestamp_t));
     zeros = (cf_t*)srslte_vec_malloc(burst_preamble_max_samples * sizeof(cf_t));
     bzero(zeros, burst_preamble_max_samples * sizeof(cf_t));

     log_h = NULL;

     burst_preamble_sec          = 0;
     is_start_of_burst           = false;
     burst_preamble_samples      = 0;
     burst_preamble_time_rounded = 0;

     cur_tx_srate       = 0;
     tx_adv_sec         = 0;
     tx_adv_nsamples    = 0;
     tx_adv_auto        = false;
     tx_adv_negative    = false;
     tx_freq            = 0;
     rx_freq            = 0;
     freq_offset        = 0;
     trace_enabled      = false;
     tti                = 0;
     agc_enabled        = false;
     radio_is_streaming = false;
     is_initialized     = false;
     continuous_tx      = false;
  };

  ~radio()
  {
    if (zeros) {
      free(zeros);
      zeros = NULL;
    }
  }

  bool init(log_filter* _log_h, char* args = NULL, char* devname = NULL, uint32_t nof_channels = 1);
  void stop();
  void reset();
  bool start_agc(bool tx_gain_same_rx = false);

  void set_burst_preamble(double preamble_us);
  void set_tx_adv(int nsamples);
  void set_tx_adv_neg(bool tx_adv_is_neg);

  bool is_continuous_tx();
  void set_continuous_tx(bool enable);

  void get_time(srslte_timestamp_t *now);
  int  synch_wait();
  void synch_issue();
  bool tx_single(cf_t* buffer, uint32_t nof_samples, srslte_timestamp_t tx_time);
  bool tx(cf_t* buffer[SRSLTE_MAX_PORTS], uint32_t nof_samples, srslte_timestamp_t tx_time);
  void tx_end();
  bool get_is_start_of_burst();
  bool rx_now(cf_t* buffer[SRSLTE_MAX_PORTS], uint32_t nof_samples, srslte_timestamp_t* rxd_time);
  bool rx_at(cf_t* buffer, uint32_t nof_samples, srslte_timestamp_t rx_time);

  void set_tx_gain(float gain);
  void set_rx_gain(float gain);
  void set_tx_rx_gain_offset(float offset);
  double set_rx_gain_th(float gain);

  void set_freq_offset(double freq);
  void set_tx_freq(uint32_t chan, double freq);
  void set_rx_freq(uint32_t chan, double freq);

  double get_freq_offset();
  double get_tx_freq();
  double get_rx_freq();

  void set_tx_srate(double srate);
  void set_rx_srate(double srate);

  float get_tx_gain();
  float get_rx_gain();
  srslte_rf_info_t *get_info();

  float get_max_tx_power();
  float set_tx_power(float power);
  float get_rssi();
  bool has_rssi();

  bool is_first_of_burst();

  bool is_init();

  void register_error_handler(srslte_rf_error_handler_t h);

 protected:
   srslte_rf_t rf_device;
   log_filter* log_h;

   const static uint32_t burst_preamble_max_samples = 13824;
   double                burst_preamble_sec; // Start of burst preamble time (off->on RF transition time)
   srslte_timestamp_t    end_of_burst_time;
   bool                  is_start_of_burst;
   uint32_t              burst_preamble_samples;
   double                burst_preamble_time_rounded; // preamble time rounded to sample time
   cf_t*                 zeros;
   double                cur_tx_srate;

   double tx_adv_sec;      // Transmission time advance to compensate for antenna->timestamp delay
   int    tx_adv_nsamples; // Transmision time advance in number of samples

   // Define default values for known radios
   bool                    tx_adv_auto;
   bool                    tx_adv_negative;
   constexpr static double uhd_default_burst_preamble_sec = 600 * 1e-6;
   constexpr static double uhd_default_tx_adv_samples     = 98;
   constexpr static double uhd_default_tx_adv_offset_sec  = 4 * 1e-6;

   constexpr static double blade_default_burst_preamble_sec = 0.0;
   constexpr static double blade_default_tx_adv_samples     = 27;
   constexpr static double blade_default_tx_adv_offset_sec  = 1e-6;

   double tx_freq, rx_freq, freq_offset;

   trace<uint32_t> tr_local_time;
   trace<uint32_t> tr_usrp_time;
   trace<uint32_t> tr_tx_time;
   trace<uint32_t> tr_is_eob;
   bool            trace_enabled;
   uint32_t        tti;
   bool            agc_enabled;

   bool continuous_tx;
   bool is_initialized;
   bool radio_is_streaming;

   uint32_t saved_nof_channels;
   char     saved_args[128];
   char     saved_devname[128];
};

} // namespace srslte

#endif // SRSLTE_RADIO_H