MbsfnFrameProcessor Class Reference

Frame processor for MBSFN subframes. More...

#include <MbsfnFrameProcessor.h>

Public Member Functions
	MbsfnFrameProcessor (const libconfig::Config &cfg, srslte::rlc &rlc, Phy &phy, srslte::log_ref log_h, RestHandler &rest)
	Default constructor. More...
virtual	~MbsfnFrameProcessor ()
	Default destructor.
bool	init ()
	Initialize signal- and softbuffers, init all underlying components. More...
int	process (uint32_t tti)
	Process the sample data in the signal buffer. More...
void	set_cell (srslte_cell_t cell)
	Set the parameters for the cell (Nof PRB, etc). More...
cf_t **	get_rx_buffer_and_lock ()
	Get a handle of the signal buffer to store samples for processing in, and lock this processor. More...
uint32_t	rx_buffer_size ()
	Size of the signal buffer.
void	configure_mbsfn (uint8_t area_id, srslte_scs_t subcarrier_spacing)
	Set MBSFN parameters: area ID and subcarrier spacing.
bool	mbsfn_configured ()
	Returns tru if MBSFN params have already been configured.
void	unlock ()
	Unlock the processor. More...
const std::vector< uint8_t >	mch_data () const
	Get the constellation diagram data (I/Q data of the subcarriers after CE)
float	cinr_db ()
	Get the CINR estimate (in dB)

Detailed Description

Frame processor for MBSFN subframes.

Handles the complete processing chain for a CAS subframe: calls FFT and channel estimation, decodes PDSCH and passes received PDUs to RLC.

Definition at line 39 of file MbsfnFrameProcessor.h.

Constructor & Destructor Documentation

MbsfnFrameProcessor()

MbsfnFrameProcessor::MbsfnFrameProcessor ( const libconfig::Config &  cfg, srslte::rlc &  rlc, Phy &  phy, srslte::log_ref  log_h, RestHandler &  rest  )

inline

Default constructor.

Parameters

cfg	Config singleton reference
phy	PHY reference
rlc	RLC reference
log_h	srsLTE log handle for the MCH MAC msg decoder
rest	RESTful API handler reference

Definition at line 50 of file MbsfnFrameProcessor.h.

      : _cfg(cfg)
        , _rlc(rlc)
        , _phy(phy)
        , _rest(rest)
        , mch_mac_msg(20, log_h) {}

Member Function Documentation

get_rx_buffer_and_lock()

cf_t** MbsfnFrameProcessor::get_rx_buffer_and_lock ( )

inline

Get a handle of the signal buffer to store samples for processing in, and lock this processor.

The processor unlocks itself after (failed or successful) frame processing in process(). If process() is not called by the application after calling this method, it must unlock the processor itself by calling unlock()

Definition at line 91 of file MbsfnFrameProcessor.h.

{ _mutex.lock(); return _signal_buffer_rx; }

init()

auto MbsfnFrameProcessor::init

(

)

Initialize signal- and softbuffers, init all underlying components.

Must be called once before the first call to process().

Definition at line 29 of file MbsfnFrameProcessor.cpp.

                                       {
  _signal_buffer_max_samples = 3 * SRSLTE_SF_LEN_PRB(MAX_PRB);
 
  _signal_buffer_rx[0] = srslte_vec_cf_malloc(_signal_buffer_max_samples);
  if (_signal_buffer_rx[0] == nullptr) {
    spdlog::error("Could not allocate regular DL signal buffer\n");
    return false;
  }
 
  if (srslte_ue_dl_init(&_ue_dl, _signal_buffer_rx, MAX_PRB, 1) != 0) {
    spdlog::error("Could not init ue_dl\n");
    return false;;
  }
 
  srslte_softbuffer_rx_init(&_softbuffer, 100);
 
  _ue_dl_cfg.snr_to_cqi_offset = 0;
 
  srslte_chest_dl_cfg_t* chest_cfg = &_ue_dl_cfg.chest_cfg;
  bzero(chest_cfg, sizeof(srslte_chest_dl_cfg_t));
  chest_cfg->filter_coef[0] = 0.1;
  chest_cfg->filter_type = SRSLTE_CHEST_FILTER_TRIANGLE;
  chest_cfg->noise_alg = SRSLTE_NOISE_ALG_EMPTY;
  chest_cfg->rsrp_neighbour       = false;
  chest_cfg->sync_error_enable    = false;
  chest_cfg->estimator_alg = SRSLTE_ESTIMATOR_ALG_INTERPOLATE;
  chest_cfg->cfo_estimate_enable  = false;
 
  _ue_dl_cfg.cfg.pdsch.csi_enable         = true;
  _ue_dl_cfg.cfg.pdsch.max_nof_iterations = 8;
  _ue_dl_cfg.cfg.pdsch.meas_evm_en        = false;
  _ue_dl_cfg.cfg.pdsch.decoder_type       = SRSLTE_MIMO_DECODER_MMSE;
  _ue_dl_cfg.cfg.pdsch.softbuffers.rx[0] = &_softbuffer;
 
  _pmch_cfg.pdsch_cfg.csi_enable         = true;
  _pmch_cfg.pdsch_cfg.max_nof_iterations = 8;
  _pmch_cfg.pdsch_cfg.meas_evm_en        = false;
  _pmch_cfg.pdsch_cfg.decoder_type       = SRSLTE_MIMO_DECODER_MMSE;
 
  _sf_cfg.sf_type = SRSLTE_SF_MBSFN;
  return true;
}

