/* * 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/. * */ #ifndef SRSUE_PHCH_RECV_H #define SRSUE_PHCH_RECV_H #include #include #include #include "phy_common.h" #include "prach.h" #include "sf_worker.h" #include "srslte/common/log.h" #include "srslte/common/thread_pool.h" #include "srslte/common/threads.h" #include "srslte/common/tti_sync_cv.h" #include "srslte/interfaces/ue_interfaces.h" #include "srslte/srslte.h" #include "srsue/hdr/phy/scell/async_scell_recv.h" #include namespace srsue { typedef _Complex float cf_t; class sync : public thread, public chest_feedback_itf { public: sync(); ~sync(); void init(radio_interface_phy* radio_, stack_interface_phy_lte* _stack, prach* prach_buffer, srslte::thread_pool* _workers_pool, phy_common* _worker_com, srslte::log* _log_h, srslte::log* _log_phy_lib_h, scell::async_recv_vector* scell_sync_, uint32_t prio, int sync_cpu_affinity = -1); void stop(); void radio_overflow(); // RRC interface for controling the SYNC state phy_interface_rrc_lte::cell_search_ret_t cell_search(phy_interface_rrc_lte::phy_cell_t* cell); bool cell_select(phy_interface_rrc_lte::phy_cell_t* cell); bool cell_is_camping(); // RRC interface for controlling the neighbour cell measurement void meas_reset(); int meas_start(uint32_t earfcn, int pci); int meas_stop(uint32_t earfcn, int pci); // from chest_feedback_itf void in_sync(); void out_of_sync(); void set_cfo(float cfo); void set_time_adv_sec(float time_adv_sec); void get_current_cell(srslte_cell_t *cell, uint32_t *earfcn = NULL); uint32_t get_current_tti(); // From UE configuration void set_agc_enable(bool enable); void set_earfcn(std::vector earfcn); void force_freq(float dl_freq, float ul_freq); // Other functions double set_rx_gain(double gain); int radio_recv_fnc(cf_t *data[SRSLTE_MAX_PORTS], uint32_t nsamples, srslte_timestamp_t *rx_time); private: // Class to run cell search class search { public: typedef enum {CELL_NOT_FOUND, CELL_FOUND, ERROR, TIMEOUT} ret_code; ~search(); void init(cf_t* buffer[SRSLTE_MAX_PORTS], srslte::log* log_h, uint32_t nof_rx_antennas, sync* parent); void reset(); float get_last_cfo(); void set_agc_enable(bool enable); ret_code run(srslte_cell_t *cell); private: sync* p; srslte::log* log_h; cf_t *buffer[SRSLTE_MAX_PORTS]; srslte_ue_cellsearch_t cs; srslte_ue_mib_sync_t ue_mib_sync; int force_N_id_2; }; // Class to synchronize system frame number class sfn_sync { public: typedef enum {IDLE, SFN_FOUND, SFX0_FOUND, SFN_NOFOUND, ERROR} ret_code; ~sfn_sync(); void init(srslte_ue_sync_t* ue_sync, cf_t* buffer[SRSLTE_MAX_PORTS], srslte::log* log_h, uint32_t nof_subframes = SFN_SYNC_NOF_SUBFRAMES); void reset(); bool set_cell(srslte_cell_t cell); ret_code run_subframe(srslte_cell_t *cell, uint32_t *tti_cnt, bool sfidx_only = false); ret_code decode_mib(srslte_cell_t* cell, uint32_t* tti_cnt, cf_t* ext_buffer[SRSLTE_MAX_PORTS], bool sfidx_only = false); private: const static int SFN_SYNC_NOF_SUBFRAMES = 100; uint32_t cnt; uint32_t timeout; srslte::log *log_h; srslte_ue_sync_t *ue_sync; cf_t *buffer[SRSLTE_MAX_PORTS]; srslte_ue_mib_t ue_mib; }; /* TODO: Intra-freq measurements can be improved by capturing 200 ms length signal and run cell search + * measurements offline using sync object and finding multiple cells for each N_id_2 */ std::vector earfcn; void reset(); void radio_error(); void set_ue_sync_opts(srslte_ue_sync_t *q, float cfo); void run_thread(); float get_tx_cfo(); void set_sampling_rate(); bool set_frequency(); bool set_cell(); bool radio_is_overflow; bool radio_overflow_return; bool running; // Objects for internal use search search_p; sfn_sync sfn_p; scell::intra_measure intra_freq_meas; uint32_t current_sflen; int next_offset; // Sample offset triggered by Time aligment commands int next_radio_offset[SRSLTE_MAX_RADIOS]; // Sample offset triggered by SFO compensation // Pointers to other classes stack_interface_phy_lte* stack; srslte::log* log_h; srslte::log* log_phy_lib_h; srslte::thread_pool* workers_pool; radio_interface_phy* radio_h; phy_common* worker_com; prach* prach_buffer; scell::async_recv_vector* scell_sync; srslte::channel_ptr channel_emulator = nullptr; // Object for synchronization of the primary cell srslte_ue_sync_t ue_sync; // Buffer for primary and secondary cell samples cf_t* sf_buffer[SRSLTE_MAX_RADIOS][SRSLTE_MAX_PORTS]; // Sync metrics sync_metrics_t metrics; // in-sync / out-of-sync counters uint32_t out_of_sync_cnt; uint32_t in_sync_cnt; const static uint32_t NOF_OUT_OF_SYNC_SF = 20; const static uint32_t NOF_IN_SYNC_SF = 10; // State machine for SYNC thread class sync_state { public: typedef enum { IDLE = 0, CELL_SEARCH, SFN_SYNC, CAMPING, } state_t; /* Run_state is called by the main thread at the start of each loop. It updates the state * and returns the current state */ state_t run_state() { pthread_mutex_lock(&inside); cur_state = next_state; if (state_setting) { state_setting = false; state_running = true; } pthread_cond_broadcast(&cvar); pthread_mutex_unlock(&inside); return cur_state; } // Called by the main thread at the end of each state to indicate it has finished. void state_exit(bool exit_ok = true) { pthread_mutex_lock(&inside); if (cur_state == SFN_SYNC && exit_ok == true) { next_state = CAMPING; } else { next_state = IDLE; } state_running = false; pthread_cond_broadcast(&cvar); pthread_mutex_unlock(&inside); } void force_sfn_sync() { pthread_mutex_lock(&inside); next_state = SFN_SYNC; pthread_mutex_unlock(&inside); } /* Functions to be called from outside the STM thread to instruct the STM to switch state. * The functions change the state and wait until it has changed it. * * These functions are mutexed and only 1 can be called at a time */ void go_idle() { pthread_mutex_lock(&outside); go_state(IDLE); pthread_mutex_unlock(&outside); } void run_cell_search() { pthread_mutex_lock(&outside); go_state(CELL_SEARCH); wait_state_run(); wait_state_next(); pthread_mutex_unlock(&outside); } void run_sfn_sync() { pthread_mutex_lock(&outside); go_state(SFN_SYNC); wait_state_run(); wait_state_next(); pthread_mutex_unlock(&outside); } /* Helpers below this */ bool is_idle() { return cur_state == IDLE; } bool is_camping() { return cur_state == CAMPING; } const char *to_string() { switch(cur_state) { case IDLE: return "IDLE"; case CELL_SEARCH: return "SEARCH"; case SFN_SYNC: return "SYNC"; case CAMPING: return "CAMPING"; default: return "UNKNOWN"; } } sync_state() { pthread_mutex_init(&inside, NULL); pthread_mutex_init(&outside, NULL); pthread_cond_init(&cvar, NULL); cur_state = IDLE; next_state = IDLE; state_setting = false; state_running = false; } private: void go_state(state_t s) { pthread_mutex_lock(&inside); next_state = s; state_setting = true; while(state_setting) { pthread_cond_wait(&cvar, &inside); } pthread_mutex_unlock(&inside); } /* Waits until there is a call to set_state() and then run_state(). Returns when run_state() returns */ void wait_state_run() { pthread_mutex_lock(&inside); while (state_running) { pthread_cond_wait(&cvar, &inside); } pthread_mutex_unlock(&inside); } void wait_state_next() { pthread_mutex_lock(&inside); while (cur_state != next_state) { pthread_cond_wait(&cvar, &inside); } pthread_mutex_unlock(&inside); } bool state_running, state_setting; state_t cur_state, next_state; pthread_mutex_t inside, outside; pthread_cond_t cvar; }; pthread_mutex_t rrc_mutex; sync_state phy_state; search::ret_code cell_search_ret; // Sampling rate mode (find is 1.96 MHz, camp is the full cell BW) enum { SRATE_NONE=0, SRATE_FIND, SRATE_CAMP } srate_mode; float current_srate; // This is the primary cell srslte_cell_t cell; bool started; float time_adv_sec, next_time_adv_sec; uint32_t tti; bool do_agc; uint32_t tx_worker_cnt; uint32_t nof_workers; float ul_dl_factor; int current_earfcn; uint32_t cellsearch_earfcn_index; float dl_freq; float ul_freq; }; } // namespace srsue #endif // SRSUE_PHCH_RECV_H