diff --git a/executables/nr-softmodem-common.h b/executables/nr-softmodem-common.h
index 21dd057a64bdd5c8955774d0424e29bacf075e80..589bc537f52f05214e6bd65c5c4dbb305172c9f4 100644
--- a/executables/nr-softmodem-common.h
+++ b/executables/nr-softmodem-common.h
@@ -104,7 +104,7 @@
#define CONFIG_HLP_SNR "Set average SNR in dB (for --siml1 option)\n"
#define CONFIG_HLP_NOS1 "Disable s1 interface\n"
#define CONFIG_HLP_NOKRNMOD "(noS1 only): Use tun instead of namesh module \n"
-
+#define CONFIG_HLP_AGC "Rx Gain control used for UE"
/*--------------------------------------------------------------------------------------------------------------------------------*/
/* command line parameters for LOG utility */
/* optname helpstr paramflags XXXptr defXXXval type numelt */
diff --git a/executables/nr-ue.c b/executables/nr-ue.c
index e3595f6cf8f70de27979ea31840770640d2dcfd7..266778ebca1b16d4f811946f049db887a84afce9 100644
--- a/executables/nr-ue.c
+++ b/executables/nr-ue.c
@@ -348,10 +348,31 @@ typedef struct {
int rx_offset;
} syncData_t;
+static int nr_ue_adjust_rx_gain(PHY_VARS_NR_UE *UE, openair0_config_t *cfg0, int gain_change)
+{
+ // Increase the RX gain by the value determined by adjust_rxgain
+ cfg0->rx_gain[0] += gain_change;
+
+ // Set new RX gain.
+ int ret_gain = UE->rfdevice.trx_set_gains_func(&UE->rfdevice, cfg0);
+ // APPLY RX gain again if crossed the MAX RX gain threshold
+ if (ret_gain < 0) {
+ gain_change += ret_gain;
+ cfg0->rx_gain[0] += ret_gain;
+ ret_gain = UE->rfdevice.trx_set_gains_func(&UE->rfdevice, cfg0);
+ }
+
+ int applied_rxgain = cfg0->rx_gain[0] - cfg0->rx_gain_offset[0];
+ LOG_I(PHY, "Rxgain adjusted by %d dB, RX gain: %d dB \n", gain_change, applied_rxgain);
+
+ return gain_change;
+}
+
static void UE_synch(void *arg) {
syncData_t *syncD = (syncData_t *)arg;
PHY_VARS_NR_UE *UE = syncD->UE;
UE->is_synchronized = 0;
+ openair0_config_t *cfg0 = &openair0_cfg[UE->rf_map.card];
if (UE->target_Nid_cell != -1) {
LOG_W(NR_PHY, "Starting re-sync detection for target Nid_cell %i\n", UE->target_Nid_cell);
@@ -383,18 +404,30 @@ static void UE_synch(void *arg) {
// rerun with new cell parameters and frequency-offset
// todo: the freq_offset computed on DL shall be scaled before being applied to UL
- nr_rf_card_config_freq(&openair0_cfg[UE->rf_map.card], ul_carrier, dl_carrier, freq_offset);
+ nr_rf_card_config_freq(cfg0, ul_carrier, dl_carrier, freq_offset);
+
+ if (get_nrUE_params()->agc) {
+ nr_ue_adjust_rx_gain(UE, cfg0, UE->adjust_rxgain);
+ }
LOG_I(PHY,
"Got synch: hw_slot_offset %d, carrier off %d Hz, rxgain %f (DL %f Hz, UL %f Hz)\n",
hw_slot_offset,
freq_offset,
- openair0_cfg[UE->rf_map.card].rx_gain[0],
- openair0_cfg[UE->rf_map.card].rx_freq[0],
- openair0_cfg[UE->rf_map.card].tx_freq[0]);
+ cfg0->rx_gain[0] - cfg0->rx_gain_offset[0],
+ cfg0->rx_freq[0],
+ cfg0->tx_freq[0]);
- UE->rfdevice.trx_set_freq_func(&UE->rfdevice, &openair0_cfg[0]);
+ UE->rfdevice.trx_set_freq_func(&UE->rfdevice, cfg0);
UE->is_synchronized = 1;
+ } else {
+ int gain_change = 0;
+ if (get_nrUE_params()->agc)
+ gain_change = nr_ue_adjust_rx_gain(UE, cfg0, INCREASE_IN_RXGAIN);
+ if (gain_change)
+ LOG_I(PHY, "synch retry: Rx gain increased \n");
+ else
+ LOG_E(PHY, "synch Failed: \n");
}
}
diff --git a/executables/nr-uesoftmodem.h b/executables/nr-uesoftmodem.h
index 9d14a8d74bd06ee6709fa880673ec18fad83cadf..779f0049d8b6fe4136855b07646c5b762d7cbfd3 100644
--- a/executables/nr-uesoftmodem.h
+++ b/executables/nr-uesoftmodem.h
@@ -65,6 +65,7 @@
{"num-ues", NULL, 0, .iptr=&(NB_UE_INST), .defuintval=1, TYPE_INT, 0}, \
{"ntn-koffset", CONFIG_HLP_NTN_KOFFSET, 0, .uptr=&(nrUE_params.ntn_koffset), .defuintval=0, TYPE_UINT, 0}, \
{"ntn-ta-common", CONFIG_HLP_NTN_TA_COMMON, 0, .dblptr=&(nrUE_params.ntn_ta_common), .defdblval=0.0, TYPE_DOUBLE, 0}, \
+ {"agc", CONFIG_HLP_AGC, PARAMFLAG_BOOL, .iptr=&(nrUE_params.agc), .defintval=0, TYPE_INT, 0}, \
}
// clang-format on
@@ -87,6 +88,7 @@ typedef struct {
int ldpc_offload_flag;
unsigned int ntn_koffset;
double ntn_ta_common;
+ int agc;
} nrUE_params_t;
extern uint64_t get_nrUE_optmask(void);
extern uint64_t set_nrUE_optmask(uint64_t bitmask);
diff --git a/openair1/PHY/NR_UE_ESTIMATION/nr_estimation.h b/openair1/PHY/NR_UE_ESTIMATION/nr_estimation.h
index fc2e2bba62e6845cf3faef2b89bd3ee60626d85a..390775fee7a9c00366425e646cf14fda9c0e1f52 100644
--- a/openair1/PHY/NR_UE_ESTIMATION/nr_estimation.h
+++ b/openair1/PHY/NR_UE_ESTIMATION/nr_estimation.h
@@ -115,6 +115,12 @@ void nr_ue_measurements(PHY_VARS_NR_UE *ue,
uint32_t pdsch_est_size,
int32_t dl_ch_estimates[][pdsch_est_size]);
+int nr_ue_calculate_ssb_rsrp(const NR_DL_FRAME_PARMS *fp,
+ const UE_nr_rxtx_proc_t *proc,
+ const c16_t rxdataF[][fp->samples_per_slot_wCP],
+ int symbol_offset,
+ int ssb_start_subcarrier);
+
void nr_ue_ssb_rsrp_measurements(PHY_VARS_NR_UE *ue,
uint8_t gNB_index,
const UE_nr_rxtx_proc_t *proc,
@@ -146,9 +152,9 @@ void nr_pdsch_ptrs_processing(PHY_VARS_NR_UE *ue,
float_t get_nr_RSRP(module_id_t Mod_id,uint8_t CC_id,uint8_t gNB_index);
-void nr_sl_psbch_rsrp_measurements(sl_nr_ue_phy_params_t *sl_phy_params,
- NR_DL_FRAME_PARMS *fp,
- c16_t rxdataF[][fp->samples_per_slot_wCP],
- bool use_SSS);
+int nr_sl_psbch_rsrp_measurements(sl_nr_ue_phy_params_t *sl_phy_params,
+ NR_DL_FRAME_PARMS *fp,
+ c16_t rxdataF[][fp->samples_per_slot_wCP],
+ bool use_SSS);
/** @}*/
#endif
diff --git a/openair1/PHY/NR_UE_ESTIMATION/nr_ue_measurements.c b/openair1/PHY/NR_UE_ESTIMATION/nr_ue_measurements.c
index 30ff7a2f9b7b4f05978b8fdffc5990a9c80c573b..3e42680dc8bc6b07be075e5462da9f9be926701d 100644
--- a/openair1/PHY/NR_UE_ESTIMATION/nr_ue_measurements.c
+++ b/openair1/PHY/NR_UE_ESTIMATION/nr_ue_measurements.c
@@ -170,45 +170,33 @@ void nr_ue_measurements(PHY_VARS_NR_UE *ue,
}
}
-// This function implements:
-// - SS reference signal received power (SS-RSRP) as per clause 5.1.1 of 3GPP TS 38.215 version 16.3.0 Release 16
-// - no Layer 3 filtering implemented (no filterCoefficient provided from RRC)
-// Todo:
-// - Layer 3 filtering according to clause 5.5.3.2 of 3GPP TS 38.331 version 16.2.0 Release 16
-// Measurement units:
-// - RSRP: W (dBW)
-// - RX Gain dB
-void nr_ue_ssb_rsrp_measurements(PHY_VARS_NR_UE *ue,
- int ssb_index,
- const UE_nr_rxtx_proc_t *proc,
- c16_t rxdataF[][ue->frame_parms.samples_per_slot_wCP])
+// This function calculates:
+// - SS reference signal received digital power in dB/RE
+int nr_ue_calculate_ssb_rsrp(const NR_DL_FRAME_PARMS *fp,
+ const UE_nr_rxtx_proc_t *proc,
+ const c16_t rxdataF[][fp->samples_per_slot_wCP],
+ int symbol_offset,
+ int ssb_start_subcarrier)
{
int k_start = 56;
int k_end = 183;
- int slot = proc->nr_slot_rx;
- unsigned int ssb_offset = ue->frame_parms.first_carrier_offset + ue->frame_parms.ssb_start_subcarrier;
- int symbol_offset = nr_get_ssb_start_symbol(&ue->frame_parms,ssb_index);
-
- if (ue->frame_parms.half_frame_bit)
- symbol_offset += (ue->frame_parms.slots_per_frame>>1)*ue->frame_parms.symbols_per_slot;
+ unsigned int ssb_offset = fp->first_carrier_offset + ssb_start_subcarrier;
- uint8_t l_sss = (symbol_offset + 2) % ue->frame_parms.symbols_per_slot;
+ uint8_t l_sss = (symbol_offset + 2) % fp->symbols_per_slot;
uint32_t rsrp = 0;
- LOG_D(PHY, "In %s: [UE %d] slot %d l_sss %d ssb_offset %d\n", __FUNCTION__, ue->Mod_id, slot, l_sss, ssb_offset);
+ LOG_D(PHY, "In %s: l_sss %d ssb_offset %d\n", __FUNCTION__, l_sss, ssb_offset);
int nb_re = 0;
- for (int aarx = 0; aarx < ue->frame_parms.nb_antennas_rx; aarx++) {
-
- int16_t *rxF_sss = (int16_t *)&rxdataF[aarx][l_sss*ue->frame_parms.ofdm_symbol_size];
+ for (int aarx = 0; aarx < fp->nb_antennas_rx; aarx++) {
+ int16_t *rxF_sss = (int16_t *)&rxdataF[aarx][l_sss * fp->ofdm_symbol_size];
for(int k = k_start; k < k_end; k++){
-
- int re = (ssb_offset + k) % ue->frame_parms.ofdm_symbol_size;
+ int re = (ssb_offset + k) % fp->ofdm_symbol_size;
#ifdef DEBUG_MEAS_UE
- LOG_I(PHY, "In %s rxF_sss %d %d\n", __FUNCTION__, rxF_sss[re*2], rxF_sss[re*2 + 1]);
+ LOG_I(PHY, "In %s rxF_sss[%d] %d %d\n", __FUNCTION__, re, rxF_sss[re * 2], rxF_sss[re * 2 + 1]);
#endif
rsrp += (((int32_t)rxF_sss[re*2]*rxF_sss[re*2]) + ((int32_t)rxF_sss[re*2 + 1]*rxF_sss[re*2 + 1]));
@@ -218,17 +206,48 @@ void nr_ue_ssb_rsrp_measurements(PHY_VARS_NR_UE *ue,
}
rsrp /= nb_re;
- ue->measurements.ssb_rsrp_dBm[ssb_index] = 10*log10(rsrp) +
- 30 - SQ15_SQUARED_NORM_FACTOR_DB -
- ((int)openair0_cfg[0].rx_gain[0] - (int)openair0_cfg[0].rx_gain_offset[0]) -
- dB_fixed(ue->frame_parms.ofdm_symbol_size);
-
- LOG_D(PHY, "In %s: [UE %d] ssb %d SS-RSRP: %d dBm/RE (%d)\n",
- __FUNCTION__,
- ue->Mod_id,
- ssb_index,
- ue->measurements.ssb_rsrp_dBm[ssb_index],
- rsrp);
+
+ LOG_D(PHY, "In %s: RSRP/nb_re: %d nb_re :%d\n", __FUNCTION__, rsrp, nb_re);
+
+ int rsrp_db_per_re = 10 * log10(rsrp);
+
+ return rsrp_db_per_re;
+}
+
+// This function implements:
+// - SS reference signal received power (SS-RSRP) as per clause 5.1.1 of 3GPP TS 38.215 version 16.3.0 Release 16
+// - no Layer 3 filtering implemented (no filterCoefficient provided from RRC)
+// Todo:
+// - Layer 3 filtering according to clause 5.5.3.2 of 3GPP TS 38.331 version 16.2.0 Release 16
+// Measurement units:
+// - RSRP: W (dBW)
+// - RX Gain dB
+void nr_ue_ssb_rsrp_measurements(PHY_VARS_NR_UE *ue,
+ int ssb_index,
+ const UE_nr_rxtx_proc_t *proc,
+ c16_t rxdataF[][ue->frame_parms.samples_per_slot_wCP])
+{
+ NR_DL_FRAME_PARMS *fp = &ue->frame_parms;
+
+ int symbol_offset = nr_get_ssb_start_symbol(fp, ssb_index);
+
+ if (fp->half_frame_bit)
+ symbol_offset += (fp->slots_per_frame >> 1) * fp->symbols_per_slot;
+
+ int rsrp_db_per_re = nr_ue_calculate_ssb_rsrp(fp, proc, rxdataF, symbol_offset, fp->ssb_start_subcarrier);
+
+ openair0_config_t *cfg0 = &openair0_cfg[0];
+
+ ue->measurements.ssb_rsrp_dBm[ssb_index] = rsrp_db_per_re + 30 - SQ15_SQUARED_NORM_FACTOR_DB
+ - ((int)cfg0->rx_gain[0] - (int)cfg0->rx_gain_offset[0])
+ - dB_fixed(fp->ofdm_symbol_size);
+
+ LOG_D(PHY,
+ "[UE %d] ssb %d SS-RSRP: %d dBm/RE (%d dB/RE)\n",
+ ue->Mod_id,
+ ssb_index,
+ ue->measurements.ssb_rsrp_dBm[ssb_index],
+ rsrp_db_per_re);
}
// This function computes the received noise power
@@ -310,11 +329,17 @@ void nr_ue_rrc_measurements(PHY_VARS_NR_UE *ue,
- ((int)rx_gain - (int)rx_gain_offset));
}
-// PSBCH RSRP calculations according to 38.215 section 5.1.22
-void nr_sl_psbch_rsrp_measurements(sl_nr_ue_phy_params_t *sl_phy_params,
- NR_DL_FRAME_PARMS *fp,
- c16_t rxdataF[][fp->samples_per_slot_wCP],
- bool use_SSS)
+// This function implements:
+// - PSBCH RSRP calculations according to 38.215 section 5.1.22 Release 16
+// - PSBCH DMRS used for calculations
+// - TBD: SSS REs for calculation.
+// Measurement units:
+// - RSRP: W (dBW)
+// returns RXgain to be adjusted based on target rx power (50db) - received digital power in db/RE
+int nr_sl_psbch_rsrp_measurements(sl_nr_ue_phy_params_t *sl_phy_params,
+ NR_DL_FRAME_PARMS *fp,
+ c16_t rxdataF[][fp->samples_per_slot_wCP],
+ bool use_SSS)
{
SL_NR_UE_PSBCH_t *psbch_rx = &sl_phy_params->psbch;
uint8_t numsym = (fp->Ncp) ? SL_NR_NUM_SYMBOLS_SSB_EXT_CP : SL_NR_NUM_SYMBOLS_SSB_NORMAL_CP;
@@ -351,9 +376,14 @@ void nr_sl_psbch_rsrp_measurements(sl_nr_ue_phy_params_t *sl_phy_params,
- ((int)openair0_cfg[0].rx_gain[0] - (int)openair0_cfg[0].rx_gain_offset[0])
- dB_fixed(fp->ofdm_symbol_size);
+ int adjust_rxgain = TARGET_RX_POWER - psbch_rx->rsrp_dB_per_RE;
+
LOG_D(PHY,
- "PSBCH RSRP (DMRS REs): numREs:%d RSRP :%d dB/RE ,RSRP:%d dBm/RE\n",
+ "PSBCH RSRP (DMRS REs): numREs:%d RSRP :%d dB/RE ,RSRP:%d dBm/RE, adjust_rxgain:%d dB\n",
num_re,
psbch_rx->rsrp_dB_per_RE,
- psbch_rx->rsrp_dBm_per_RE);
+ psbch_rx->rsrp_dBm_per_RE,
+ adjust_rxgain);
+
+ return adjust_rxgain;
}
diff --git a/openair1/PHY/NR_UE_TRANSPORT/nr_initial_sync.c b/openair1/PHY/NR_UE_TRANSPORT/nr_initial_sync.c
index 4788c9ed9da87367c3d76f05687a2cb4cc15f7a3..341459832ff6125ae509bbfa007d55d54439cfe2 100644
--- a/openair1/PHY/NR_UE_TRANSPORT/nr_initial_sync.c
+++ b/openair1/PHY/NR_UE_TRANSPORT/nr_initial_sync.c
@@ -291,6 +291,11 @@ void nr_scan_ssb(void *arg)
&ssbInfo->pbchResult,
nr_gold_pbch_ref,
rxdataF); // start pbch detection at first symbol after pss
+ if (ssbInfo->syncRes.cell_detected) {
+ int rsrp_db_per_re = nr_ue_calculate_ssb_rsrp(ssbInfo->fp, ssbInfo->proc, rxdataF, 0, ssbInfo->gscnInfo.ssbFirstSC);
+ ssbInfo->adjust_rxgain = TARGET_RX_POWER - rsrp_db_per_re;
+ LOG_I(PHY, "pbch rx ok. rsrp:%d dB/RE, adjust_rxgain:%d dB\n", rsrp_db_per_re, ssbInfo->adjust_rxgain);
+ }
}
}
}
@@ -370,6 +375,7 @@ nr_initial_sync_t nr_initial_sync(UE_nr_rxtx_proc_t *proc,
fp->ssb_index = res.ssbIndex;
ue->symbol_offset = res.symbolOffset;
ue->common_vars.freq_offset = res.freqOffset;
+ ue->adjust_rxgain = res.adjust_rxgain;
}
// In initial sync, we indicate PBCH to MAC after the scan is complete.
diff --git a/openair1/PHY/NR_UE_TRANSPORT/nr_initial_sync_sl.c b/openair1/PHY/NR_UE_TRANSPORT/nr_initial_sync_sl.c
index 96c2638c9e7683efd19f19f10a123addfb626c0a..1d92bf99aa9a683b7ec17d25d01ca4092d8995b7 100644
--- a/openair1/PHY/NR_UE_TRANSPORT/nr_initial_sync_sl.c
+++ b/openair1/PHY/NR_UE_TRANSPORT/nr_initial_sync_sl.c
@@ -346,7 +346,7 @@ nr_initial_sync_t sl_nr_slss_search(PHY_VARS_NR_UE *UE, UE_nr_rxtx_proc_t *proc,
int ret = -1;
uint16_t rx_slss_id = 65535;
- nr_initial_sync_t result = {true, 0};
+ nr_initial_sync_t result = {false, 0};
#ifdef SL_DEBUG_SEARCH_SLSS
LOG_D(PHY, "SIDELINK SEARCH SLSS: Function:%s\n", __func__);
@@ -512,7 +512,7 @@ nr_initial_sync_t sl_nr_slss_search(PHY_VARS_NR_UE *UE, UE_nr_rxtx_proc_t *proc,
sync_params->DFN,
sync_params->slot_offset);
- nr_sl_psbch_rsrp_measurements(sl_ue, frame_parms, rxdataF, false);
+ UE->adjust_rxgain = nr_sl_psbch_rsrp_measurements(sl_ue, frame_parms, rxdataF, false);
UE->init_sync_frame = sync_params->remaining_frames;
result.rx_offset = sync_params->rx_offset;
diff --git a/openair1/PHY/defs_nr_UE.h b/openair1/PHY/defs_nr_UE.h
index 70b0dc041f1d76be39c43e5125a09ebd38616b96..5178bc63201d2669cb0f7f2b0efd2dcfe04be58c 100644
--- a/openair1/PHY/defs_nr_UE.h
+++ b/openair1/PHY/defs_nr_UE.h
@@ -600,6 +600,9 @@ typedef struct PHY_VARS_NR_UE_s {
notifiedFIFO_t tx_resume_ind_fifo[NR_MAX_SLOTS_PER_FRAME];
+ // Gain change required for automation RX gain change
+ int adjust_rxgain;
+
// Sidelink parameters
sl_nr_sidelink_mode_t sl_mode;
sl_nr_ue_phy_params_t SL_UE_PHY_PARAMS;
@@ -645,6 +648,7 @@ typedef struct {
fapiPbch_t pbchResult;
int pssCorrPeakPower;
int pssCorrAvgPower;
+ int adjust_rxgain;
} nr_ue_ssb_scan_t;
typedef struct nr_phy_data_tx_s {
diff --git a/openair1/PHY/impl_defs_top.h b/openair1/PHY/impl_defs_top.h
index 618a7e6c5803cae5af81da00778a87fdfdad9d47..24f15998737b6e7f8c003572ea95821b9e014962 100644
--- a/openair1/PHY/impl_defs_top.h
+++ b/openair1/PHY/impl_defs_top.h
@@ -181,6 +181,9 @@
#define TARGET_RX_POWER_MAX 65 // Maximum digital power, such that signal does not saturate (value found by simulation)
#define TARGET_RX_POWER_MIN 35 // Minimum digital power, anything below will be discarded (value found by simulation)
+// Increase USRP rx gain in steps of 3dB during Initial search
+#define INCREASE_IN_RXGAIN 3
+
//the min and max gains have to match the calibrated gain table
//#define MAX_RF_GAIN 160
//#define MIN_RF_GAIN 96
diff --git a/openair1/SCHED_NR_UE/phy_procedures_nr_ue_sl.c b/openair1/SCHED_NR_UE/phy_procedures_nr_ue_sl.c
index b4335c748009a283219fe5a07c74da0bba47fafb..dac44e0f565ab0a7802651aab451b102e0daa63f 100644
--- a/openair1/SCHED_NR_UE/phy_procedures_nr_ue_sl.c
+++ b/openair1/SCHED_NR_UE/phy_procedures_nr_ue_sl.c
@@ -223,7 +223,7 @@ int psbch_pscch_processing(PHY_VARS_NR_UE *ue, const UE_nr_rxtx_proc_t *proc, nr
sym = (sym == 0) ? 5 : sym + 1;
}
- nr_sl_psbch_rsrp_measurements(sl_phy_params, fp, rxdataF, false);
+ ue->adjust_rxgain = nr_sl_psbch_rsrp_measurements(sl_phy_params, fp, rxdataF, false);
LOG_D(NR_PHY, " ------ Decode SL-MIB: frame.slot %d.%d ------ \n", frame_rx % 1024, nr_slot_rx);
diff --git a/radio/USRP/usrp_lib.cpp b/radio/USRP/usrp_lib.cpp
index 8cc4a5b2ee3265cf1d5b2b987355c422e90dc51a..71da4da167a13fd02f9c3775210fdb7618a8a08a 100644
--- a/radio/USRP/usrp_lib.cpp
+++ b/radio/USRP/usrp_lib.cpp
@@ -869,7 +869,8 @@ int trx_usrp_set_gains(openair0_device *device,
if (openair0_cfg[0].rx_gain[0]-openair0_cfg[0].rx_gain_offset[0] > gain_range.stop()) {
LOG_E(HW,"RX Gain 0 too high, reduce by %f dB\n",
openair0_cfg[0].rx_gain[0]-openair0_cfg[0].rx_gain_offset[0] - gain_range.stop());
- exit(-1);
+ int gain_diff = gain_range.stop() - (openair0_cfg[0].rx_gain[0] - openair0_cfg[0].rx_gain_offset[0]);
+ return gain_diff;
}
s->usrp->set_rx_gain(openair0_cfg[0].rx_gain[0]-openair0_cfg[0].rx_gain_offset[0]);
@@ -1424,25 +1425,27 @@ extern "C" {
}
for(int i=0; i<((int) s->usrp->get_rx_num_channels()); i++) {
- if (i<openair0_cfg[0].rx_num_channels) {
- s->usrp->set_rx_rate(openair0_cfg[0].sample_rate,i+choffset);
- uhd::tune_request_t rx_tune_req(openair0_cfg[0].rx_freq[i],
- openair0_cfg[0].tune_offset);
+ openair0_config_t *cfg = &openair0_cfg[0];
+ if (i < cfg->rx_num_channels) {
+ s->usrp->set_rx_rate(cfg->sample_rate, i + choffset);
+ uhd::tune_request_t rx_tune_req(cfg->rx_freq[i], cfg->tune_offset);
s->usrp->set_rx_freq(rx_tune_req, i+choffset);
- set_rx_gain_offset(&openair0_cfg[0],i,bw_gain_adjust);
+ set_rx_gain_offset(cfg, i, bw_gain_adjust);
::uhd::gain_range_t gain_range = s->usrp->get_rx_gain_range(i+choffset);
// limit to maximum gain
- double gain=openair0_cfg[0].rx_gain[i]-openair0_cfg[0].rx_gain_offset[i];
+ double gain = cfg->rx_gain[i] - cfg->rx_gain_offset[i];
if ( gain > gain_range.stop()) {
- LOG_E(HW,"RX Gain too high, lower by %f dB\n",
- gain - gain_range.stop());
- gain=gain_range.stop();
+ LOG_E(HW, "RX Gain too high, lower by %f dB\n", gain - gain_range.stop());
+ gain = gain_range.stop();
}
-
s->usrp->set_rx_gain(gain,i+choffset);
- LOG_I(HW,"RX Gain %d %f (%f) => %f (max %f)\n",i,
- openair0_cfg[0].rx_gain[i],openair0_cfg[0].rx_gain_offset[i],
- openair0_cfg[0].rx_gain[i]-openair0_cfg[0].rx_gain_offset[i],gain_range.stop());
+ LOG_I(HW,
+ "RX Gain %d %f (%f) => %f (max %f)\n",
+ i,
+ cfg->rx_gain[i],
+ cfg->rx_gain_offset[i],
+ cfg->rx_gain[i] - cfg->rx_gain_offset[i],
+ gain_range.stop());
}
}