Merge remote-tracking branch 'origin/develop' into feature-131-new-license
Conflicts: openair1/PHY/INIT/lte_init.c openair1/PHY/LTE_TRANSPORT/dci_tools.c openair1/PHY/LTE_TRANSPORT/ulsch_decoding.c openair1/SCHED/phy_procedures_lte_eNb.c openair1/SCHED/phy_procedures_lte_ue.c openair1/SIMULATION/LTE_PHY/dlsim.c openair1/SIMULATION/RF/adc.c openair2/LAYER2/MAC/lte_transport_init.c targets/RT/USER/lte-softmodem.c targets/RT/USER/sched_dlsch.c targets/RT/USER/sched_rx_pdsch.c targets/RT/USER/sched_ulsch.c targets/SIMU/USER/oaisim.c
This commit is contained in:
Cedric Roux
+264
-308
@@ -47,16 +47,21 @@ int first_rbUL ;
|
||||
extern Signal_buffers_t *signal_buffers_g;
|
||||
|
||||
|
||||
double r_re_DL[NUMBER_OF_UE_MAX][2][30720];
|
||||
double r_im_DL[NUMBER_OF_UE_MAX][2][30720];
|
||||
double r_re_UL[NUMBER_OF_eNB_MAX][2][30720];
|
||||
double r_im_UL[NUMBER_OF_eNB_MAX][2][30720];
|
||||
int eNB_output_mask[NUMBER_OF_UE_MAX];
|
||||
int UE_output_mask[NUMBER_OF_eNB_MAX];
|
||||
pthread_mutex_t eNB_output_mutex[NUMBER_OF_UE_MAX];
|
||||
pthread_mutex_t UE_output_mutex[NUMBER_OF_eNB_MAX];
|
||||
|
||||
void do_DL_sig(double **r_re0,double **r_im0,
|
||||
double **r_re,double **r_im,
|
||||
double **s_re,double **s_im,
|
||||
channel_desc_t *eNB2UE[NUMBER_OF_eNB_MAX][NUMBER_OF_UE_MAX][MAX_NUM_CCs],
|
||||
node_desc_t *enb_data[NUMBER_OF_eNB_MAX],
|
||||
node_desc_t *ue_data[NUMBER_OF_UE_MAX],
|
||||
uint16_t next_slot,uint8_t abstraction_flag,LTE_DL_FRAME_PARMS *frame_parms,
|
||||
uint8_t UE_id,
|
||||
int CC_id)
|
||||
void do_DL_sig(channel_desc_t *eNB2UE[NUMBER_OF_eNB_MAX][NUMBER_OF_UE_MAX][MAX_NUM_CCs],
|
||||
node_desc_t *enb_data[NUMBER_OF_eNB_MAX],
|
||||
node_desc_t *ue_data[NUMBER_OF_UE_MAX],
|
||||
uint16_t subframe,uint8_t abstraction_flag,LTE_DL_FRAME_PARMS *frame_parms,
|
||||
uint8_t UE_id,
|
||||
int CC_id)
|
||||
{
|
||||
|
||||
int32_t att_eNB_id=-1;
|
||||
@@ -67,19 +72,37 @@ void do_DL_sig(double **r_re0,double **r_im0,
|
||||
double rx_pwr;
|
||||
int32_t rx_pwr2;
|
||||
uint32_t i,aa;
|
||||
uint32_t slot_offset,slot_offset_meas = 0;
|
||||
uint32_t sf_offset;
|
||||
|
||||
double min_path_loss=-200;
|
||||
uint8_t hold_channel=0;
|
||||
// uint8_t aatx,aarx;
|
||||
uint8_t nb_antennas_rx = eNB2UE[0][0][CC_id]->nb_rx; // number of rx antennas at UE
|
||||
uint8_t nb_antennas_tx = eNB2UE[0][0][CC_id]->nb_tx; // number of tx antennas at eNB
|
||||
|
||||
//LTE_DL_FRAME_PARMS *fp;
|
||||
// int subframe_sched = ((next_slot>>1) == 0) ? 9 : ((next_slot>>1)-1);
|
||||
double s_re0[30720];//PHY_vars_UE_g[UE_id][CC_id]->frame_parms.samples_per_tti];
|
||||
double s_re1[30720];//PHY_vars_UE_g[UE_id][CC_id]->frame_parms.samples_per_tti];
|
||||
double *s_re[2];
|
||||
double s_im0[30720];//PHY_vars_UE_g[UE_id][CC_id]->frame_parms.samples_per_tti];
|
||||
double s_im1[30720];//PHY_vars_UE_g[UE_id][CC_id]->frame_parms.samples_per_tti];
|
||||
double *s_im[2];
|
||||
double r_re00[30720];//PHY_vars_UE_g[UE_id][CC_id]->frame_parms.samples_per_tti];
|
||||
double r_re01[30720];//PHY_vars_UE_g[UE_id][CC_id]->frame_parms.samples_per_tti];
|
||||
double *r_re0[2];
|
||||
double r_im00[30720];//PHY_vars_UE_g[UE_id][CC_id]->frame_parms.samples_per_tti];
|
||||
double r_im01[30720];//PHY_vars_UE_g[UE_id][CC_id]->frame_parms.samples_per_tti];
|
||||
double *r_im0[2];
|
||||
|
||||
s_re[0] = s_re0;
|
||||
s_im[0] = s_im0;
|
||||
s_re[1] = s_re1;
|
||||
s_im[1] = s_im1;
|
||||
|
||||
if (next_slot==0)
|
||||
r_re0[0] = r_re00;
|
||||
r_im0[0] = r_im00;
|
||||
r_re0[1] = r_re01;
|
||||
r_im0[1] = r_im01;
|
||||
|
||||
if (subframe==0)
|
||||
hold_channel = 0;
|
||||
else
|
||||
hold_channel = 1;
|
||||
@@ -101,7 +124,7 @@ void do_DL_sig(double **r_re0,double **r_im0,
|
||||
|
||||
// find out which eNB the UE is attached to
|
||||
for (eNB_id=0; eNB_id<NB_eNB_INST; eNB_id++) {
|
||||
if (find_ue(PHY_vars_UE_g[UE_id][CC_id]->lte_ue_pdcch_vars[0]->crnti,PHY_vars_eNB_g[eNB_id][CC_id])>=0) {
|
||||
if (find_ue(PHY_vars_UE_g[UE_id][CC_id]->pdcch_vars[0]->crnti,PHY_vars_eNB_g[eNB_id][CC_id])>=0) {
|
||||
// UE with UE_id is connected to eNb with eNB_id
|
||||
att_eNB_id=eNB_id;
|
||||
LOG_D(OCM,"A: UE attached to eNB (UE%d->eNB%d)\n",UE_id,eNB_id);
|
||||
@@ -136,7 +159,7 @@ void do_DL_sig(double **r_re0,double **r_im0,
|
||||
//dlsch_abstraction(PHY_vars_UE_g[UE_id]->sinr_dB, rb_alloc, 8);
|
||||
// fill in perfect channel estimates
|
||||
channel_desc_t *desc1 = eNB2UE[att_eNB_id][UE_id][CC_id];
|
||||
int32_t **dl_channel_est = PHY_vars_UE_g[UE_id][CC_id]->lte_ue_common_vars.dl_ch_estimates[0];
|
||||
int32_t **dl_channel_est = PHY_vars_UE_g[UE_id][CC_id]->common_vars.dl_ch_estimates[0];
|
||||
// double scale = pow(10.0,(enb_data[att_eNB_id]->tx_power_dBm + eNB2UE[att_eNB_id][UE_id]->path_loss_dB + (double) PHY_vars_UE_g[UE_id]->rx_total_gain_dB)/20.0);
|
||||
double scale = pow(10.0,(frame_parms->pdsch_config_common.referenceSignalPower+eNB2UE[att_eNB_id][UE_id][CC_id]->path_loss_dB + (double) PHY_vars_UE_g[UE_id][CC_id]->rx_total_gain_dB)/20.0);
|
||||
LOG_D(OCM,"scale =%lf (%d dB)\n",scale,(int) (20*log10(scale)));
|
||||
@@ -157,80 +180,59 @@ void do_DL_sig(double **r_re0,double **r_im0,
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
if(PHY_vars_UE_g[UE_id]->transmission_mode[att_eNB_id]>=5)
|
||||
{
|
||||
lte_ue_measurements(PHY_vars_UE_g[UE_id],
|
||||
((next_slot-1)>>1)*frame_parms->samples_per_tti,
|
||||
1,
|
||||
abstraction_flag);
|
||||
|
||||
PHY_vars_eNB_g[att_eNB_id]->dlsch_eNB[0][0]->pmi_alloc = quantize_subband_pmi(&PHY_vars_UE_g[UE_id]->PHY_measurements,0);
|
||||
// printf("pmi_alloc in channel sim: %d",PHY_vars_eNB_g[att_eNB_id]->dlsch_eNB[0][0]->pmi_alloc);
|
||||
}
|
||||
*/
|
||||
|
||||
// calculate the SNR for the attached eNB (this assumes eNB always uses PMI stored in eNB_UE_stats; to be improved)
|
||||
init_snr(eNB2UE[att_eNB_id][UE_id][CC_id], enb_data[att_eNB_id], ue_data[UE_id], PHY_vars_UE_g[UE_id][CC_id]->sinr_dB, &PHY_vars_UE_g[UE_id][CC_id]->N0,
|
||||
PHY_vars_UE_g[UE_id][CC_id]->transmission_mode[att_eNB_id], PHY_vars_eNB_g[att_eNB_id][CC_id]->eNB_UE_stats[UE_id].DL_pmi_single,
|
||||
PHY_vars_eNB_g[att_eNB_id][CC_id]->mu_mimo_mode[UE_id].dl_pow_off,PHY_vars_eNB_g[att_eNB_id][CC_id]->lte_frame_parms.N_RB_DL);
|
||||
PHY_vars_UE_g[UE_id][CC_id]->transmission_mode[att_eNB_id], PHY_vars_eNB_g[att_eNB_id][CC_id]->UE_stats[UE_id].DL_pmi_single,
|
||||
PHY_vars_eNB_g[att_eNB_id][CC_id]->mu_mimo_mode[UE_id].dl_pow_off,PHY_vars_eNB_g[att_eNB_id][CC_id]->frame_parms.N_RB_DL);
|
||||
|
||||
// calculate sinr here
|
||||
for (eNB_id = 0; eNB_id < NB_eNB_INST; eNB_id++) {
|
||||
if (att_eNB_id != eNB_id) {
|
||||
calculate_sinr(eNB2UE[eNB_id][UE_id][CC_id], enb_data[eNB_id], ue_data[UE_id], PHY_vars_UE_g[UE_id][CC_id]->sinr_dB,PHY_vars_eNB_g[att_eNB_id][CC_id]->lte_frame_parms.N_RB_DL);
|
||||
calculate_sinr(eNB2UE[eNB_id][UE_id][CC_id], enb_data[eNB_id], ue_data[UE_id], PHY_vars_UE_g[UE_id][CC_id]->sinr_dB,PHY_vars_eNB_g[att_eNB_id][CC_id]->frame_parms.N_RB_DL);
|
||||
}
|
||||
}
|
||||
} // hold channel
|
||||
}
|
||||
|
||||
else { //abstraction_flag
|
||||
/*
|
||||
Call do_OFDM_mod from phy_procedures_eNB_TX function
|
||||
*/
|
||||
|
||||
// printf("r_re[0] %p\n",r_re[0]);
|
||||
for (aa=0; aa<nb_antennas_rx; aa++) {
|
||||
memset((void*)r_re[aa],0,(frame_parms->samples_per_tti>>1)*sizeof(double));
|
||||
memset((void*)r_im[aa],0,(frame_parms->samples_per_tti>>1)*sizeof(double));
|
||||
|
||||
pthread_mutex_lock(&eNB_output_mutex[UE_id]);
|
||||
|
||||
if (eNB_output_mask[UE_id] == 0) { // This is the first eNodeB for this UE, clear the buffer
|
||||
|
||||
for (aa=0; aa<nb_antennas_rx; aa++) {
|
||||
memset((void*)r_re_DL[UE_id][aa],0,(frame_parms->samples_per_tti)*sizeof(double));
|
||||
memset((void*)r_im_DL[UE_id][aa],0,(frame_parms->samples_per_tti)*sizeof(double));
|
||||
}
|
||||
}
|
||||
pthread_mutex_unlock(&eNB_output_mutex[UE_id]);
|
||||
|
||||
/*
|
||||
for (i=0;i<16;i++)
|
||||
printf("%f, %X\n",r_re[aa][i],(unsigned long long)r_re[aa][i]);
|
||||
*/
|
||||
for (eNB_id=0; eNB_id<NB_eNB_INST; eNB_id++) {
|
||||
// if (((double)PHY_vars_UE_g[UE_id]->tx_power_dBm +
|
||||
// eNB2UE[eNB_id][UE_id]->path_loss_dB) <= -107.0)
|
||||
// break;
|
||||
|
||||
txdata = PHY_vars_eNB_g[eNB_id][CC_id]->lte_eNB_common_vars.txdata[0];
|
||||
slot_offset = (next_slot)*(frame_parms->samples_per_tti>>1);
|
||||
slot_offset_meas = ((next_slot&1)==0) ? slot_offset : (slot_offset-(frame_parms->samples_per_tti>>1));
|
||||
txdata = PHY_vars_eNB_g[eNB_id][CC_id]->common_vars.txdata[0];
|
||||
sf_offset = subframe*frame_parms->samples_per_tti;
|
||||
tx_pwr = dac_fixed_gain(s_re,
|
||||
s_im,
|
||||
txdata,
|
||||
slot_offset,
|
||||
sf_offset,
|
||||
nb_antennas_tx,
|
||||
frame_parms->samples_per_tti>>1,
|
||||
slot_offset_meas,
|
||||
frame_parms->samples_per_tti,
|
||||
sf_offset,
|
||||
frame_parms->ofdm_symbol_size,
|
||||
14,
|
||||
// enb_data[eNB_id]->tx_power_dBm);
|
||||
frame_parms->pdsch_config_common.referenceSignalPower, // dBm/RE
|
||||
frame_parms->N_RB_DL*12);
|
||||
|
||||
#ifdef DEBUG_SIM
|
||||
LOG_D(OCM,"[SIM][DL] eNB %d (CCid %d): tx_pwr %.1f dBm/RE (target %d dBm/RE), for slot %d (subframe %d)\n",
|
||||
LOG_D(OCM,"[SIM][DL] eNB %d (CCid %d): tx_pwr %.1f dBm/RE (target %d dBm/RE), for subframe %d\n",
|
||||
eNB_id,CC_id,
|
||||
10*log10(tx_pwr),
|
||||
frame_parms->pdsch_config_common.referenceSignalPower,
|
||||
next_slot,
|
||||
next_slot>>1);
|
||||
subframe);
|
||||
|
||||
#endif
|
||||
//eNB2UE[eNB_id][UE_id]->path_loss_dB = 0;
|
||||
multipath_channel(eNB2UE[eNB_id][UE_id][CC_id],s_re,s_im,r_re0,r_im0,
|
||||
frame_parms->samples_per_tti>>1,hold_channel);
|
||||
frame_parms->samples_per_tti,hold_channel);
|
||||
#ifdef DEBUG_SIM
|
||||
rx_pwr = signal_energy_fp2(eNB2UE[eNB_id][UE_id][CC_id]->ch[0],
|
||||
eNB2UE[eNB_id][UE_id][CC_id]->channel_length)*eNB2UE[eNB_id][UE_id][CC_id]->channel_length;
|
||||
@@ -254,15 +256,15 @@ void do_DL_sig(double **r_re0,double **r_im0,
|
||||
#ifdef DEBUG_SIM
|
||||
rx_pwr = signal_energy_fp(r_re0,r_im0,nb_antennas_rx,
|
||||
frame_parms->ofdm_symbol_size,
|
||||
slot_offset_meas)/(12.0*frame_parms->N_RB_DL);
|
||||
LOG_D(OCM,"[SIM][DL] UE %d : rx_pwr %f dBm/RE (%f dBm RSSI)for slot %d (subframe %d)\n",UE_id,
|
||||
sf_offset)/(12.0*frame_parms->N_RB_DL);
|
||||
LOG_D(OCM,"[SIM][DL] UE %d : rx_pwr %f dBm/RE (%f dBm RSSI)for subframe %d\n",UE_id,
|
||||
10*log10(rx_pwr),
|
||||
10*log10(rx_pwr*(double)frame_parms->N_RB_DL*12),next_slot,next_slot>>1);
|
||||
10*log10(rx_pwr*(double)frame_parms->N_RB_DL*12),subframe);
|
||||
LOG_D(OCM,"[SIM][DL] UE %d : rx_pwr (noise) -132 dBm/RE (N0fs = %.1f dBm, N0B = %.1f dBm) for slot %d (subframe %d)\n",
|
||||
UE_id,
|
||||
10*log10(eNB2UE[eNB_id][UE_id][CC_id]->sampling_rate*1e6)-174,
|
||||
10*log10(eNB2UE[eNB_id][UE_id][CC_id]->sampling_rate*1e6*12*frame_parms->N_RB_DL/(double)frame_parms->ofdm_symbol_size)-174,
|
||||
next_slot,next_slot>>1);
|
||||
subframe);
|
||||
#endif
|
||||
|
||||
if (eNB2UE[eNB_id][UE_id][CC_id]->first_run == 1)
|
||||
@@ -271,34 +273,14 @@ void do_DL_sig(double **r_re0,double **r_im0,
|
||||
|
||||
// RF model
|
||||
#ifdef DEBUG_SIM
|
||||
LOG_D(OCM,"[SIM][DL] UE %d (CCid %d): rx_gain %d dB (-ADC %f) for slot %d (subframe %d)\n",UE_id,CC_id,PHY_vars_UE_g[UE_id][CC_id]->rx_total_gain_dB,
|
||||
PHY_vars_UE_g[UE_id][CC_id]->rx_total_gain_dB-66.227,next_slot,next_slot>>1);
|
||||
LOG_D(OCM,"[SIM][DL] UE %d (CCid %d): rx_gain %d dB (-ADC %f) for subframe %d\n",UE_id,CC_id,PHY_vars_UE_g[UE_id][CC_id]->rx_total_gain_dB,
|
||||
PHY_vars_UE_g[UE_id][CC_id]->rx_total_gain_dB-66.227,subframe);
|
||||
#endif
|
||||
/*
|
||||
rf_rx(r_re0,
|
||||
r_im0,
|
||||
NULL,
|
||||
NULL,
|
||||
0,
|
||||
nb_antennas_rx,
|
||||
frame_parms->samples_per_tti>>1,
|
||||
1e3/eNB2UE[eNB_id][UE_id]->BW, // sampling time (ns)
|
||||
0.0, // freq offset (Hz) (-20kHz..20kHz)
|
||||
0.0, // drift (Hz) NOT YET IMPLEMENTED
|
||||
ue_data[UE_id]->rx_noise_level, // noise_figure NOT YET IMPLEMENTED
|
||||
(double)PHY_vars_UE_g[UE_id]->rx_total_gain_dB - 66.227, // rx_gain (dB) (66.227 = 20*log10(pow2(11)) = gain from the adc that will be applied later)
|
||||
200.0, // IP3_dBm (dBm)
|
||||
&eNB2UE[eNB_id][UE_id]->ip, // initial phase
|
||||
30.0e3, // pn_cutoff (kHz)
|
||||
-500.0, // pn_amp (dBc) default: 50
|
||||
0.0, // IQ imbalance (dB),
|
||||
0.0); // IQ phase imbalance (rad)
|
||||
*/
|
||||
|
||||
rf_rx_simple(r_re0,
|
||||
r_im0,
|
||||
nb_antennas_rx,
|
||||
frame_parms->samples_per_tti>>1,
|
||||
frame_parms->samples_per_tti,
|
||||
1e3/eNB2UE[eNB_id][UE_id][CC_id]->sampling_rate, // sampling time (ns)
|
||||
(double)PHY_vars_UE_g[UE_id][CC_id]->rx_total_gain_dB - 66.227); // rx_gain (dB) (66.227 = 20*log10(pow2(11)) = gain from the adc that will be applied later)
|
||||
|
||||
@@ -306,61 +288,74 @@ void do_DL_sig(double **r_re0,double **r_im0,
|
||||
rx_pwr = signal_energy_fp(r_re0,r_im0,
|
||||
nb_antennas_rx,
|
||||
frame_parms->ofdm_symbol_size,
|
||||
slot_offset_meas)/(12.0*frame_parms->N_RB_DL);
|
||||
LOG_D(OCM,"[SIM][DL] UE %d : ADC in (eNB %d) %f dBm/RE for slot %d (subframe %d)\n",
|
||||
sf_offset)/(12.0*frame_parms->N_RB_DL);
|
||||
LOG_D(OCM,"[SIM][DL] UE %d : ADC in (eNB %d) %f dBm/RE for subframe %d\n",
|
||||
UE_id,eNB_id,
|
||||
10*log10(rx_pwr),next_slot,next_slot>>1);
|
||||
10*log10(rx_pwr),subframe);
|
||||
#endif
|
||||
|
||||
for (i=0; i<(frame_parms->samples_per_tti>>1); i++) {
|
||||
|
||||
pthread_mutex_lock(&eNB_output_mutex[UE_id]);
|
||||
for (i=0; i<frame_parms->samples_per_tti; i++) {
|
||||
for (aa=0; aa<nb_antennas_rx; aa++) {
|
||||
r_re[aa][i]+=r_re0[aa][i];
|
||||
r_im[aa][i]+=r_im0[aa][i];
|
||||
r_re_DL[UE_id][aa][i]+=r_re0[aa][i];
|
||||
r_im_DL[UE_id][aa][i]+=r_im0[aa][i];
|
||||
}
|
||||
}
|
||||
eNB_output_mask[UE_id] |= (1<<eNB_id);
|
||||
if (eNB_output_mask[UE_id] == (1<<NB_eNB_INST)-1) {
|
||||
eNB_output_mask[UE_id]=0;
|
||||
|
||||
|
||||
}
|
||||
double *r_re_p[2] = {r_re_DL[eNB_id][0],r_re_DL[eNB_id][1]};
|
||||
double *r_im_p[2] = {r_im_DL[eNB_id][0],r_im_DL[eNB_id][1]};
|
||||
|
||||
#ifdef DEBUG_SIM
|
||||
rx_pwr = signal_energy_fp(r_re,r_im,nb_antennas_rx,frame_parms->ofdm_symbol_size,slot_offset_meas)/(12.0*frame_parms->N_RB_DL);
|
||||
LOG_D(OCM,"[SIM][DL] UE %d : ADC in %f dBm for slot %d (subframe %d)\n",UE_id,10*log10(rx_pwr),next_slot,next_slot>>1);
|
||||
rx_pwr = signal_energy_fp(r_re_p,r_im_p,nb_antennas_rx,frame_parms->ofdm_symbol_size,sf_offset)/(12.0*frame_parms->N_RB_DL);
|
||||
LOG_D(OCM,"[SIM][DL] UE %d : ADC in %f dBm for subframe %d\n",UE_id,10*log10(rx_pwr),subframe);
|
||||
#endif
|
||||
|
||||
rxdata = PHY_vars_UE_g[UE_id][CC_id]->common_vars.rxdata;
|
||||
sf_offset = subframe*frame_parms->samples_per_tti;
|
||||
|
||||
rxdata = PHY_vars_UE_g[UE_id][CC_id]->lte_ue_common_vars.rxdata;
|
||||
slot_offset = (next_slot)*(frame_parms->samples_per_tti>>1);
|
||||
|
||||
adc(r_re,
|
||||
r_im,
|
||||
0,
|
||||
slot_offset,
|
||||
rxdata,
|
||||
nb_antennas_rx,
|
||||
frame_parms->samples_per_tti>>1,
|
||||
12);
|
||||
|
||||
adc(r_re_p,
|
||||
r_im_p,
|
||||
0,
|
||||
sf_offset,
|
||||
rxdata,
|
||||
nb_antennas_rx,
|
||||
frame_parms->samples_per_tti,
|
||||
12);
|
||||
|
||||
#ifdef DEBUG_SIM
|
||||
rx_pwr2 = signal_energy(rxdata[0]+slot_offset,frame_parms->ofdm_symbol_size)/(12.0*frame_parms->N_RB_DL);
|
||||
LOG_D(OCM,"[SIM][DL] UE %d : rx_pwr (ADC out) %f dB/RE (%d) for slot %d (subframe %d), writing to %p\n",UE_id, 10*log10((double)rx_pwr2),rx_pwr2,next_slot,next_slot>>1,rxdata);
|
||||
rx_pwr2 = signal_energy(rxdata[0]+sf_offset,frame_parms->ofdm_symbol_size)/(12.0*frame_parms->N_RB_DL);
|
||||
LOG_D(OCM,"[SIM][DL] UE %d : rx_pwr (ADC out) %f dB/RE (%d) for subframe %d, writing to %p\n",UE_id, 10*log10((double)rx_pwr2),rx_pwr2,subframe,rxdata);
|
||||
#else
|
||||
UNUSED_VARIABLE(rx_pwr2);
|
||||
UNUSED_VARIABLE(tx_pwr);
|
||||
UNUSED_VARIABLE(rx_pwr);
|
||||
UNUSED_VARIABLE(rx_pwr2);
|
||||
UNUSED_VARIABLE(tx_pwr);
|
||||
UNUSED_VARIABLE(rx_pwr);
|
||||
#endif
|
||||
//}// UE_index loop
|
||||
|
||||
} // eNB_output_mask
|
||||
pthread_mutex_unlock(&eNB_output_mutex[UE_id]);
|
||||
} // eNB_id
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
void do_UL_sig(double **r_re0,double **r_im0,double **r_re,double **r_im,double **s_re,double **s_im,channel_desc_t *UE2eNB[NUMBER_OF_UE_MAX][NUMBER_OF_eNB_MAX][MAX_NUM_CCs],
|
||||
node_desc_t *enb_data[NUMBER_OF_eNB_MAX],node_desc_t *ue_data[NUMBER_OF_UE_MAX],uint16_t next_slot,uint8_t abstraction_flag,LTE_DL_FRAME_PARMS *frame_parms, uint32_t frame,uint8_t CC_id)
|
||||
void do_UL_sig(channel_desc_t *UE2eNB[NUMBER_OF_UE_MAX][NUMBER_OF_eNB_MAX][MAX_NUM_CCs],
|
||||
node_desc_t *enb_data[NUMBER_OF_eNB_MAX],node_desc_t *ue_data[NUMBER_OF_UE_MAX],
|
||||
uint16_t subframe,uint8_t abstraction_flag,LTE_DL_FRAME_PARMS *frame_parms,
|
||||
uint32_t frame,int eNB_id,uint8_t CC_id)
|
||||
{
|
||||
|
||||
int32_t **txdata,**rxdata;
|
||||
#ifdef PHY_ABSTRACTION_UL
|
||||
int32_t att_eNB_id=-1;
|
||||
#endif
|
||||
uint8_t eNB_id=0,UE_id=0;
|
||||
uint8_t UE_id=0;
|
||||
|
||||
uint8_t nb_antennas_rx = UE2eNB[0][0][CC_id]->nb_rx; // number of rx antennas at eNB
|
||||
uint8_t nb_antennas_tx = UE2eNB[0][0][CC_id]->nb_tx; // number of tx antennas at UE
|
||||
@@ -368,7 +363,7 @@ void do_UL_sig(double **r_re0,double **r_im0,double **r_re,double **r_im,double
|
||||
double tx_pwr, rx_pwr;
|
||||
int32_t rx_pwr2;
|
||||
uint32_t i,aa;
|
||||
uint32_t slot_offset,slot_offset_meas;
|
||||
uint32_t sf_offset;
|
||||
|
||||
uint8_t hold_channel=0;
|
||||
|
||||
@@ -379,198 +374,175 @@ void do_UL_sig(double **r_re0,double **r_im0,double **r_re,double **r_im,double
|
||||
int ulnbrb2 ;
|
||||
int ulfrrb2 ;
|
||||
uint8_t harq_pid;
|
||||
int subframe = (next_slot>>1);
|
||||
#endif
|
||||
double s_re0[30720];//PHY_vars_UE_g[UE_id][CC_id]->frame_parms.samples_per_tti];
|
||||
double s_re1[30720];//PHY_vars_UE_g[UE_id][CC_id]->frame_parms.samples_per_tti];
|
||||
double *s_re[2];
|
||||
double s_im0[30720];//PHY_vars_UE_g[UE_id][CC_id]->frame_parms.samples_per_tti];
|
||||
double s_im1[30720];//PHY_vars_UE_g[UE_id][CC_id]->frame_parms.samples_per_tti];
|
||||
double *s_im[2];
|
||||
double r_re00[30720];//PHY_vars_UE_g[UE_id][CC_id]->frame_parms.samples_per_tti];
|
||||
double r_re01[30720];//PHY_vars_UE_g[UE_id][CC_id]->frame_parms.samples_per_tti];
|
||||
double *r_re0[2];
|
||||
double r_im00[30720];//PHY_vars_UE_g[UE_id][CC_id]->frame_parms.samples_per_tti];
|
||||
double r_im01[30720];//PHY_vars_UE_g[UE_id][CC_id]->frame_parms.samples_per_tti];
|
||||
double *r_im0[2];
|
||||
|
||||
/*
|
||||
if (next_slot==4)
|
||||
hold_channel = 0;
|
||||
else
|
||||
hold_channel = 1;
|
||||
*/
|
||||
s_re[0] = s_re0;
|
||||
s_im[0] = s_im0;
|
||||
s_re[1] = s_re1;
|
||||
s_im[1] = s_im1;
|
||||
|
||||
r_re0[0] = r_re00;
|
||||
r_im0[0] = r_im00;
|
||||
r_re0[1] = r_re01;
|
||||
r_im0[1] = r_im01;
|
||||
|
||||
if (abstraction_flag!=0) {
|
||||
#ifdef PHY_ABSTRACTION_UL
|
||||
|
||||
for (eNB_id=0; eNB_id<NB_eNB_INST; eNB_id++) {
|
||||
for (UE_id=0; UE_id<NB_UE_INST; UE_id++) {
|
||||
if (!hold_channel) {
|
||||
random_channel(UE2eNB[UE_id][eNB_id][CC_id],abstraction_flag);
|
||||
freq_channel(UE2eNB[UE_id][eNB_id][CC_id], frame_parms->N_RB_UL,frame_parms->N_RB_UL*12+1);
|
||||
|
||||
// REceived power at the eNB
|
||||
rx_pwr = signal_energy_fp2(UE2eNB[UE_id][eNB_id][CC_id]->ch[0],
|
||||
UE2eNB[UE_id][eNB_id][CC_id]->channel_length)*UE2eNB[UE_id][att_eNB_id][CC_id]->channel_length; // calculate the rx power at the eNB
|
||||
}
|
||||
|
||||
// write_output("SINRch.m","SINRch",PHY_vars_eNB_g[att_eNB_id]->sinr_dB_eNB,frame_parms->N_RB_UL*12+1,1,1);
|
||||
if(subframe>1 && subframe <5) {
|
||||
harq_pid = subframe2harq_pid(frame_parms,frame,subframe);
|
||||
ul_nb_rb = PHY_vars_eNB_g[att_eNB_id][CC_id]->ulsch_eNB[(uint8_t)UE_id]->harq_processes[harq_pid]->nb_rb;
|
||||
ul_fr_rb = PHY_vars_eNB_g[att_eNB_id][CC_id]->ulsch_eNB[(uint8_t)UE_id]->harq_processes[harq_pid]->first_rb;
|
||||
}
|
||||
|
||||
if(ul_nb_rb>1 && (ul_fr_rb < 25 && ul_fr_rb > -1)) {
|
||||
number_rb_ul = ul_nb_rb;
|
||||
first_rbUL = ul_fr_rb;
|
||||
init_snr_up(UE2eNB[UE_id][att_eNB_id][CC_id],enb_data[att_eNB_id], ue_data[UE_id],PHY_vars_eNB_g[att_eNB_id][CC_id]->sinr_dB,&PHY_vars_UE_g[att_eNB_id][CC_id]->N0,ul_nb_rb,ul_fr_rb);
|
||||
|
||||
}
|
||||
} //UE_id
|
||||
} //eNB_id
|
||||
for (UE_id=0; UE_id<NB_UE_INST; UE_id++) {
|
||||
if (!hold_channel) {
|
||||
random_channel(UE2eNB[UE_id][eNB_id][CC_id],abstraction_flag);
|
||||
freq_channel(UE2eNB[UE_id][eNB_id][CC_id], frame_parms->N_RB_UL,frame_parms->N_RB_UL*12+1);
|
||||
|
||||
// REceived power at the eNB
|
||||
rx_pwr = signal_energy_fp2(UE2eNB[UE_id][eNB_id][CC_id]->ch[0],
|
||||
UE2eNB[UE_id][eNB_id][CC_id]->channel_length)*UE2eNB[UE_id][att_eNB_id][CC_id]->channel_length; // calculate the rx power at the eNB
|
||||
}
|
||||
|
||||
// write_output("SINRch.m","SINRch",PHY_vars_eNB_g[att_eNB_id]->sinr_dB_eNB,frame_parms->N_RB_UL*12+1,1,1);
|
||||
if(subframe>1 && subframe <5) {
|
||||
harq_pid = subframe2harq_pid(frame_parms,frame,subframe);
|
||||
ul_nb_rb = PHY_vars_eNB_g[att_eNB_id][CC_id]->ulsch_eNB[(uint8_t)UE_id]->harq_processes[harq_pid]->nb_rb;
|
||||
ul_fr_rb = PHY_vars_eNB_g[att_eNB_id][CC_id]->ulsch_eNB[(uint8_t)UE_id]->harq_processes[harq_pid]->first_rb;
|
||||
}
|
||||
|
||||
if(ul_nb_rb>1 && (ul_fr_rb < 25 && ul_fr_rb > -1)) {
|
||||
number_rb_ul = ul_nb_rb;
|
||||
first_rbUL = ul_fr_rb;
|
||||
init_snr_up(UE2eNB[UE_id][att_eNB_id][CC_id],enb_data[att_eNB_id], ue_data[UE_id],PHY_vars_eNB_g[att_eNB_id][CC_id]->sinr_dB,&PHY_vars_UE_g[att_eNB_id][CC_id]->N0,ul_nb_rb,ul_fr_rb);
|
||||
|
||||
}
|
||||
} //UE_id
|
||||
|
||||
#else
|
||||
/* the following functions are not needed */
|
||||
/*
|
||||
if (abstraction_flag!=0) {
|
||||
for (eNB_id=0;eNB_id<NB_eNB_INST;eNB_id++) {
|
||||
for (UE_id=0;UE_id<NB_UE_INST;UE_id++) {
|
||||
random_channel(UE2eNB[UE_id][eNB_id]);
|
||||
freq_channel(UE2eNB[UE_id][eNB_id], frame_parms->N_RB_UL,2);
|
||||
}
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
#endif
|
||||
} else { //without abstraction
|
||||
|
||||
/*
|
||||
for (UE_id=0;UE_id<NB_UE_INST;UE_id++) {
|
||||
do_OFDM_mod(PHY_vars_UE_g[UE_id]->lte_ue_common_vars.txdataF,PHY_vars_UE_g[UE_id]->lte_ue_common_vars.txdata,next_slot,&PHY_vars_UE_g[UE_id]->lte_frame_parms);
|
||||
}
|
||||
*/
|
||||
|
||||
for (eNB_id=0; eNB_id<NB_eNB_INST; eNB_id++) {
|
||||
// Clear RX signal for eNB = eNB_id
|
||||
for (i=0; i<(frame_parms->samples_per_tti>>1); i++) {
|
||||
for (aa=0; aa<nb_antennas_rx; aa++) {
|
||||
r_re[aa][i]=0.0;
|
||||
r_im[aa][i]=0.0;
|
||||
}
|
||||
pthread_mutex_lock(&UE_output_mutex[eNB_id]);
|
||||
// Clear RX signal for eNB = eNB_id
|
||||
for (i=0; i<frame_parms->samples_per_tti; i++) {
|
||||
for (aa=0; aa<nb_antennas_rx; aa++) {
|
||||
r_re_UL[eNB_id][aa][i]=0.0;
|
||||
r_im_UL[eNB_id][aa][i]=0.0;
|
||||
}
|
||||
}
|
||||
pthread_mutex_unlock(&UE_output_mutex[eNB_id]);
|
||||
|
||||
// Compute RX signal for eNB = eNB_id
|
||||
for (UE_id=0; UE_id<NB_UE_INST; UE_id++) {
|
||||
// Compute RX signal for eNB = eNB_id
|
||||
for (UE_id=0; UE_id<NB_UE_INST; UE_id++) {
|
||||
|
||||
txdata = PHY_vars_UE_g[UE_id][CC_id]->common_vars.txdata;
|
||||
sf_offset = subframe*frame_parms->samples_per_tti;
|
||||
|
||||
if (((double)PHY_vars_UE_g[UE_id][CC_id]->tx_power_dBm[subframe] +
|
||||
UE2eNB[UE_id][eNB_id][CC_id]->path_loss_dB) <= -125.0) {
|
||||
// don't simulate a UE that is too weak
|
||||
LOG_D(OCM,"[SIM][UL] UE %d tx_pwr %d dBm (num_RE %d) for subframe %d (sf_offset %d)\n",
|
||||
UE_id,
|
||||
PHY_vars_UE_g[UE_id][CC_id]->tx_power_dBm[subframe],
|
||||
PHY_vars_UE_g[UE_id][CC_id]->tx_total_RE[subframe],
|
||||
subframe,sf_offset);
|
||||
} else {
|
||||
tx_pwr = dac_fixed_gain((double**)s_re,
|
||||
(double**)s_im,
|
||||
txdata,
|
||||
sf_offset,
|
||||
nb_antennas_tx,
|
||||
frame_parms->samples_per_tti,
|
||||
sf_offset,
|
||||
frame_parms->ofdm_symbol_size,
|
||||
14,
|
||||
(double)PHY_vars_UE_g[UE_id][CC_id]->tx_power_dBm[subframe]-10*log10((double)PHY_vars_UE_g[UE_id][CC_id]->tx_total_RE[subframe]),
|
||||
PHY_vars_UE_g[UE_id][CC_id]->tx_total_RE[subframe]); // This make the previous argument the total power
|
||||
LOG_D(OCM,"[SIM][UL] UE %d tx_pwr %f dBm (target %d dBm, num_RE %d) for subframe %d (sf_offset %d)\n",
|
||||
UE_id,
|
||||
10*log10(tx_pwr),
|
||||
PHY_vars_UE_g[UE_id][CC_id]->tx_power_dBm[subframe],
|
||||
PHY_vars_UE_g[UE_id][CC_id]->tx_total_RE[subframe],
|
||||
subframe,sf_offset);
|
||||
|
||||
|
||||
multipath_channel(UE2eNB[UE_id][eNB_id][CC_id],s_re,s_im,r_re0,r_im0,
|
||||
frame_parms->samples_per_tti,hold_channel);
|
||||
|
||||
|
||||
txdata = PHY_vars_UE_g[UE_id][CC_id]->lte_ue_common_vars.txdata;
|
||||
slot_offset = (next_slot)*(frame_parms->samples_per_tti>>1);
|
||||
slot_offset_meas = ((next_slot&1)==0) ? slot_offset : (slot_offset-(frame_parms->samples_per_tti>>1));
|
||||
rx_pwr = signal_energy_fp2(UE2eNB[UE_id][eNB_id][CC_id]->ch[0],
|
||||
UE2eNB[UE_id][eNB_id][CC_id]->channel_length)*UE2eNB[UE_id][eNB_id][CC_id]->channel_length;
|
||||
|
||||
if (((double)PHY_vars_UE_g[UE_id][CC_id]->tx_power_dBm +
|
||||
UE2eNB[UE_id][eNB_id][CC_id]->path_loss_dB) <= -125.0) {
|
||||
LOG_D(OCM,"[SIM][UL] subframe %d Channel UE %d => eNB %d : %f dB (hold %d,length %d, PL %f)\n",subframe,UE_id,eNB_id,10*log10(rx_pwr),
|
||||
hold_channel,UE2eNB[UE_id][eNB_id][CC_id]->channel_length,
|
||||
UE2eNB[UE_id][eNB_id][CC_id]->path_loss_dB);
|
||||
|
||||
// don't simulate a UE that is too weak
|
||||
} else {
|
||||
|
||||
tx_pwr = dac_fixed_gain(s_re,
|
||||
s_im,
|
||||
txdata,
|
||||
slot_offset,
|
||||
nb_antennas_tx,
|
||||
frame_parms->samples_per_tti>>1,
|
||||
slot_offset_meas,
|
||||
frame_parms->ofdm_symbol_size,
|
||||
14,
|
||||
(double)PHY_vars_UE_g[UE_id][CC_id]->tx_power_dBm-10*log10((double)PHY_vars_UE_g[UE_id][CC_id]->tx_total_RE),
|
||||
PHY_vars_UE_g[UE_id][CC_id]->tx_total_RE); // This make the previous argument the total power
|
||||
//ue_data[UE_id]->tx_power_dBm);
|
||||
//#ifdef DEBUG_SIM
|
||||
LOG_D(OCM,"[SIM][UL] UE %d tx_pwr %f dBm (target %d dBm, num_RE %d) for slot %d (subframe %d, slot_offset %d, slot_offset_meas %d)\n",
|
||||
UE_id,
|
||||
10*log10(tx_pwr),
|
||||
PHY_vars_UE_g[UE_id][CC_id]->tx_power_dBm,
|
||||
PHY_vars_UE_g[UE_id][CC_id]->tx_total_RE,
|
||||
next_slot,next_slot>>1,slot_offset,slot_offset_meas);
|
||||
//#endif
|
||||
|
||||
multipath_channel(UE2eNB[UE_id][eNB_id][CC_id],s_re,s_im,r_re0,r_im0,
|
||||
frame_parms->samples_per_tti>>1,hold_channel);
|
||||
|
||||
//#ifdef DEBUG_SIM
|
||||
rx_pwr = signal_energy_fp2(UE2eNB[UE_id][eNB_id][CC_id]->ch[0],
|
||||
UE2eNB[UE_id][eNB_id][CC_id]->channel_length)*UE2eNB[UE_id][eNB_id][CC_id]->channel_length;
|
||||
LOG_D(OCM,"[SIM][UL] slot %d Channel UE %d => eNB %d : %f dB (hold %d,length %d, PL %f)\n",next_slot,UE_id,eNB_id,10*log10(rx_pwr),
|
||||
hold_channel,UE2eNB[UE_id][eNB_id][CC_id]->channel_length,
|
||||
UE2eNB[UE_id][eNB_id][CC_id]->path_loss_dB);
|
||||
//#endif
|
||||
|
||||
//#ifdef DEBUG_SIM
|
||||
rx_pwr = signal_energy_fp(r_re0,r_im0,nb_antennas_rx,frame_parms->samples_per_tti>>1,0);
|
||||
LOG_D(OCM,"[SIM][UL] eNB %d : rx_pwr %f dBm (%f) for slot %d (subframe %d), sptti %d\n",
|
||||
eNB_id,10*log10(rx_pwr),rx_pwr,next_slot,next_slot>>1,frame_parms->samples_per_tti);
|
||||
//#endif
|
||||
|
||||
|
||||
if (UE2eNB[UE_id][eNB_id][CC_id]->first_run == 1)
|
||||
UE2eNB[UE_id][eNB_id][CC_id]->first_run = 0;
|
||||
|
||||
|
||||
|
||||
for (aa=0; aa<nb_antennas_rx; aa++) {
|
||||
for (i=0; i<(frame_parms->samples_per_tti>>1); i++) {
|
||||
r_re[aa][i]+=r_re0[aa][i];
|
||||
r_im[aa][i]+=r_im0[aa][i];
|
||||
}
|
||||
}
|
||||
}
|
||||
} //UE_id
|
||||
|
||||
// RF model
|
||||
/*
|
||||
rf_rx(r_re0,
|
||||
r_im0,
|
||||
NULL,
|
||||
NULL,
|
||||
0,
|
||||
frame_parms->nb_antennas_rx,
|
||||
frame_parms->samples_per_tti>>1,
|
||||
1e3/UE2eNB[UE_id][eNB_id]->BW, // sampling time (ns)
|
||||
0.0, // freq offset (Hz) (-20kHz..20kHz)
|
||||
0.0, // drift (Hz) NOT YET IMPLEMENTED
|
||||
enb_data[eNB_id]->rx_noise_level, // noise_figure NOT YET IMPLEMENTED
|
||||
(double)PHY_vars_eNB_g[eNB_id]->rx_total_gain_eNB_dB - 66.227, // rx_gain (dB) (66.227 = 20*log10(pow2(11)) = gain from the adc that will be applied later)
|
||||
200.0, // IP3_dBm (dBm)
|
||||
&UE2eNB[UE_id][eNB_id]->ip, // initial phase
|
||||
30.0e3, // pn_cutoff (kHz)
|
||||
-500.0, // pn_amp (dBc) default: 50
|
||||
0.0, // IQ imbalance (dB),
|
||||
0.0); // IQ phase imbalance (rad)
|
||||
*/
|
||||
|
||||
rf_rx_simple(r_re,
|
||||
r_im,
|
||||
nb_antennas_rx,
|
||||
frame_parms->samples_per_tti>>1,
|
||||
1e3/UE2eNB[0][eNB_id][CC_id]->sampling_rate, // sampling time (ns)
|
||||
(double)PHY_vars_eNB_g[eNB_id][CC_id]->rx_total_gain_eNB_dB - 66.227); // rx_gain (dB) (66.227 = 20*log10(pow2(11)) = gain from the adc that will be applied later)
|
||||
rx_pwr = signal_energy_fp(r_re0,r_im0,nb_antennas_rx,frame_parms->samples_per_tti,0);
|
||||
LOG_D(OCM,"[SIM][UL] eNB %d : rx_pwr %f dBm (%f) for subframe %d, sptti %d\n",
|
||||
eNB_id,10*log10(rx_pwr),rx_pwr,subframe,frame_parms->samples_per_tti);
|
||||
|
||||
|
||||
if (UE2eNB[UE_id][eNB_id][CC_id]->first_run == 1)
|
||||
UE2eNB[UE_id][eNB_id][CC_id]->first_run = 0;
|
||||
|
||||
|
||||
pthread_mutex_lock(&UE_output_mutex[eNB_id]);
|
||||
for (aa=0; aa<nb_antennas_rx; aa++) {
|
||||
for (i=0; i<frame_parms->samples_per_tti; i++) {
|
||||
r_re_UL[eNB_id][aa][i]+=r_re0[aa][i];
|
||||
r_im_UL[eNB_id][aa][i]+=r_im0[aa][i];
|
||||
}
|
||||
}
|
||||
pthread_mutex_unlock(&UE_output_mutex[eNB_id]);
|
||||
}
|
||||
} //UE_id
|
||||
|
||||
double *r_re_p[2] = {r_re_UL[eNB_id][0],r_re_UL[eNB_id][1]};
|
||||
double *r_im_p[2] = {r_im_UL[eNB_id][0],r_im_UL[eNB_id][1]};
|
||||
|
||||
rf_rx_simple(r_re_p,
|
||||
r_im_p,
|
||||
nb_antennas_rx,
|
||||
frame_parms->samples_per_tti,
|
||||
1e3/UE2eNB[0][eNB_id][CC_id]->sampling_rate, // sampling time (ns)
|
||||
(double)PHY_vars_eNB_g[eNB_id][CC_id]->rx_total_gain_dB - 66.227); // rx_gain (dB) (66.227 = 20*log10(pow2(11)) = gain from the adc that will be applied later)
|
||||
|
||||
#ifdef DEBUG_SIM
|
||||
rx_pwr = signal_energy_fp(r_re,r_im,nb_antennas_rx,frame_parms->samples_per_tti>>1,0)*(double)frame_parms->ofdm_symbol_size/(12.0*frame_parms->N_RB_DL);
|
||||
LOG_D(OCM,"[SIM][UL] rx_pwr (ADC in) %f dB for slot %d (subframe %d)\n",10*log10(rx_pwr),next_slot,next_slot>>1);
|
||||
rx_pwr = signal_energy_fp(r_re_p,r_im_p,nb_antennas_rx,frame_parms->samples_per_tti,0)*(double)frame_parms->ofdm_symbol_size/(12.0*frame_parms->N_RB_DL);
|
||||
LOG_D(OCM,"[SIM][UL] rx_pwr (ADC in) %f dB for subframe %d\n",10*log10(rx_pwr),subframe);
|
||||
#endif
|
||||
|
||||
rxdata = PHY_vars_eNB_g[eNB_id][CC_id]->common_vars.rxdata[0];
|
||||
sf_offset = subframe*frame_parms->samples_per_tti;
|
||||
|
||||
rxdata = PHY_vars_eNB_g[eNB_id][CC_id]->lte_eNB_common_vars.rxdata[0];
|
||||
slot_offset = (next_slot)*(frame_parms->samples_per_tti>>1);
|
||||
|
||||
adc(r_re,
|
||||
r_im,
|
||||
0,
|
||||
slot_offset,
|
||||
rxdata,
|
||||
nb_antennas_rx,
|
||||
frame_parms->samples_per_tti>>1,
|
||||
12);
|
||||
|
||||
|
||||
adc(r_re_p,
|
||||
r_im_p,
|
||||
0,
|
||||
sf_offset,
|
||||
rxdata,
|
||||
nb_antennas_rx,
|
||||
frame_parms->samples_per_tti,
|
||||
12);
|
||||
|
||||
#ifdef DEBUG_SIM
|
||||
rx_pwr2 = signal_energy(rxdata[0]+slot_offset,frame_parms->samples_per_tti>>1)*(double)frame_parms->ofdm_symbol_size/(12.0*frame_parms->N_RB_DL);
|
||||
LOG_D(OCM,"[SIM][UL] eNB %d rx_pwr (ADC out) %f dB (%d) for slot %d (subframe %d)\n",eNB_id,10*log10((double)rx_pwr2),rx_pwr2,next_slot,next_slot>>1);
|
||||
rx_pwr2 = signal_energy(rxdata[0]+sf_offset,frame_parms->samples_per_tti)*(double)frame_parms->ofdm_symbol_size/(12.0*frame_parms->N_RB_DL);
|
||||
LOG_D(OCM,"[SIM][UL] eNB %d rx_pwr (ADC out) %f dB (%d) for subframe %d\n",eNB_id,10*log10((double)rx_pwr2),rx_pwr2,subframe);
|
||||
#else
|
||||
UNUSED_VARIABLE(tx_pwr);
|
||||
UNUSED_VARIABLE(rx_pwr);
|
||||
UNUSED_VARIABLE(rx_pwr2);
|
||||
UNUSED_VARIABLE(tx_pwr);
|
||||
UNUSED_VARIABLE(rx_pwr);
|
||||
UNUSED_VARIABLE(rx_pwr2);
|
||||
#endif
|
||||
|
||||
} // eNB_id
|
||||
|
||||
} // abstraction_flag==0
|
||||
|
||||
}
|
||||
@@ -581,29 +553,13 @@ void init_channel_vars(LTE_DL_FRAME_PARMS *frame_parms, double ***s_re,double **
|
||||
|
||||
int i;
|
||||
|
||||
*s_re = malloc(2*sizeof(double*));
|
||||
*s_im = malloc(2*sizeof(double*));
|
||||
*r_re = malloc(2*sizeof(double*));
|
||||
*r_im = malloc(2*sizeof(double*));
|
||||
*r_re0 = malloc(2*sizeof(double*));
|
||||
*r_im0 = malloc(2*sizeof(double*));
|
||||
memset(eNB_output_mask,0,sizeof(int)*NUMBER_OF_UE_MAX);
|
||||
for (i=0;i<NB_UE_INST;i++)
|
||||
pthread_mutex_init(&eNB_output_mutex[i],NULL);
|
||||
|
||||
memset(UE_output_mask,0,sizeof(int)*NUMBER_OF_eNB_MAX);
|
||||
for (i=0;i<NB_eNB_INST;i++)
|
||||
pthread_mutex_init(&UE_output_mutex[i],NULL);
|
||||
|
||||
for (i=0; i<2; i++) {
|
||||
|
||||
(*s_re)[i] = malloc(FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
|
||||
bzero((*s_re)[i],FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
|
||||
(*s_im)[i] = malloc(FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
|
||||
bzero((*s_im)[i],FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
|
||||
(*r_re)[i] = malloc(FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
|
||||
bzero((*r_re)[i],FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
|
||||
(*r_im)[i] = malloc(FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
|
||||
bzero((*r_im)[i],FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
|
||||
(*r_re0)[i] = malloc(FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
|
||||
bzero((*r_re0)[i],FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
|
||||
(*r_im0)[i] = malloc(FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
|
||||
bzero((*r_im0)[i],FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -20,7 +20,6 @@
|
||||
PHY_VARS_eNB* init_lte_eNB(LTE_DL_FRAME_PARMS *frame_parms,
|
||||
uint8_t eNB_id,
|
||||
uint8_t Nid_cell,
|
||||
uint8_t cooperation_flag,
|
||||
uint8_t abstraction_flag)
|
||||
{
|
||||
|
||||
@@ -28,34 +27,36 @@ PHY_VARS_eNB* init_lte_eNB(LTE_DL_FRAME_PARMS *frame_parms,
|
||||
PHY_VARS_eNB* PHY_vars_eNB = malloc(sizeof(PHY_VARS_eNB));
|
||||
memset(PHY_vars_eNB,0,sizeof(PHY_VARS_eNB));
|
||||
PHY_vars_eNB->Mod_id=eNB_id;
|
||||
PHY_vars_eNB->cooperation_flag=cooperation_flag;
|
||||
memcpy(&(PHY_vars_eNB->lte_frame_parms), frame_parms, sizeof(LTE_DL_FRAME_PARMS));
|
||||
PHY_vars_eNB->lte_frame_parms.Nid_cell = ((Nid_cell/3)*3)+((eNB_id+Nid_cell)%3);
|
||||
PHY_vars_eNB->lte_frame_parms.nushift = PHY_vars_eNB->lte_frame_parms.Nid_cell%6;
|
||||
phy_init_lte_eNB(PHY_vars_eNB,0,cooperation_flag,abstraction_flag);
|
||||
PHY_vars_eNB->cooperation_flag=0;//cooperation_flag;
|
||||
memcpy(&(PHY_vars_eNB->frame_parms), frame_parms, sizeof(LTE_DL_FRAME_PARMS));
|
||||
PHY_vars_eNB->frame_parms.Nid_cell = ((Nid_cell/3)*3)+((eNB_id+Nid_cell)%3);
|
||||
PHY_vars_eNB->frame_parms.nushift = PHY_vars_eNB->frame_parms.Nid_cell%6;
|
||||
phy_init_lte_eNB(PHY_vars_eNB,0,abstraction_flag);
|
||||
|
||||
LOG_I(PHY,"init eNB: Nid_cell %d\n", frame_parms->Nid_cell);
|
||||
LOG_I(PHY,"init eNB: frame_type %d,tdd_config %d\n", frame_parms->frame_type,frame_parms->tdd_config);
|
||||
LOG_I(PHY,"init eNB: number of ue max %d number of enb max %d number of harq pid max %d\n",
|
||||
NUMBER_OF_UE_MAX, NUMBER_OF_eNB_MAX, NUMBER_OF_HARQ_PID_MAX);
|
||||
LOG_I(PHY,"init eNB: N_RB_DL %d\n", frame_parms->N_RB_DL);
|
||||
LOG_I(PHY,"init eNB: prach_config_index %d\n", frame_parms->prach_config_common.prach_ConfigInfo.prach_ConfigIndex);
|
||||
|
||||
|
||||
for (i=0; i<NUMBER_OF_UE_MAX; i++) {
|
||||
for (j=0; j<2; j++) {
|
||||
PHY_vars_eNB->dlsch_eNB[i][j] = new_eNB_dlsch(1,8,NSOFT,frame_parms->N_RB_DL,abstraction_flag);
|
||||
PHY_vars_eNB->dlsch[i][j] = new_eNB_dlsch(1,8,NSOFT,frame_parms->N_RB_DL,abstraction_flag);
|
||||
|
||||
if (!PHY_vars_eNB->dlsch_eNB[i][j]) {
|
||||
if (!PHY_vars_eNB->dlsch[i][j]) {
|
||||
LOG_E(PHY,"Can't get eNB dlsch structures for UE %d \n", i);
|
||||
exit(-1);
|
||||
} else {
|
||||
LOG_D(PHY,"dlsch_eNB[%d][%d] => %p\n",i,j,PHY_vars_eNB->dlsch_eNB[i][j]);
|
||||
PHY_vars_eNB->dlsch_eNB[i][j]->rnti=0;
|
||||
LOG_D(PHY,"dlsch[%d][%d] => %p\n",i,j,PHY_vars_eNB->dlsch[i][j]);
|
||||
PHY_vars_eNB->dlsch[i][j]->rnti=0;
|
||||
}
|
||||
}
|
||||
|
||||
PHY_vars_eNB->ulsch_eNB[1+i] = new_eNB_ulsch(MAX_TURBO_ITERATIONS,frame_parms->N_RB_UL, abstraction_flag);
|
||||
PHY_vars_eNB->ulsch[1+i] = new_eNB_ulsch(MAX_TURBO_ITERATIONS,frame_parms->N_RB_UL, abstraction_flag);
|
||||
|
||||
if (!PHY_vars_eNB->ulsch_eNB[1+i]) {
|
||||
if (!PHY_vars_eNB->ulsch[1+i]) {
|
||||
LOG_E(PHY,"Can't get eNB ulsch structures\n");
|
||||
exit(-1);
|
||||
}
|
||||
@@ -64,45 +65,45 @@ PHY_VARS_eNB* init_lte_eNB(LTE_DL_FRAME_PARMS *frame_parms,
|
||||
// this will be overwritten with the real transmission mode by the RRC once the UE is connected
|
||||
PHY_vars_eNB->transmission_mode[i] = frame_parms->nb_antennas_tx_eNB==1 ? 1 : 2;
|
||||
#ifdef LOCALIZATION
|
||||
PHY_vars_eNB->ulsch_eNB[1+i]->aggregation_period_ms = 5000; // 5000 milliseconds // could be given as an argument (TBD))
|
||||
PHY_vars_eNB->ulsch[1+i]->aggregation_period_ms = 5000; // 5000 milliseconds // could be given as an argument (TBD))
|
||||
struct timeval ts;
|
||||
gettimeofday(&ts, NULL);
|
||||
PHY_vars_eNB->ulsch_eNB[1+i]->reference_timestamp_ms = ts.tv_sec * 1000 + ts.tv_usec / 1000;
|
||||
PHY_vars_eNB->ulsch[1+i]->reference_timestamp_ms = ts.tv_sec * 1000 + ts.tv_usec / 1000;
|
||||
int j;
|
||||
|
||||
for (j=0; j<10; j++) {
|
||||
initialize(&PHY_vars_eNB->ulsch_eNB[1+i]->loc_rss_list[j]);
|
||||
initialize(&PHY_vars_eNB->ulsch_eNB[1+i]->loc_rssi_list[j]);
|
||||
initialize(&PHY_vars_eNB->ulsch_eNB[1+i]->loc_subcarrier_rss_list[j]);
|
||||
initialize(&PHY_vars_eNB->ulsch_eNB[1+i]->loc_timing_advance_list[j]);
|
||||
initialize(&PHY_vars_eNB->ulsch_eNB[1+i]->loc_timing_update_list[j]);
|
||||
initialize(&PHY_vars_eNB->ulsch[1+i]->loc_rss_list[j]);
|
||||
initialize(&PHY_vars_eNB->ulsch[1+i]->loc_rssi_list[j]);
|
||||
initialize(&PHY_vars_eNB->ulsch[1+i]->loc_subcarrier_rss_list[j]);
|
||||
initialize(&PHY_vars_eNB->ulsch[1+i]->loc_timing_advance_list[j]);
|
||||
initialize(&PHY_vars_eNB->ulsch[1+i]->loc_timing_update_list[j]);
|
||||
}
|
||||
|
||||
initialize(&PHY_vars_eNB->ulsch_eNB[1+i]->tot_loc_rss_list);
|
||||
initialize(&PHY_vars_eNB->ulsch_eNB[1+i]->tot_loc_rssi_list);
|
||||
initialize(&PHY_vars_eNB->ulsch_eNB[1+i]->tot_loc_subcarrier_rss_list);
|
||||
initialize(&PHY_vars_eNB->ulsch_eNB[1+i]->tot_loc_timing_advance_list);
|
||||
initialize(&PHY_vars_eNB->ulsch_eNB[1+i]->tot_loc_timing_update_list);
|
||||
initialize(&PHY_vars_eNB->ulsch[1+i]->tot_loc_rss_list);
|
||||
initialize(&PHY_vars_eNB->ulsch[1+i]->tot_loc_rssi_list);
|
||||
initialize(&PHY_vars_eNB->ulsch[1+i]->tot_loc_subcarrier_rss_list);
|
||||
initialize(&PHY_vars_eNB->ulsch[1+i]->tot_loc_timing_advance_list);
|
||||
initialize(&PHY_vars_eNB->ulsch[1+i]->tot_loc_timing_update_list);
|
||||
#endif
|
||||
}
|
||||
|
||||
// ULSCH for RA
|
||||
PHY_vars_eNB->ulsch_eNB[0] = new_eNB_ulsch(MAX_TURBO_ITERATIONS, frame_parms->N_RB_UL, abstraction_flag);
|
||||
PHY_vars_eNB->ulsch[0] = new_eNB_ulsch(MAX_TURBO_ITERATIONS, frame_parms->N_RB_UL, abstraction_flag);
|
||||
|
||||
if (!PHY_vars_eNB->ulsch_eNB[0]) {
|
||||
if (!PHY_vars_eNB->ulsch[0]) {
|
||||
LOG_E(PHY,"Can't get eNB ulsch structures\n");
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
PHY_vars_eNB->dlsch_eNB_SI = new_eNB_dlsch(1,8,NSOFT,frame_parms->N_RB_DL, abstraction_flag);
|
||||
LOG_D(PHY,"eNB %d : SI %p\n",eNB_id,PHY_vars_eNB->dlsch_eNB_SI);
|
||||
PHY_vars_eNB->dlsch_eNB_ra = new_eNB_dlsch(1,8,NSOFT,frame_parms->N_RB_DL, abstraction_flag);
|
||||
LOG_D(PHY,"eNB %d : RA %p\n",eNB_id,PHY_vars_eNB->dlsch_eNB_ra);
|
||||
PHY_vars_eNB->dlsch_eNB_MCH = new_eNB_dlsch(1,8,NSOFT,frame_parms->N_RB_DL, 0);
|
||||
LOG_D(PHY,"eNB %d : MCH %p\n",eNB_id,PHY_vars_eNB->dlsch_eNB_MCH);
|
||||
PHY_vars_eNB->dlsch_SI = new_eNB_dlsch(1,8,NSOFT,frame_parms->N_RB_DL, abstraction_flag);
|
||||
LOG_D(PHY,"eNB %d : SI %p\n",eNB_id,PHY_vars_eNB->dlsch_SI);
|
||||
PHY_vars_eNB->dlsch_ra = new_eNB_dlsch(1,8,NSOFT,frame_parms->N_RB_DL, abstraction_flag);
|
||||
LOG_D(PHY,"eNB %d : RA %p\n",eNB_id,PHY_vars_eNB->dlsch_ra);
|
||||
PHY_vars_eNB->dlsch_MCH = new_eNB_dlsch(1,8,NSOFT,frame_parms->N_RB_DL, 0);
|
||||
LOG_D(PHY,"eNB %d : MCH %p\n",eNB_id,PHY_vars_eNB->dlsch_MCH);
|
||||
|
||||
|
||||
PHY_vars_eNB->rx_total_gain_eNB_dB=130;
|
||||
PHY_vars_eNB->rx_total_gain_dB=130;
|
||||
|
||||
for(i=0; i<NUMBER_OF_UE_MAX; i++)
|
||||
PHY_vars_eNB->mu_mimo_mode[i].dl_pow_off = 2;
|
||||
@@ -115,7 +116,7 @@ PHY_VARS_eNB* init_lte_eNB(LTE_DL_FRAME_PARMS *frame_parms,
|
||||
|
||||
PHY_vars_eNB->check_for_SUMIMO_transmissions = 0;
|
||||
|
||||
PHY_vars_eNB->lte_frame_parms.pucch_config_common.deltaPUCCH_Shift = 1;
|
||||
PHY_vars_eNB->frame_parms.pucch_config_common.deltaPUCCH_Shift = 1;
|
||||
|
||||
return (PHY_vars_eNB);
|
||||
}
|
||||
@@ -130,38 +131,38 @@ PHY_VARS_UE* init_lte_UE(LTE_DL_FRAME_PARMS *frame_parms,
|
||||
PHY_VARS_UE* PHY_vars_UE = malloc(sizeof(PHY_VARS_UE));
|
||||
memset(PHY_vars_UE,0,sizeof(PHY_VARS_UE));
|
||||
PHY_vars_UE->Mod_id=UE_id;
|
||||
memcpy(&(PHY_vars_UE->lte_frame_parms), frame_parms, sizeof(LTE_DL_FRAME_PARMS));
|
||||
memcpy(&(PHY_vars_UE->frame_parms), frame_parms, sizeof(LTE_DL_FRAME_PARMS));
|
||||
phy_init_lte_ue(PHY_vars_UE,1,abstraction_flag);
|
||||
|
||||
for (i=0; i<NUMBER_OF_CONNECTED_eNB_MAX; i++) {
|
||||
for (j=0; j<2; j++) {
|
||||
PHY_vars_UE->dlsch_ue[i][j] = new_ue_dlsch(1,NUMBER_OF_HARQ_PID_MAX,NSOFT,MAX_TURBO_ITERATIONS,frame_parms->N_RB_DL, abstraction_flag);
|
||||
PHY_vars_UE->dlsch[i][j] = new_ue_dlsch(1,NUMBER_OF_HARQ_PID_MAX,NSOFT,MAX_TURBO_ITERATIONS,frame_parms->N_RB_DL, abstraction_flag);
|
||||
|
||||
if (!PHY_vars_UE->dlsch_ue[i][j]) {
|
||||
if (!PHY_vars_UE->dlsch[i][j]) {
|
||||
LOG_E(PHY,"Can't get ue dlsch structures\n");
|
||||
exit(-1);
|
||||
} else
|
||||
LOG_D(PHY,"dlsch_ue[%d][%d] => %p\n",UE_id,i,PHY_vars_UE->dlsch_ue[i][j]);
|
||||
LOG_D(PHY,"dlsch[%d][%d] => %p\n",UE_id,i,PHY_vars_UE->dlsch[i][j]);
|
||||
}
|
||||
|
||||
|
||||
|
||||
PHY_vars_UE->ulsch_ue[i] = new_ue_ulsch(frame_parms->N_RB_UL, abstraction_flag);
|
||||
PHY_vars_UE->ulsch[i] = new_ue_ulsch(frame_parms->N_RB_UL, abstraction_flag);
|
||||
|
||||
if (!PHY_vars_UE->ulsch_ue[i]) {
|
||||
if (!PHY_vars_UE->ulsch[i]) {
|
||||
LOG_E(PHY,"Can't get ue ulsch structures\n");
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
PHY_vars_UE->dlsch_ue_SI[i] = new_ue_dlsch(1,1,NSOFT,MAX_TURBO_ITERATIONS,frame_parms->N_RB_DL, abstraction_flag);
|
||||
PHY_vars_UE->dlsch_ue_ra[i] = new_ue_dlsch(1,1,NSOFT,MAX_TURBO_ITERATIONS,frame_parms->N_RB_DL, abstraction_flag);
|
||||
PHY_vars_UE->dlsch_SI[i] = new_ue_dlsch(1,1,NSOFT,MAX_TURBO_ITERATIONS,frame_parms->N_RB_DL, abstraction_flag);
|
||||
PHY_vars_UE->dlsch_ra[i] = new_ue_dlsch(1,1,NSOFT,MAX_TURBO_ITERATIONS,frame_parms->N_RB_DL, abstraction_flag);
|
||||
|
||||
PHY_vars_UE->transmission_mode[i] = frame_parms->nb_antennas_tx_eNB==1 ? 1 : 2;
|
||||
}
|
||||
|
||||
PHY_vars_UE->lte_frame_parms.pucch_config_common.deltaPUCCH_Shift = 1;
|
||||
PHY_vars_UE->frame_parms.pucch_config_common.deltaPUCCH_Shift = 1;
|
||||
|
||||
PHY_vars_UE->dlsch_ue_MCH[0] = new_ue_dlsch(1,NUMBER_OF_HARQ_PID_MAX,NSOFT,MAX_TURBO_ITERATIONS_MBSFN,frame_parms->N_RB_DL,0);
|
||||
PHY_vars_UE->dlsch_MCH[0] = new_ue_dlsch(1,NUMBER_OF_HARQ_PID_MAX,NSOFT,MAX_TURBO_ITERATIONS_MBSFN,frame_parms->N_RB_DL,0);
|
||||
|
||||
return (PHY_vars_UE);
|
||||
}
|
||||
@@ -249,7 +250,7 @@ void init_lte_vars(LTE_DL_FRAME_PARMS *frame_parms[MAX_NUM_CCs],
|
||||
PHY_vars_eNB_g[eNB_id] = (PHY_VARS_eNB**) malloc(MAX_NUM_CCs*sizeof(PHY_VARS_eNB*));
|
||||
|
||||
for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
|
||||
PHY_vars_eNB_g[eNB_id][CC_id] = init_lte_eNB(frame_parms[CC_id],eNB_id,Nid_cell,cooperation_flag,abstraction_flag);
|
||||
PHY_vars_eNB_g[eNB_id][CC_id] = init_lte_eNB(frame_parms[CC_id],eNB_id,Nid_cell,abstraction_flag);
|
||||
PHY_vars_eNB_g[eNB_id][CC_id]->Mod_id=eNB_id;
|
||||
PHY_vars_eNB_g[eNB_id][CC_id]->CC_id=CC_id;
|
||||
}
|
||||
|
||||
@@ -4,7 +4,6 @@
|
||||
PHY_VARS_eNB* init_lte_eNB(LTE_DL_FRAME_PARMS *frame_parms,
|
||||
uint8_t eNB_id,
|
||||
uint8_t Nid_cell,
|
||||
uint8_t cooperation_flag,
|
||||
uint8_t abstraction_flag);
|
||||
|
||||
PHY_VARS_UE* init_lte_UE(LTE_DL_FRAME_PARMS *frame_parms,
|
||||
|
||||
+337
-416
File diff suppressed because it is too large
Load Diff
@@ -21,11 +21,13 @@ eNB_MAC_INST* get_eNB_mac_inst(module_id_t module_idP);
|
||||
OAI_Emulation* get_OAI_emulation(void);
|
||||
void init_channel_vars(LTE_DL_FRAME_PARMS *frame_parms, double ***s_re,double ***s_im,double ***r_re,double ***r_im,double ***r_re0,double ***r_im0);
|
||||
|
||||
void do_UL_sig(double **r_re0,double **r_im0,double **r_re,double **r_im,double **s_re,double **s_im,channel_desc_t *UE2eNB[NUMBER_OF_UE_MAX][NUMBER_OF_eNB_MAX][MAX_NUM_CCs],
|
||||
node_desc_t *enb_data[NUMBER_OF_eNB_MAX],node_desc_t *ue_data[NUMBER_OF_UE_MAX],uint16_t next_slot,uint8_t abstraction_flag,LTE_DL_FRAME_PARMS *frame_parms, uint32_t,uint8_t);
|
||||
void do_UL_sig(channel_desc_t *UE2eNB[NUMBER_OF_UE_MAX][NUMBER_OF_eNB_MAX][MAX_NUM_CCs],
|
||||
node_desc_t *enb_data[NUMBER_OF_eNB_MAX],node_desc_t *ue_data[NUMBER_OF_UE_MAX],
|
||||
uint16_t subframe,uint8_t abstraction_flag,LTE_DL_FRAME_PARMS *frame_parms,
|
||||
uint32_t frame,int eNB_id,uint8_t CC_id);
|
||||
|
||||
void do_DL_sig(double **r_re0,double **r_im0,double **r_re,double **r_im,double **s_re,double **s_im,channel_desc_t *eNB2UE[NUMBER_OF_eNB_MAX][NUMBER_OF_UE_MAX][MAX_NUM_CCs],
|
||||
node_desc_t *enb_data[NUMBER_OF_eNB_MAX],node_desc_t *ue_data[NUMBER_OF_UE_MAX],uint16_t next_slot,uint8_t abstraction_flag,LTE_DL_FRAME_PARMS *frame_parms,uint8_t UE_id,int CC_id);
|
||||
void do_DL_sig(channel_desc_t *eNB2UE[NUMBER_OF_eNB_MAX][NUMBER_OF_UE_MAX][MAX_NUM_CCs],
|
||||
node_desc_t *enb_data[NUMBER_OF_eNB_MAX],node_desc_t *ue_data[NUMBER_OF_UE_MAX],uint16_t subframe,uint8_t abstraction_flag,LTE_DL_FRAME_PARMS *frame_parms,uint8_t UE_id,int CC_id);
|
||||
|
||||
void init_ue(node_desc_t *ue_data, UE_Antenna ue_ant);//Abstraction changes
|
||||
void init_enb(node_desc_t *enb_data, eNB_Antenna enb_ant);//Abstraction changes
|
||||
|
||||
@@ -427,7 +427,7 @@ int olg_config(void)
|
||||
set_comp_log(PHY, LOG_TRACE, 0x15, 1);
|
||||
set_comp_log(PDCP, LOG_DEBUG, 0x15,1);
|
||||
set_comp_log(RRC, LOG_DEBUG, 0x15,1);
|
||||
set_comp_log(OCM, LOG_ERR, 0x15,20);
|
||||
set_comp_log(OCM, LOG_DEBUG, 0x15,20);
|
||||
set_comp_log(OTG, LOG_DEBUG, 0x15,1);
|
||||
set_comp_log(OMG, LOG_NOTICE, 0x15,1);
|
||||
set_comp_log(OPT, LOG_ERR, 0x15,1);
|
||||
|
||||
@@ -145,8 +145,16 @@ extern time_stats_t ul_chan_stats;
|
||||
|
||||
extern int xforms;
|
||||
|
||||
|
||||
extern uint32_t downlink_frequency[MAX_NUM_CCs][4];
|
||||
extern int32_t uplink_frequency_offset[MAX_NUM_CCs][4];
|
||||
|
||||
void init_eNB(eNB_func_t node_function[], eNB_timing_t node_timing[],int nb_inst);
|
||||
void stop_eNB(int nb_inst);
|
||||
|
||||
const Enb_properties_array_t *enb_properties;
|
||||
|
||||
|
||||
void get_simulation_options(int argc, char *argv[])
|
||||
{
|
||||
int option;
|
||||
@@ -757,12 +765,17 @@ void get_simulation_options(int argc, char *argv[])
|
||||
AssertFatal (oai_emulation.info.nb_enb_local <= enb_properties->number,
|
||||
"Number of eNB is greater than eNB defined in configuration file %s (%d/%d)!",
|
||||
conf_config_file_name, oai_emulation.info.nb_enb_local, enb_properties->number);
|
||||
|
||||
|
||||
/* Update some simulation parameters */
|
||||
oai_emulation.info.frame_type[0] = enb_properties->properties[0]->frame_type[0];
|
||||
oai_emulation.info.tdd_config[0] = enb_properties->properties[0]->tdd_config[0];
|
||||
oai_emulation.info.tdd_config_S[0] = enb_properties->properties[0]->tdd_config_s[0];
|
||||
oai_emulation.info.frame_type[0] = enb_properties->properties[0]->frame_type[0];
|
||||
oai_emulation.info.tdd_config[0] = enb_properties->properties[0]->tdd_config[0];
|
||||
oai_emulation.info.tdd_config_S[0] = enb_properties->properties[0]->tdd_config_s[0];
|
||||
oai_emulation.info.extended_prefix_flag[0] = enb_properties->properties[0]->prefix_type[0];
|
||||
|
||||
oai_emulation.info.node_function[0] = enb_properties->properties[0]->cc_node_function[0];
|
||||
oai_emulation.info.node_timing[0] = enb_properties->properties[0]->cc_node_timing[0];
|
||||
downlink_frequency[0][0] = enb_properties->properties[0]->downlink_frequency[0];
|
||||
uplink_frequency_offset[0][0] = enb_properties->properties[0]->uplink_frequency_offset[0];
|
||||
}
|
||||
|
||||
free(conf_config_file_name);
|
||||
@@ -923,6 +936,215 @@ void init_seed(uint8_t set_seed)
|
||||
}
|
||||
}
|
||||
|
||||
openair0_timestamp current_eNB_rx_timestamp[NUMBER_OF_eNB_MAX][MAX_NUM_CCs];
|
||||
openair0_timestamp current_UE_rx_timestamp[NUMBER_OF_UE_MAX][MAX_NUM_CCs];
|
||||
openair0_timestamp last_eNB_rx_timestamp[NUMBER_OF_eNB_MAX][MAX_NUM_CCs];
|
||||
openair0_timestamp last_UE_rx_timestamp[NUMBER_OF_UE_MAX][MAX_NUM_CCs];
|
||||
|
||||
int eNB_trx_start(openair0_device *device) {
|
||||
return(0);
|
||||
}
|
||||
|
||||
void eNB_trx_end(openair0_device *device) {
|
||||
return;
|
||||
}
|
||||
|
||||
int eNB_trx_stop(openair0_device *device) {
|
||||
return(0);
|
||||
}
|
||||
int UE_trx_start(openair0_device *device) {
|
||||
return(0);
|
||||
}
|
||||
int UE_trx_end(openair0_device *device) {
|
||||
return(0);
|
||||
}
|
||||
int UE_trx_stop(openair0_device *device) {
|
||||
return(0);
|
||||
}
|
||||
int eNB_trx_set_freq(openair0_device *device, openair0_config_t *openair0_cfg, int dummy) {
|
||||
return(0);
|
||||
}
|
||||
int eNB_trx_set_gains(openair0_device *device, openair0_config_t *openair0_cfg) {
|
||||
return(0);
|
||||
}
|
||||
int UE_trx_set_freq(openair0_device *device, openair0_config_t *openair0_cfg, int dummy) {
|
||||
return(0);
|
||||
}
|
||||
int UE_trx_set_gains(openair0_device *device, openair0_config_t *openair0_cfg) {
|
||||
return(0);
|
||||
}
|
||||
|
||||
extern pthread_mutex_t subframe_mutex;
|
||||
extern int subframe_eNB_mask,subframe_UE_mask;
|
||||
|
||||
int eNB_trx_read(openair0_device *device, openair0_timestamp *ptimestamp, void **buff, int nsamps, int cc) {
|
||||
|
||||
int eNB_id = device->Mod_id;
|
||||
int CC_id = device->CC_id;
|
||||
|
||||
int subframe;
|
||||
int ready_for_new_subframe=0;
|
||||
int subframe_eNB_mask_local;
|
||||
int sample_count=0;
|
||||
|
||||
*ptimestamp = last_eNB_rx_timestamp[eNB_id][CC_id];
|
||||
|
||||
LOG_D(PHY,"eNB_trx_read nsamps %d TS(%llu,%llu) => subframe %d\n",nsamps,
|
||||
(unsigned long long)current_eNB_rx_timestamp[eNB_id][CC_id],
|
||||
(unsigned long long)last_eNB_rx_timestamp[eNB_id][CC_id],
|
||||
(*ptimestamp/PHY_vars_eNB_g[eNB_id][CC_id]->frame_parms.samples_per_tti)%10);
|
||||
// if we're at a subframe boundary generate UL signals for this eNB
|
||||
|
||||
while (sample_count<nsamps) {
|
||||
while (current_eNB_rx_timestamp[eNB_id][CC_id]<
|
||||
(nsamps+last_eNB_rx_timestamp[eNB_id][CC_id])) {
|
||||
LOG_D(EMU,"eNB: current TS %llu, last TS %llu, sleeping\n",current_eNB_rx_timestamp[eNB_id][CC_id],last_eNB_rx_timestamp[eNB_id][CC_id]);
|
||||
usleep(500);
|
||||
}
|
||||
|
||||
// tell top-level we are busy
|
||||
pthread_mutex_lock(&subframe_mutex);
|
||||
subframe_eNB_mask|=(1<<eNB_id);
|
||||
pthread_mutex_unlock(&subframe_mutex);
|
||||
|
||||
subframe = (last_eNB_rx_timestamp[eNB_id][CC_id]/PHY_vars_eNB_g[eNB_id][CC_id]->frame_parms.samples_per_tti)%10;
|
||||
LOG_D(PHY,"eNB_trx_read generating UL subframe %d (Ts %llu, current TS %llu)\n",
|
||||
subframe,(unsigned long long)*ptimestamp,
|
||||
(unsigned long long)current_eNB_rx_timestamp[eNB_id][CC_id]);
|
||||
|
||||
do_UL_sig(UE2eNB,
|
||||
enb_data,
|
||||
ue_data,
|
||||
subframe,
|
||||
0, // abstraction_flag
|
||||
&PHY_vars_eNB_g[eNB_id][CC_id]->frame_parms,
|
||||
0, // frame is only used for abstraction
|
||||
eNB_id,
|
||||
CC_id);
|
||||
|
||||
last_eNB_rx_timestamp[eNB_id][CC_id] += PHY_vars_eNB_g[eNB_id][CC_id]->frame_parms.samples_per_tti;
|
||||
sample_count += PHY_vars_eNB_g[eNB_id][CC_id]->frame_parms.samples_per_tti;
|
||||
}
|
||||
|
||||
|
||||
|
||||
return(nsamps);
|
||||
}
|
||||
|
||||
int UE_trx_read(openair0_device *device, openair0_timestamp *ptimestamp, void **buff, int nsamps, int cc) {
|
||||
|
||||
int UE_id = device->Mod_id;
|
||||
int CC_id = device->CC_id;
|
||||
int subframe;
|
||||
int ready_for_new_subframe=0;
|
||||
int subframe_UE_mask_local;
|
||||
int sample_count=0;
|
||||
int read_size;
|
||||
|
||||
*ptimestamp = last_UE_rx_timestamp[UE_id][CC_id];
|
||||
|
||||
LOG_D(EMU,"UE_trx_read nsamps %d TS(%llu,%llu) antenna %d\n",nsamps,
|
||||
(unsigned long long)current_UE_rx_timestamp[UE_id][CC_id],
|
||||
(unsigned long long)last_UE_rx_timestamp[UE_id][CC_id],
|
||||
cc);
|
||||
|
||||
if (nsamps < PHY_vars_UE_g[UE_id][CC_id]->frame_parms.samples_per_tti)
|
||||
read_size = nsamps;
|
||||
else
|
||||
read_size = PHY_vars_UE_g[UE_id][CC_id]->frame_parms.samples_per_tti;
|
||||
|
||||
while (sample_count<nsamps) {
|
||||
while (current_UE_rx_timestamp[UE_id][CC_id] <
|
||||
(last_UE_rx_timestamp[UE_id][CC_id]+read_size)) {
|
||||
LOG_D(EMU,"UE_trx_read : current TS %d, last TS %d, sleeping\n",current_UE_rx_timestamp[UE_id][CC_id],last_UE_rx_timestamp[UE_id][CC_id]);
|
||||
|
||||
usleep(500);
|
||||
}
|
||||
|
||||
LOG_D(EMU,"UE_trx_read : current TS %d, last TS %d, sleeping\n",current_UE_rx_timestamp[UE_id][CC_id],last_UE_rx_timestamp[UE_id][CC_id]);
|
||||
|
||||
// tell top-level we are busy
|
||||
pthread_mutex_lock(&subframe_mutex);
|
||||
subframe_UE_mask|=(1<<UE_id);
|
||||
pthread_mutex_unlock(&subframe_mutex);
|
||||
|
||||
|
||||
// otherwise we have one subframe here so generate the received signal
|
||||
subframe = (last_UE_rx_timestamp[UE_id][CC_id]/PHY_vars_UE_g[UE_id][CC_id]->frame_parms.samples_per_tti)%10;
|
||||
if ((last_UE_rx_timestamp[UE_id][CC_id]%PHY_vars_UE_g[UE_id][CC_id]->frame_parms.samples_per_tti) > 0)
|
||||
subframe++;
|
||||
|
||||
last_UE_rx_timestamp[UE_id][CC_id] += read_size;
|
||||
sample_count += read_size;
|
||||
|
||||
if (subframe > 9)
|
||||
return(nsamps);
|
||||
|
||||
LOG_D(PHY,"UE_trx_read generating DL subframe %d (Ts %llu, current TS %llu)\n",
|
||||
subframe,(unsigned long long)*ptimestamp,
|
||||
(unsigned long long)current_UE_rx_timestamp[UE_id][CC_id]);
|
||||
do_DL_sig(eNB2UE,
|
||||
enb_data,
|
||||
ue_data,
|
||||
subframe,
|
||||
0, //abstraction_flag,
|
||||
&PHY_vars_UE_g[UE_id][CC_id]->frame_parms,
|
||||
UE_id,
|
||||
CC_id);
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
return(nsamps);
|
||||
}
|
||||
|
||||
int eNB_trx_write(openair0_device *device,openair0_timestamp timestamp, void **buff, int nsamps, int cc, int flags) {
|
||||
|
||||
return(nsamps);
|
||||
}
|
||||
|
||||
int UE_trx_write(openair0_device *device,openair0_timestamp timestamp, void **buff, int nsamps, int cc, int flags) {
|
||||
|
||||
return(nsamps);
|
||||
}
|
||||
|
||||
void init_devices(void){
|
||||
|
||||
module_id_t UE_id, eNB_id;
|
||||
uint8_t CC_id;
|
||||
|
||||
for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
|
||||
for (eNB_id=0;eNB_id<NB_eNB_INST;eNB_id++) {
|
||||
PHY_vars_eNB_g[eNB_id][CC_id]->rfdevice.Mod_id = eNB_id;
|
||||
PHY_vars_eNB_g[eNB_id][CC_id]->rfdevice.CC_id = CC_id;
|
||||
PHY_vars_eNB_g[eNB_id][CC_id]->rfdevice.trx_start_func = eNB_trx_start;
|
||||
PHY_vars_eNB_g[eNB_id][CC_id]->rfdevice.trx_read_func = eNB_trx_read;
|
||||
PHY_vars_eNB_g[eNB_id][CC_id]->rfdevice.trx_write_func = eNB_trx_write;
|
||||
PHY_vars_eNB_g[eNB_id][CC_id]->rfdevice.trx_end_func = eNB_trx_end;
|
||||
PHY_vars_eNB_g[eNB_id][CC_id]->rfdevice.trx_stop_func = eNB_trx_stop;
|
||||
PHY_vars_eNB_g[eNB_id][CC_id]->rfdevice.trx_set_freq_func = eNB_trx_set_freq;
|
||||
PHY_vars_eNB_g[eNB_id][CC_id]->rfdevice.trx_set_gains_func = eNB_trx_set_gains;
|
||||
current_eNB_rx_timestamp[eNB_id][CC_id] = PHY_vars_eNB_g[eNB_id][CC_id]->frame_parms.samples_per_tti;
|
||||
last_eNB_rx_timestamp[eNB_id][CC_id] = 0;
|
||||
}
|
||||
for (UE_id=0;UE_id<NB_UE_INST;UE_id++) {
|
||||
PHY_vars_UE_g[UE_id][CC_id]->rfdevice.Mod_id = UE_id;
|
||||
PHY_vars_UE_g[UE_id][CC_id]->rfdevice.CC_id = CC_id;
|
||||
PHY_vars_UE_g[UE_id][CC_id]->rfdevice.trx_start_func = UE_trx_start;
|
||||
PHY_vars_UE_g[UE_id][CC_id]->rfdevice.trx_read_func = UE_trx_read;
|
||||
PHY_vars_UE_g[UE_id][CC_id]->rfdevice.trx_write_func = UE_trx_write;
|
||||
PHY_vars_UE_g[UE_id][CC_id]->rfdevice.trx_end_func = UE_trx_end;
|
||||
PHY_vars_UE_g[UE_id][CC_id]->rfdevice.trx_stop_func = UE_trx_stop;
|
||||
PHY_vars_UE_g[UE_id][CC_id]->rfdevice.trx_set_freq_func = UE_trx_set_freq;
|
||||
PHY_vars_UE_g[UE_id][CC_id]->rfdevice.trx_set_gains_func = UE_trx_set_gains;
|
||||
current_UE_rx_timestamp[UE_id][CC_id] = PHY_vars_UE_g[UE_id][CC_id]->frame_parms.samples_per_tti;
|
||||
last_UE_rx_timestamp[UE_id][CC_id] = 0;
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void init_openair1(void)
|
||||
{
|
||||
module_id_t UE_id, eNB_id;
|
||||
@@ -955,46 +1177,51 @@ void init_openair1(void)
|
||||
PHY_vars_eNB_g[eNB_id][CC_id]->pusch_config_dedicated[UE_id].betaOffset_ACK_Index = beta_ACK;
|
||||
PHY_vars_eNB_g[eNB_id][CC_id]->pusch_config_dedicated[UE_id].betaOffset_RI_Index = beta_RI;
|
||||
PHY_vars_eNB_g[eNB_id][CC_id]->pusch_config_dedicated[UE_id].betaOffset_CQI_Index = beta_CQI;
|
||||
PHY_vars_eNB_g[eNB_id][CC_id]->lte_frame_parms.pdsch_config_common.p_b = (frame_parms[CC_id]->nb_antennas_tx_eNB>1) ? 1 : 0; // rho_A = rho_B
|
||||
PHY_vars_eNB_g[eNB_id][CC_id]->frame_parms.pdsch_config_common.p_b = (frame_parms[CC_id]->nb_antennas_tx_eNB>1) ? 1 : 0; // rho_A = rho_B
|
||||
|
||||
PHY_vars_UE_g[UE_id][CC_id]->pusch_config_dedicated[eNB_id].betaOffset_ACK_Index = beta_ACK;
|
||||
PHY_vars_UE_g[UE_id][CC_id]->pusch_config_dedicated[eNB_id].betaOffset_RI_Index = beta_RI;
|
||||
PHY_vars_UE_g[UE_id][CC_id]->pusch_config_dedicated[eNB_id].betaOffset_CQI_Index = beta_CQI;
|
||||
PHY_vars_UE_g[UE_id][CC_id]->lte_frame_parms.pdsch_config_common.p_b = (frame_parms[CC_id]->nb_antennas_tx_eNB>1) ? 1 : 0; // rho_A = rho_B
|
||||
PHY_vars_UE_g[UE_id][CC_id]->frame_parms.pdsch_config_common.p_b = (frame_parms[CC_id]->nb_antennas_tx_eNB>1) ? 1 : 0; // rho_A = rho_B
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
printf ("AFTER init: MAX_NUM_CCs %d, Nid_cell %d frame_type %d,tdd_config %d\n",
|
||||
MAX_NUM_CCs,
|
||||
PHY_vars_eNB_g[0][0]->lte_frame_parms.Nid_cell,
|
||||
PHY_vars_eNB_g[0][0]->lte_frame_parms.frame_type,
|
||||
PHY_vars_eNB_g[0][0]->lte_frame_parms.tdd_config);
|
||||
PHY_vars_eNB_g[0][0]->frame_parms.Nid_cell,
|
||||
PHY_vars_eNB_g[0][0]->frame_parms.frame_type,
|
||||
PHY_vars_eNB_g[0][0]->frame_parms.tdd_config);
|
||||
|
||||
number_of_cards = 1;
|
||||
|
||||
openair_daq_vars.rx_rf_mode = 1;
|
||||
openair_daq_vars.tdd = 1;
|
||||
openair_daq_vars.rx_gain_mode = DAQ_AGC_ON;
|
||||
// openair_daq_vars.rx_rf_mode = 1;
|
||||
// openair_daq_vars.tdd = 1;
|
||||
// openair_daq_vars.rx_gain_mode = DAQ_AGC_ON;
|
||||
|
||||
openair_daq_vars.dlsch_transmission_mode = oai_emulation.info.transmission_mode[0];
|
||||
// openair_daq_vars.dlsch_transmission_mode = oai_emulation.info.transmission_mode[0];
|
||||
//#warning "NN->FK: OAI EMU channel abstraction does not work for MCS higher than"
|
||||
openair_daq_vars.target_ue_dl_mcs = cmin(target_dl_mcs,16);
|
||||
openair_daq_vars.target_ue_ul_mcs = target_ul_mcs;
|
||||
openair_daq_vars.ue_dl_rb_alloc=0x1fff;
|
||||
openair_daq_vars.ue_ul_nb_rb=6;
|
||||
openair_daq_vars.dlsch_rate_adaptation = rate_adaptation_flag;
|
||||
openair_daq_vars.use_ia_receiver = 0;
|
||||
// openair_daq_vars.target_ue_dl_mcs = cmin(target_dl_mcs,16);
|
||||
// openair_daq_vars.target_ue_ul_mcs = target_ul_mcs;
|
||||
// openair_daq_vars.ue_dl_rb_alloc=0x1fff;
|
||||
// openair_daq_vars.ue_ul_nb_rb=6;
|
||||
// openair_daq_vars.dlsch_rate_adaptation = rate_adaptation_flag;
|
||||
|
||||
//N_TA_offset
|
||||
for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
|
||||
for (UE_id=0; UE_id<NB_UE_INST; UE_id++) {
|
||||
if (PHY_vars_UE_g[UE_id][CC_id]->lte_frame_parms.frame_type == TDD) {
|
||||
if (PHY_vars_UE_g[UE_id][CC_id]->lte_frame_parms.N_RB_DL == 100)
|
||||
|
||||
PHY_vars_UE_g[UE_id][CC_id]->use_ia_receiver = 0;
|
||||
PHY_vars_UE_g[UE_id][CC_id]->mode = normal_txrx;
|
||||
PHY_vars_UE_g[UE_id][CC_id]->mac_enabled = 1;
|
||||
PHY_vars_UE_g[UE_id][CC_id]->no_timing_correction = 1;
|
||||
|
||||
if (PHY_vars_UE_g[UE_id][CC_id]->frame_parms.frame_type == TDD) {
|
||||
if (PHY_vars_UE_g[UE_id][CC_id]->frame_parms.N_RB_DL == 100)
|
||||
PHY_vars_UE_g[UE_id][CC_id]->N_TA_offset = 624;
|
||||
else if (PHY_vars_UE_g[UE_id][CC_id]->lte_frame_parms.N_RB_DL == 50)
|
||||
else if (PHY_vars_UE_g[UE_id][CC_id]->frame_parms.N_RB_DL == 50)
|
||||
PHY_vars_UE_g[UE_id][CC_id]->N_TA_offset = 624/2;
|
||||
else if (PHY_vars_UE_g[UE_id][CC_id]->lte_frame_parms.N_RB_DL == 25)
|
||||
else if (PHY_vars_UE_g[UE_id][CC_id]->frame_parms.N_RB_DL == 25)
|
||||
PHY_vars_UE_g[UE_id][CC_id]->N_TA_offset = 624/4;
|
||||
} else {
|
||||
PHY_vars_UE_g[UE_id][CC_id]->N_TA_offset = 0;
|
||||
@@ -1002,33 +1229,38 @@ void init_openair1(void)
|
||||
}
|
||||
|
||||
for (eNB_id=0; eNB_id<NB_eNB_INST; eNB_id++) {
|
||||
if (PHY_vars_eNB_g[eNB_id][CC_id]->lte_frame_parms.frame_type == TDD) {
|
||||
if (PHY_vars_eNB_g[eNB_id][CC_id]->lte_frame_parms.N_RB_DL == 100)
|
||||
if (PHY_vars_eNB_g[eNB_id][CC_id]->frame_parms.frame_type == TDD) {
|
||||
if (PHY_vars_eNB_g[eNB_id][CC_id]->frame_parms.N_RB_DL == 100)
|
||||
PHY_vars_eNB_g[eNB_id][CC_id]->N_TA_offset = 624;
|
||||
else if (PHY_vars_eNB_g[eNB_id][CC_id]->lte_frame_parms.N_RB_DL == 50)
|
||||
else if (PHY_vars_eNB_g[eNB_id][CC_id]->frame_parms.N_RB_DL == 50)
|
||||
PHY_vars_eNB_g[eNB_id][CC_id]->N_TA_offset = 624/2;
|
||||
else if (PHY_vars_eNB_g[eNB_id][CC_id]->lte_frame_parms.N_RB_DL == 25)
|
||||
else if (PHY_vars_eNB_g[eNB_id][CC_id]->frame_parms.N_RB_DL == 25)
|
||||
PHY_vars_eNB_g[eNB_id][CC_id]->N_TA_offset = 624/4;
|
||||
} else {
|
||||
PHY_vars_eNB_g[eNB_id][CC_id]->N_TA_offset = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
} // eNB_id
|
||||
} // CC_id
|
||||
|
||||
for (eNB_id=0; eNB_id<NB_eNB_INST; eNB_id++)
|
||||
for (eNB_id=0; eNB_id<NB_eNB_INST; eNB_id++) {
|
||||
for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
|
||||
if (phy_test==1)
|
||||
PHY_vars_eNB_g[eNB_id][CC_id]->mac_enabled=0;
|
||||
else
|
||||
PHY_vars_eNB_g[eNB_id][CC_id]->mac_enabled=1;
|
||||
}
|
||||
}
|
||||
|
||||
init_devices ();
|
||||
|
||||
init_eNB(oai_emulation.info.node_function,oai_emulation.info.node_timing,NB_eNB_INST);
|
||||
|
||||
// init_ue_status();
|
||||
for (UE_id=0; UE_id<NB_UE_INST; UE_id++)
|
||||
for (UE_id=0; UE_id<NB_UE_INST; UE_id++) {
|
||||
for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
|
||||
|
||||
|
||||
PHY_vars_UE_g[UE_id][CC_id]->tx_power_max_dBm=23;
|
||||
|
||||
|
||||
PHY_vars_UE_g[UE_id][CC_id]->rx_total_gain_dB=100;
|
||||
|
||||
// update UE_mode for each eNB_id not just 0
|
||||
@@ -1044,7 +1276,7 @@ void init_openair1(void)
|
||||
else
|
||||
PHY_vars_UE_g[UE_id][CC_id]->mac_enabled=1;
|
||||
|
||||
PHY_vars_UE_g[UE_id][CC_id]->lte_ue_pdcch_vars[0]->crnti = 0x1235 + UE_id;
|
||||
PHY_vars_UE_g[UE_id][CC_id]->pdcch_vars[0]->crnti = 0x1235 + UE_id;
|
||||
PHY_vars_UE_g[UE_id][CC_id]->current_dlsch_cqi[0] = 10;
|
||||
|
||||
LOG_I(EMU, "UE %d mode is initialized to %d\n", UE_id, PHY_vars_UE_g[UE_id][CC_id]->UE_mode[0] );
|
||||
@@ -1061,8 +1293,10 @@ void init_openair1(void)
|
||||
|
||||
#endif
|
||||
|
||||
} // CC_id
|
||||
} // UE_id
|
||||
init_UE(NB_UE_INST);
|
||||
}
|
||||
}
|
||||
|
||||
void init_openair2(void)
|
||||
{
|
||||
@@ -1073,7 +1307,7 @@ void init_openair2(void)
|
||||
//#warning "eNB index is hard coded to zero"
|
||||
|
||||
for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++)
|
||||
l2_init (&PHY_vars_eNB_g[0][CC_id]->lte_frame_parms,
|
||||
l2_init (&PHY_vars_eNB_g[0][CC_id]->frame_parms,
|
||||
oai_emulation.info.eMBMS_active_state,
|
||||
NULL,
|
||||
oai_emulation.info.cba_group_active,
|
||||
@@ -1114,7 +1348,7 @@ void init_ocm(void)
|
||||
get_beta_map_up();
|
||||
#endif
|
||||
get_MIESM_param();
|
||||
|
||||
|
||||
//load_pbch_desc();
|
||||
}
|
||||
|
||||
@@ -1154,24 +1388,13 @@ void init_ocm(void)
|
||||
LOG_D(OCM,"Initializing channel (%s, %d) from eNB %d to UE %d\n", oai_emulation.environment_system_config.fading.small_scale.selected_option,
|
||||
map_str_to_int(small_scale_names,oai_emulation.environment_system_config.fading.small_scale.selected_option), eNB_id, UE_id);
|
||||
|
||||
/* if (oai_emulation.info.transmission_mode == 5)
|
||||
eNB2UE[eNB_id][UE_id] = new_channel_desc_scm(PHY_vars_eNB_g[eNB_id]->lte_frame_parms.nb_antennas_tx,
|
||||
PHY_vars_UE_g[UE_id]->lte_frame_parms.nb_antennas_rx,
|
||||
(UE_id == 0)? Rice1_corr : Rice1_anticorr,
|
||||
oai_emulation.environment_system_config.system_bandwidth_MB,
|
||||
forgetting_factor,
|
||||
0,
|
||||
0);
|
||||
|
||||
else
|
||||
*/
|
||||
|
||||
eNB2UE[eNB_id][UE_id][CC_id] =
|
||||
new_channel_desc_scm(PHY_vars_eNB_g[eNB_id][CC_id]->lte_frame_parms.nb_antennas_tx,
|
||||
PHY_vars_UE_g[UE_id][CC_id]->lte_frame_parms.nb_antennas_rx,
|
||||
new_channel_desc_scm(PHY_vars_eNB_g[eNB_id][CC_id]->frame_parms.nb_antennas_tx,
|
||||
PHY_vars_UE_g[UE_id][CC_id]->frame_parms.nb_antennas_rx,
|
||||
map_str_to_int(small_scale_names,oai_emulation.environment_system_config.fading.small_scale.selected_option),
|
||||
N_RB2sampling_rate(PHY_vars_eNB_g[eNB_id][CC_id]->lte_frame_parms.N_RB_DL),
|
||||
N_RB2channel_bandwidth(PHY_vars_eNB_g[eNB_id][CC_id]->lte_frame_parms.N_RB_DL),
|
||||
N_RB2sampling_rate(PHY_vars_eNB_g[eNB_id][CC_id]->frame_parms.N_RB_DL),
|
||||
N_RB2channel_bandwidth(PHY_vars_eNB_g[eNB_id][CC_id]->frame_parms.N_RB_DL),
|
||||
forgetting_factor,
|
||||
0,
|
||||
0);
|
||||
@@ -1180,11 +1403,11 @@ void init_ocm(void)
|
||||
map_str_to_int(small_scale_names, oai_emulation.environment_system_config.fading.small_scale.selected_option),UE_id, eNB_id);
|
||||
|
||||
UE2eNB[UE_id][eNB_id][CC_id] =
|
||||
new_channel_desc_scm(PHY_vars_UE_g[UE_id][CC_id]->lte_frame_parms.nb_antennas_tx,
|
||||
PHY_vars_eNB_g[eNB_id][CC_id]->lte_frame_parms.nb_antennas_rx,
|
||||
new_channel_desc_scm(PHY_vars_UE_g[UE_id][CC_id]->frame_parms.nb_antennas_tx,
|
||||
PHY_vars_eNB_g[eNB_id][CC_id]->frame_parms.nb_antennas_rx,
|
||||
map_str_to_int(small_scale_names, oai_emulation.environment_system_config.fading.small_scale.selected_option),
|
||||
N_RB2sampling_rate(PHY_vars_eNB_g[eNB_id][CC_id]->lte_frame_parms.N_RB_UL),
|
||||
N_RB2channel_bandwidth(PHY_vars_eNB_g[eNB_id][CC_id]->lte_frame_parms.N_RB_UL),
|
||||
N_RB2sampling_rate(PHY_vars_eNB_g[eNB_id][CC_id]->frame_parms.N_RB_UL),
|
||||
N_RB2channel_bandwidth(PHY_vars_eNB_g[eNB_id][CC_id]->frame_parms.N_RB_UL),
|
||||
forgetting_factor,
|
||||
0,
|
||||
0);
|
||||
@@ -1253,10 +1476,10 @@ void update_ocm()
|
||||
int CC_id;
|
||||
|
||||
for (eNB_id = 0; eNB_id < NB_eNB_INST; eNB_id++)
|
||||
enb_data[eNB_id]->tx_power_dBm = PHY_vars_eNB_g[eNB_id][0]->lte_frame_parms.pdsch_config_common.referenceSignalPower;
|
||||
enb_data[eNB_id]->tx_power_dBm = PHY_vars_eNB_g[eNB_id][0]->frame_parms.pdsch_config_common.referenceSignalPower;
|
||||
|
||||
for (UE_id = 0; UE_id < NB_UE_INST; UE_id++)
|
||||
ue_data[UE_id]->tx_power_dBm = PHY_vars_UE_g[UE_id][0]->tx_power_dBm;
|
||||
ue_data[UE_id]->tx_power_dBm = PHY_vars_UE_g[UE_id][0]->tx_power_dBm[0];
|
||||
|
||||
|
||||
/* check if the openair channel model is activated used for PHY abstraction : path loss*/
|
||||
@@ -1303,17 +1526,17 @@ void update_ocm()
|
||||
|
||||
//pathloss: -132.24 dBm/15kHz RE + target SNR - eNB TX power per RE
|
||||
if (eNB_id == (UE_id % NB_eNB_INST)) {
|
||||
eNB2UE[eNB_id][UE_id][CC_id]->path_loss_dB = -132.24 + snr_dB - PHY_vars_eNB_g[eNB_id][CC_id]->lte_frame_parms.pdsch_config_common.referenceSignalPower;
|
||||
UE2eNB[UE_id][eNB_id][CC_id]->path_loss_dB = -132.24 + snr_dB - PHY_vars_eNB_g[eNB_id][CC_id]->lte_frame_parms.pdsch_config_common.referenceSignalPower;
|
||||
eNB2UE[eNB_id][UE_id][CC_id]->path_loss_dB = -132.24 + snr_dB - PHY_vars_eNB_g[eNB_id][CC_id]->frame_parms.pdsch_config_common.referenceSignalPower;
|
||||
UE2eNB[UE_id][eNB_id][CC_id]->path_loss_dB = -132.24 + snr_dB - PHY_vars_eNB_g[eNB_id][CC_id]->frame_parms.pdsch_config_common.referenceSignalPower;
|
||||
} else {
|
||||
eNB2UE[eNB_id][UE_id][CC_id]->path_loss_dB = -132.24 + sinr_dB - PHY_vars_eNB_g[eNB_id][CC_id]->lte_frame_parms.pdsch_config_common.referenceSignalPower;
|
||||
UE2eNB[UE_id][eNB_id][CC_id]->path_loss_dB = -132.24 + sinr_dB - PHY_vars_eNB_g[eNB_id][CC_id]->lte_frame_parms.pdsch_config_common.referenceSignalPower;
|
||||
eNB2UE[eNB_id][UE_id][CC_id]->path_loss_dB = -132.24 + sinr_dB - PHY_vars_eNB_g[eNB_id][CC_id]->frame_parms.pdsch_config_common.referenceSignalPower;
|
||||
UE2eNB[UE_id][eNB_id][CC_id]->path_loss_dB = -132.24 + sinr_dB - PHY_vars_eNB_g[eNB_id][CC_id]->frame_parms.pdsch_config_common.referenceSignalPower;
|
||||
}
|
||||
|
||||
LOG_I(OCM,"Path loss from eNB %d to UE %d (CCid %d)=> %f dB (eNB TX %d, SNR %f)\n",eNB_id,UE_id,CC_id,
|
||||
LOG_D(OCM,"Path loss from eNB %d to UE %d (CCid %d)=> %f dB (eNB TX %d, SNR %f)\n",eNB_id,UE_id,CC_id,
|
||||
eNB2UE[eNB_id][UE_id][CC_id]->path_loss_dB,
|
||||
PHY_vars_eNB_g[eNB_id][CC_id]->lte_frame_parms.pdsch_config_common.referenceSignalPower,snr_dB);
|
||||
// printf("[SIM] Path loss from UE %d to eNB %d => %f dB\n",UE_id,eNB_id,UE2eNB[UE_id][eNB_id]->path_loss_dB);
|
||||
PHY_vars_eNB_g[eNB_id][CC_id]->frame_parms.pdsch_config_common.referenceSignalPower,snr_dB);
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1581,3 +1804,14 @@ void init_time()
|
||||
td_avg = TARGET_SF_TIME_NS;
|
||||
}
|
||||
|
||||
int openair0_transport_load(openair0_device *device, openair0_config_t *openair0_cfg, eth_params_t * eth_params) {
|
||||
|
||||
return(0);
|
||||
|
||||
|
||||
}
|
||||
|
||||
int openair0_device_load(openair0_device *device, openair0_config_t *openair0_cfg) {
|
||||
|
||||
return(0);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user