process()

auto MbsfnFrameProcessor::process

(

uint32_t

tti

)

Process the sample data in the signal buffer.

Data must already be present in the buffer obtained through the handle returnd by rx_buffer()

Parameters

tti	TTI of the subframe the data belongs to

Definition at line 82 of file MbsfnFrameProcessor.cpp.

                                                     {
  spdlog::trace("Processing MBSFN TTI {}", tti);
 
  uint32_t sfn = tti / 10;
  uint8_t sf = tti % 10;
 
  unsigned area = 0;
  _sf_cfg.tti = tti;
  _pmch_cfg.area_id = _area_id;
  srslte_mbsfn_cfg_t mbsfn_cfg = _phy.mbsfn_config_for_tti(tti, area);
  _ue_dl_cfg.chest_cfg.mbsfn_area_id = _area_id;
 
  if (sfn%50 == 0) {
    if (mbsfn_cfg.is_mcch) {
      _rest._mcch.errors = 0;
      _rest._mcch.total = 1;
    } else {
      _rest._mch[area].errors = 0;
      _rest._mch[area].total = 1;
    }
  }
 
  if (!mbsfn_cfg.enable) {
    _mutex.unlock();
    return -1;
  }
 
  if (mbsfn_cfg.is_mcch) {
    _rest._mcch.total++;
  } else {
    _rest._mch[area].total++;
  }
 
  if (srslte_ue_dl_decode_fft_estimate(&_ue_dl, &_sf_cfg, &_ue_dl_cfg) < 0) {
    if (mbsfn_cfg.is_mcch) {
      _rest._mcch.errors++;
    } else {
      _rest._mch[area].errors++;
    }
    spdlog::error("Getting PDCCH FFT estimate");
    _mutex.unlock();
    return -1;
  }
 
  srslte_configure_pmch(&_pmch_cfg, &_cell, &mbsfn_cfg);
  srslte_ra_dl_compute_nof_re(&_cell, &_sf_cfg, &_pmch_cfg.pdsch_cfg.grant);
 
  _pmch_cfg.area_id = _area_id;
 
  srslte_softbuffer_rx_reset_cb(&_softbuffer, 1);
 
  srslte_pdsch_res_t pmch_dec = {};
  _pmch_cfg.pdsch_cfg.softbuffers.rx[0] = &_softbuffer;
  pmch_dec.payload = _payload_buffer;
  srslte_softbuffer_rx_reset_tbs(_pmch_cfg.pdsch_cfg.softbuffers.rx[0], _pmch_cfg.pdsch_cfg.grant.tb[0].tbs);
 
  if (srslte_ue_dl_decode_pmch(&_ue_dl, &_sf_cfg, &_pmch_cfg, &pmch_dec) != 0) {
    if (mbsfn_cfg.is_mcch) {
      _rest._mcch.errors++;
    } else {
      _rest._mch[area].errors++;
    }
    spdlog::warn("Error decoding PMCH");
    _mutex.unlock();
    return -1;
  }
 
  spdlog::trace("PMCH: tti: {}, l_crb={}, tbs={}, mcs={}, crc={}, snr={} dB, n_iter={}\n",
      tti,
         _pmch_cfg.pdsch_cfg.grant.nof_prb,
         _pmch_cfg.pdsch_cfg.grant.tb[0].tbs / 8,
         _pmch_cfg.pdsch_cfg.grant.tb[0].mcs_idx,
         pmch_dec.crc ? "OK" : "KO",
         _ue_dl.chest_res.snr_db,
         pmch_dec.avg_iterations_block);
 
  if (mbsfn_cfg.is_mcch) {
    _rest._mcch.SetData(mch_data());
    _rest._mcch.mcs = _pmch_cfg.pdsch_cfg.grant.tb[0].mcs_idx;
    _rest._mcch.ber = _softbuffer.ber;
  } else {
    _rest._mch[area].SetData(mch_data());
    _rest._mch[area].mcs = _pmch_cfg.pdsch_cfg.grant.tb[0].mcs_idx;
    _rest._mch[area].present = true;
    _rest._mch[area].ber = _softbuffer.ber;
  }
 
  if (pmch_dec.crc) {
    mch_mac_msg.init_rx(
        static_cast<uint32_t>(_pmch_cfg.pdsch_cfg.grant.tb[0].tbs) / 8);
    mch_mac_msg.parse_packet(_payload_buffer);
 
    while (mch_mac_msg.next()) {
      if (srslte::mch_lcid::MCH_SCHED_INFO == mch_mac_msg.get()->mch_ce_type()) {
        uint16_t stop = 0;
        uint8_t lcid = 0;
        while (mch_mac_msg.get()->get_next_mch_sched_info(&lcid, &stop)) {
          const std::lock_guard<std::mutex> lock(_sched_stop_mutex);
          spdlog::debug("Scheduling stop for LCID {} in sf {}", lcid, stop);
          _sched_stops[ lcid ] = stop;
        }
      } else if (mch_mac_msg.get()->is_sdu()) {
        uint32_t lcid = mch_mac_msg.get()->get_sdu_lcid();
        spdlog::trace("Processing MAC MCH PDU entered, lcid {}", lcid);
 
        if (lcid >= SRSLTE_N_MCH_LCIDS) {
          spdlog::warn("Radio bearer id must be in [0:%d] - %d", SRSLTE_N_MCH_LCIDS, lcid);
          if (mbsfn_cfg.is_mcch) {
            _rest._mcch.errors++;
          } else {
            _rest._mch[area].errors++;
          }
          _mutex.unlock();
          return -1;
        }
 
        {
          const std::lock_guard<std::mutex> lock(_rlc_mutex);
          _phy._mcs = mbsfn_cfg.mbsfn_mcs;
          _rlc.write_pdu_mch(lcid, mch_mac_msg.get()->get_sdu_ptr(), mch_mac_msg.get()->get_payload_size());
        }
      }
    }
  } else {
    if (mbsfn_cfg.is_mcch) {
      _rest._mcch.errors++;
    } else {
      _rest._mch[area].errors++;
    }
 
    spdlog::warn("PMCH in TTI {} failed with CRC error", tti);
    _mutex.unlock();
    return -1;
  }
 
  if (!mbsfn_cfg.is_mcch) {
    for (uint32_t i = 0; i < _phy.mcch().nof_pmch_info; i++) {
      unsigned fn_in_scheduling_period =  sfn % srslte::enum_to_number(_phy.mcch().pmch_info_list[i].mch_sched_period);
      unsigned sf_idx = fn_in_scheduling_period * 10 + sf - (fn_in_scheduling_period / 4) - 1;
 
      const std::lock_guard<std::mutex> lock(_sched_stop_mutex);
      for (auto itr = _sched_stops.cbegin() ; itr != _sched_stops.cend() ;) {
        if ( sf_idx >= itr->second ) {
          const std::lock_guard<std::mutex> lock(_rlc_mutex);
          spdlog::debug("Stopping LCID {} in tti {} (idx in rf {})", itr->first, tti, sf_idx);
          _rlc.stop_mch(itr->first);
          itr = _sched_stops.erase(itr);
        } else {
          itr = std::next(itr);
        }
      }
    }
  } else {
    _rest._mcch.present = true;
  }
  _mutex.unlock();
  return mbsfn_cfg.is_mcch ? 0 : 1;
}

set_cell()

void MbsfnFrameProcessor::set_cell

(

srslte_cell_t

cell

)

Set the parameters for the cell (Nof PRB, etc).

Parameters

cell	The cell we're camping on

Definition at line 77 of file MbsfnFrameProcessor.cpp.

                                                     {
  _cell = cell;
  srslte_ue_dl_set_cell(&_ue_dl, cell);
}

unlock()

void MbsfnFrameProcessor::unlock ( )

inline

Unlock the processor.

See also

get_rx_buffer_and_lock()

Definition at line 113 of file MbsfnFrameProcessor.h.

{ _mutex.unlock(); }

---

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

• src/MbsfnFrameProcessor.h
• src/MbsfnFrameProcessor.cpp