ulsim.c 67.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
/*
 * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The OpenAirInterface Software Alliance licenses this file to You under
 * the OAI Public License, Version 1.0  (the "License"); you may not use this file
 * except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.openairinterface.org/?page_id=698
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *-------------------------------------------------------------------------------
 * For more information about the OpenAirInterface (OAI) Software Alliance:
 *      contact@openairinterface.org
 */
21 22

/*! \file ulsim.c
Xiwen JIANG's avatar
Xiwen JIANG committed
23
 \brief Top-level UL simulator
24
 \author R. Knopp
25
 \date 2011 - 2014
26 27 28 29 30 31 32
 \version 0.1
 \company Eurecom
 \email: knopp@eurecom.fr
 \note
 \warning
*/

33 34 35 36 37 38 39 40 41 42 43 44
#include <string.h>
#include <math.h>
#include <unistd.h>
#include "SIMULATION/TOOLS/defs.h"
#include "PHY/types.h"
#include "PHY/defs.h"
#include "PHY/vars.h"

#include "SCHED/defs.h"
#include "SCHED/vars.h"
#include "LAYER2/MAC/vars.h"
#include "OCG_vars.h"
Calisson's avatar
Calisson committed
45
#include "intertask_interface_init.h"
46

47 48
#include "unitary_defs.h"

49 50
#include "PHY/TOOLS/lte_phy_scope.h"

51 52 53
PHY_VARS_eNB *eNB;
PHY_VARS_UE *UE;

54
double cpuf;
55

Florian Kaltenberger's avatar
Florian Kaltenberger committed
56

57

Florian Kaltenberger's avatar
Florian Kaltenberger committed
58
//#define MCS_COUNT 23//added for PHY abstraction
59 60 61 62

channel_desc_t *eNB2UE[NUMBER_OF_eNB_MAX][NUMBER_OF_UE_MAX];
channel_desc_t *UE2eNB[NUMBER_OF_UE_MAX][NUMBER_OF_eNB_MAX];
//Added for PHY abstraction
63
node_desc_t *enb_data[NUMBER_OF_eNB_MAX];
64 65 66
node_desc_t *ue_data[NUMBER_OF_UE_MAX];
//double sinr_bler_map[MCS_COUNT][2][16];

67
extern uint16_t beta_ack[16],beta_ri[16],beta_cqi[16];
68 69
//extern  char* namepointer_chMag ;

70
int xforms=0;
71 72 73
FD_lte_phy_scope_enb *form_enb;
char title[255];

74 75 76 77 78 79 80 81
/*the following parameters are used to control the processing times*/
double t_tx_max = -1000000000; /*!< \brief initial max process time for tx */
double t_rx_max = -1000000000; /*!< \brief initial max process time for rx */
double t_tx_min = 1000000000; /*!< \brief initial min process time for tx */
double t_rx_min = 1000000000; /*!< \brief initial min process time for tx */
int n_tx_dropped = 0; /*!< \brief initial max process time for tx */
int n_rx_dropped = 0; /*!< \brief initial max process time for rx */

82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166

void fill_ulsch_dci(PHY_VARS_eNB *eNB,void *UL_dci,int first_rb,int nb_rb,int mcs,int ndi,int cqi_flag) {

  switch (eNB->frame_parms.N_RB_UL) {
  case 6:
    break;

  case 25:
    if (eNB->frame_parms.frame_type == TDD) {
      ((DCI0_5MHz_TDD_1_6_t*)UL_dci)->type    = 0;
      ((DCI0_5MHz_TDD_1_6_t*)UL_dci)->rballoc = computeRIV(eNB->frame_parms.N_RB_UL,first_rb,nb_rb);// 12 RBs from position 8
      //printf("nb_rb %d/%d, rballoc %d (dci %x)\n",nb_rb,eNB->frame_parms.N_RB_UL,((DCI0_5MHz_TDD_1_6_t*)UL_dci)->rballoc,*(uint32_t *)UL_dci);
      ((DCI0_5MHz_TDD_1_6_t*)UL_dci)->mcs     = mcs;
      ((DCI0_5MHz_TDD_1_6_t*)UL_dci)->ndi     = ndi;
      ((DCI0_5MHz_TDD_1_6_t*)UL_dci)->TPC     = 0;
      ((DCI0_5MHz_TDD_1_6_t*)UL_dci)->cqi_req = cqi_flag&1;
      ((DCI0_5MHz_TDD_1_6_t*)UL_dci)->cshift  = 0;
      ((DCI0_5MHz_TDD_1_6_t*)UL_dci)->dai     = 1;
    } else {
      ((DCI0_5MHz_FDD_t*)UL_dci)->type    = 0;
      ((DCI0_5MHz_FDD_t*)UL_dci)->rballoc = computeRIV(eNB->frame_parms.N_RB_UL,first_rb,nb_rb);// 12 RBs from position 8
      //      printf("nb_rb %d/%d, rballoc %d (dci %x) (dcip %p)\n",nb_rb,eNB->frame_parms.N_RB_UL,((DCI0_5MHz_FDD_t*)UL_dci)->rballoc,*(uint32_t *)UL_dci,UL_dci);
      ((DCI0_5MHz_FDD_t*)UL_dci)->mcs     = mcs;
      ((DCI0_5MHz_FDD_t*)UL_dci)->ndi     = ndi;
      ((DCI0_5MHz_FDD_t*)UL_dci)->TPC     = 0;
      ((DCI0_5MHz_FDD_t*)UL_dci)->cqi_req = cqi_flag&1;
      ((DCI0_5MHz_FDD_t*)UL_dci)->cshift  = 0;
    }

    break;

  case 50:
    if (eNB->frame_parms.frame_type == TDD) {
      ((DCI0_10MHz_TDD_1_6_t*)UL_dci)->type    = 0;
      ((DCI0_10MHz_TDD_1_6_t*)UL_dci)->rballoc = computeRIV(eNB->frame_parms.N_RB_UL,first_rb,nb_rb);// 12 RBs from position 8
      //      printf("nb_rb %d/%d, rballoc %d (dci %x)\n",nb_rb,eNB->frame_parms.N_RB_UL,((DCI0_10MHz_TDD_1_6_t*)UL_dci)->rballoc,*(uint32_t *)UL_dci);
      ((DCI0_10MHz_TDD_1_6_t*)UL_dci)->mcs     = mcs;
      ((DCI0_10MHz_TDD_1_6_t*)UL_dci)->ndi     = ndi;
      ((DCI0_10MHz_TDD_1_6_t*)UL_dci)->TPC     = 0;
      ((DCI0_10MHz_TDD_1_6_t*)UL_dci)->cqi_req = cqi_flag&1;
      ((DCI0_10MHz_TDD_1_6_t*)UL_dci)->cshift  = 0;
      ((DCI0_10MHz_TDD_1_6_t*)UL_dci)->dai     = 1;
    } else {
      ((DCI0_10MHz_FDD_t*)UL_dci)->type    = 0;
      ((DCI0_10MHz_FDD_t*)UL_dci)->rballoc = computeRIV(eNB->frame_parms.N_RB_UL,first_rb,nb_rb);// 12 RBs from position 8
      //printf("nb_rb %d/%d, rballoc %d (dci %x)\n",nb_rb,eNB->frame_parms.N_RB_UL,((DCI0_10MHz_FDD_t*)UL_dci)->rballoc,*(uint32_t *)UL_dci);
      ((DCI0_10MHz_FDD_t*)UL_dci)->mcs     = mcs;
      ((DCI0_10MHz_FDD_t*)UL_dci)->ndi     = ndi;
      ((DCI0_10MHz_FDD_t*)UL_dci)->TPC     = 0;
      ((DCI0_10MHz_FDD_t*)UL_dci)->cqi_req = cqi_flag&1;
      ((DCI0_10MHz_FDD_t*)UL_dci)->cshift  = 0;
    }

    break;

  case 100:
    if (eNB->frame_parms.frame_type == TDD) {
      ((DCI0_20MHz_TDD_1_6_t*)UL_dci)->type    = 0;
      ((DCI0_20MHz_TDD_1_6_t*)UL_dci)->rballoc = computeRIV(eNB->frame_parms.N_RB_UL,first_rb,nb_rb);// 12 RBs from position 8
      //      printf("nb_rb %d/%d, rballoc %d (dci %x)\n",nb_rb,eNB->frame_parms.N_RB_UL,((DCI0_20MHz_TDD_1_6_t*)UL_dci)->rballoc,*(uint32_t *)UL_dci);
      ((DCI0_20MHz_TDD_1_6_t*)UL_dci)->mcs     = mcs;
      ((DCI0_20MHz_TDD_1_6_t*)UL_dci)->ndi     = ndi;
      ((DCI0_20MHz_TDD_1_6_t*)UL_dci)->TPC     = 0;
      ((DCI0_20MHz_TDD_1_6_t*)UL_dci)->cqi_req = cqi_flag&1;
      ((DCI0_20MHz_TDD_1_6_t*)UL_dci)->cshift  = 0;
      ((DCI0_20MHz_TDD_1_6_t*)UL_dci)->dai     = 1;
    } else {
      ((DCI0_20MHz_FDD_t*)UL_dci)->type    = 0;
      ((DCI0_20MHz_FDD_t*)UL_dci)->rballoc = computeRIV(eNB->frame_parms.N_RB_UL,first_rb,nb_rb);// 12 RBs from position 8
      //   printf("nb_rb %d/%d, rballoc %d (dci %x) (UL_dci %p)\n",nb_rb,eNB->frame_parms.N_RB_UL,((DCI0_20MHz_FDD_t*)UL_dci)->rballoc,*(uint32_t *)UL_dci,(void*)UL_dci);
      ((DCI0_20MHz_FDD_t*)UL_dci)->mcs     = mcs;
      ((DCI0_20MHz_FDD_t*)UL_dci)->ndi     = ndi;
      ((DCI0_20MHz_FDD_t*)UL_dci)->TPC     = 0;
      ((DCI0_20MHz_FDD_t*)UL_dci)->cqi_req = cqi_flag&1;
      ((DCI0_20MHz_FDD_t*)UL_dci)->cshift  = 0;
    }

    break;

  default:
    break;
  }

}

167 168
extern void eNB_fep_full(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc);
extern void eNB_fep_full_2thread(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc);
169

170 171
int main(int argc, char **argv)
{
172 173 174 175 176 177

  char c;
  int i,j,aa,u;

  int aarx,aatx;
  double channelx,channely;
178
  double sigma2, sigma2_dB=10,SNR,SNR2=0,snr0=-2.0,snr1,SNRmeas,rate,saving_bler=0;
knopp's avatar
knopp committed
179
  double input_snr_step=.2,snr_int=30;
180 181 182 183 184
  double blerr;

  int **txdata;

  LTE_DL_FRAME_PARMS *frame_parms;
185 186 187 188 189 190
  double s_re0[30720],s_im0[30720],r_re0[30720],r_im0[30720];
  double s_re1[30720],s_im1[30720],r_re1[30720],r_im1[30720];
  double *s_re[2]={s_re0,s_re1};
  double *s_im[2]={s_im0,s_im1};
  double *r_re[2]={r_re0,r_re1};
  double *r_im[2]={r_im0,r_im1};
191 192
  double forgetting_factor=0.0; //in [0,1] 0 means a new channel every time, 1 means keep the same channel
  double iqim=0.0;
193
  uint8_t extended_prefix_flag=0;
194 195 196 197 198 199
  int cqi_flag=0,cqi_error,cqi_errors,ack_errors,cqi_crc_falsepositives,cqi_crc_falsenegatives;
  int ch_realization;
  int eNB_id = 0;
  int chMod = 0 ;
  int UE_id = 0;
  unsigned char nb_rb=25,first_rb=0,mcs=0,round=0,bundling_flag=1;
200
  //unsigned char l;
201 202 203 204 205 206 207 208 209 210

  unsigned char awgn_flag = 0 ;
  SCM_t channel_model=Rice1;


  unsigned char *input_buffer,harq_pid;
  unsigned short input_buffer_length;
  unsigned int ret;
  unsigned int coded_bits_per_codeword,nsymb;
  int subframe=3;
211
  unsigned int tx_lev=0,tx_lev_dB,trials,errs[4]= {0,0,0,0},round_trials[4]= {0,0,0,0};
212
  uint8_t transmission_mode=1,n_rx=1;
213

214
  FILE *bler_fd=NULL;
215
  char bler_fname[512];
216

217 218
  FILE *time_meas_fd=NULL;
  char time_meas_fname[256];
219

220 221 222
  FILE *input_fdUL=NULL,*trch_out_fdUL=NULL;
  //  unsigned char input_file=0;
  char input_val_str[50],input_val_str2[50];
223

224
  //  FILE *rx_frame_file;
225
  FILE *csv_fdUL=NULL;
226

227
  /*
228
  FILE *fperen=NULL;
229 230
  char fperen_name[512];

231
  FILE *fmageren=NULL;
232
  char fmageren_name[512];
233

234
  FILE *flogeren=NULL;
235
  char flogeren_name[512];
236
  */
237 238 239 240

  /* FILE *ftxlev;
     char ftxlev_name[512];
  */
241

242 243 244
  char csv_fname[512];
  int n_frames=5000;
  int n_ch_rlz = 1;
245 246
  int abstx = 0;
  int hold_channel=0;
247 248
  channel_desc_t *UE2eNB;

249
  //uint8_t control_only_flag = 0;
250 251
  int delay = 0;
  double maxDoppler = 0.0;
252
  uint8_t srs_flag = 0;
253

254
  uint8_t N_RB_DL=25,osf=1;
255

256
  //uint8_t cyclic_shift = 0;
257 258 259
  uint8_t cooperation_flag = 0; //0 no cooperation, 1 delay diversity, 2 Alamouti
  uint8_t beta_ACK=0,beta_RI=0,beta_CQI=2;
  uint8_t tdd_config=3,frame_type=FDD;
260

261
  uint8_t N0=30;
262 263 264 265 266 267 268
  double tx_gain=1.0;
  double cpu_freq_GHz;
  int avg_iter,iter_trials;

  uint32_t UL_alloc_pdu;
  int s,Kr,Kr_bytes;
  int dump_perf=0;
269
  int test_perf=0;
270 271
  int dump_table =0;

272 273
  double effective_rate=0.0;
  char channel_model_input[10];
274

275
  uint8_t max_turbo_iterations=4;
276
  uint8_t parallel_flag=0;
277
  int nb_rb_set = 0;
278
  int sf;
279

280
  int threequarter_fs=0;
281 282
  int ndi;

knopp's avatar
knopp committed
283 284
  opp_enabled=1; // to enable the time meas

285
  cpu_freq_GHz = (double)get_cpu_freq_GHz();
286
  cpuf = cpu_freq_GHz;
287 288 289 290

  printf("Detected cpu_freq %f GHz\n",cpu_freq_GHz);

  logInit();
Calisson's avatar
Calisson committed
291 292 293 294 295
  /*
  // enable these lines if you need debug info
  // however itti will catch all signals, so ctrl-c won't work anymore
  // alternatively you can disable ITTI completely in CMakeLists.txt
  itti_init(TASK_MAX, THREAD_MAX, MESSAGES_ID_MAX, tasks_info, messages_info, messages_definition_xml, NULL);
296
  set_comp_log(PHY,LOG_DEBUG,LOG_MED,1);
Calisson's avatar
Calisson committed
297 298
  set_glog(LOG_DEBUG,LOG_MED);
  */
299

300
  while ((c = getopt (argc, argv, "hapZEbm:n:Y:X:x:s:w:e:q:d:D:O:c:r:i:f:y:c:oA:C:R:g:N:l:S:T:QB:PI:LF")) != -1) {
301 302 303 304 305
    switch (c) {
    case 'a':
      channel_model = AWGN;
      chMod = 1;
      break;
306

307 308 309
    case 'b':
      bundling_flag = 0;
      break;
310

311 312 313
    case 'd':
      delay = atoi(optarg);
      break;
314

315 316 317
    case 'D':
      maxDoppler = atoi(optarg);
      break;
318

319 320 321
    case 'm':
      mcs = atoi(optarg);
      break;
322

323 324 325
    case 'n':
      n_frames = atoi(optarg);
      break;
326

327 328
    case 'Y':
      n_ch_rlz = atoi(optarg);
329 330
      break;

331 332
    case 'X':
      abstx= atoi(optarg);
333 334
      break;

335
    case 'g':
336
      sprintf(channel_model_input,optarg,10);
337

338
      switch((char)*optarg) {
339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373
      case 'A':
        channel_model=SCM_A;
        chMod = 2;
        break;

      case 'B':
        channel_model=SCM_B;
        chMod = 3;
        break;

      case 'C':
        channel_model=SCM_C;
        chMod = 4;
        break;

      case 'D':
        channel_model=SCM_D;
        chMod = 5;
        break;

      case 'E':
        channel_model=EPA;
        chMod = 6;
        break;

      case 'F':
        channel_model=EVA;
        chMod = 7;
        break;

      case 'G':
        channel_model=ETU;
        chMod = 8;
        break;

374
      case 'H':
375 376 377 378
        channel_model=Rayleigh8;
        chMod = 9;
        break;

379
      case 'I':
380 381 382 383
        channel_model=Rayleigh1;
        chMod = 10;
        break;

384
      case 'J':
385 386 387 388
        channel_model=Rayleigh1_corr;
        chMod = 11;
        break;

389
      case 'K':
390 391 392 393
        channel_model=Rayleigh1_anticorr;
        chMod = 12;
        break;

394
      case 'L':
395 396 397 398
        channel_model=Rice8;
        chMod = 13;
        break;

399
      case 'M':
400 401 402 403
        channel_model=Rice1;
        chMod = 14;
        break;

404
      case 'N':
405 406 407 408
        channel_model=AWGN;
        chMod = 1;
        break;

409
      default:
410
        printf("Unsupported channel model!\n");
411 412
        exit(-1);
        break;
413
      }
414

415
      break;
416

417
    case 's':
knopp's avatar
knopp committed
418 419
      snr0 = atof(optarg);
      break;
420

knopp's avatar
knopp committed
421 422 423
    case 'w':
      snr_int = atof(optarg);
      break;
424

knopp's avatar
knopp committed
425 426
    case 'e':
      input_snr_step= atof(optarg);
427
      break;
428

429 430
    case 'x':
      transmission_mode=atoi(optarg);
431

432
      if ((transmission_mode!=1) &&
433
          (transmission_mode!=2)) {
434
        printf("Unsupported transmission mode %d\n",transmission_mode);
435
        exit(-1);
436
      }
437

438
      break;
439

440 441 442
    case 'y':
      n_rx = atoi(optarg);
      break;
443

444 445 446
    case 'S':
      subframe = atoi(optarg);
      break;
447

448 449 450 451
    case 'T':
      tdd_config=atoi(optarg);
      frame_type=TDD;
      break;
452

453 454 455
    case 'p':
      extended_prefix_flag=1;
      break;
456

457 458
    case 'r':
      nb_rb = atoi(optarg);
459
      nb_rb_set = 1;
460
      break;
461

462 463 464
    case 'f':
      first_rb = atoi(optarg);
      break;
465

466 467 468
    //case 'c':
    //  cyclic_shift = atoi(optarg);
    //  break;
469

470 471 472 473
    case 'E':
      threequarter_fs=1;
      break;

474 475 476
    case 'N':
      N0 = atoi(optarg);
      break;
477

478 479 480 481 482 483
    case 'o':
      srs_flag = 1;
      break;

    case 'i':
      input_fdUL = fopen(optarg,"r");
484
      printf("Reading in %s (%p)\n",optarg,input_fdUL);
485

486
      if (input_fdUL == (FILE*)NULL) {
487
        printf("Unknown file %s\n",optarg);
488
        exit(-1);
489
      }
490

491 492
      //      input_file=1;
      break;
493

494 495
    case 'A':
      beta_ACK = atoi(optarg);
496

497
      if (beta_ACK>15) {
498 499
        printf("beta_ack must be in (0..15)\n");
        exit(-1);
500
      }
501

502
      break;
503

504 505
    case 'C':
      beta_CQI = atoi(optarg);
506

507
      if ((beta_CQI>15)||(beta_CQI<2)) {
508 509
        printf("beta_cqi must be in (2..15)\n");
        exit(-1);
510
      }
511

512
      break;
513

514 515
    case 'R':
      beta_RI = atoi(optarg);
516

517
      if ((beta_RI>15)||(beta_RI<2)) {
518 519
        printf("beta_ri must be in (0..13)\n");
        exit(-1);
520
      }
521

522
      break;
523

524 525 526
    case 'Q':
      cqi_flag=1;
      break;
527

528 529 530
    case 'B':
      N_RB_DL=atoi(optarg);
      break;
531

532 533
    case 'P':
      dump_perf=1;
534
      opp_enabled=1;
535
      break;
536

537 538 539 540
    case 'O':
      test_perf=atoi(optarg);
      //print_perf =1;
      break;
541

542
    case 'L':
543
      parallel_flag=1;
544
      break;
545

546 547 548
    case 'I':
      max_turbo_iterations=atoi(optarg);
      break;
549

550 551 552 553
    case 'F':
      xforms=1;
      break;

554 555 556
    case 'Z':
      dump_table = 1;
      break;
557

558 559
    case 'h':
    default:
560 561 562
      /* option "-c cyclic_shift" is not used, let's remove from documentation */
      //printf("%s -h(elp) -a(wgn on) -m mcs -n n_frames -s snr0 -t delay_spread -p (extended prefix on) -r nb_rb -f first_rb -c cyclic_shift -o (srs on) -g channel_model [A:M] Use 3GPP 25.814 SCM-A/B/C/D('A','B','C','D') or 36-101 EPA('E'), EVA ('F'),ETU('G') models (ignores delay spread and Ricean factor), Rayghleigh8 ('H'), Rayleigh1('I'), Rayleigh1_corr('J'), Rayleigh1_anticorr ('K'), Rice8('L'), Rice1('M'), -d Channel delay, -D maximum Doppler shift \n",
      printf("%s -h(elp) -a(wgn on) -m mcs -n n_frames -s snr0 -t delay_spread -p (extended prefix on) -r nb_rb -f first_rb -o (srs on) -g channel_model [A:M] Use 3GPP 25.814 SCM-A/B/C/D('A','B','C','D') or 36-101 EPA('E'), EVA ('F'),ETU('G') models (ignores delay spread and Ricean factor), Rayghleigh8 ('H'), Rayleigh1('I'), Rayleigh1_corr('J'), Rayleigh1_anticorr ('K'), Rice8('L'), Rice1('M'), -d Channel delay, -D maximum Doppler shift \n",
563
             argv[0]);
564 565 566 567
      exit(1);
      break;
    }
  }
568

569
  lte_param_init(1,
Xiwen JIANG's avatar
Xiwen JIANG committed
570
                 1, 
571 572 573 574 575 576 577
		 n_rx,
		 1,
		 extended_prefix_flag,
		 frame_type,
		 0,
		 tdd_config,
		 N_RB_DL,
578
		 threequarter_fs,
579 580
		 osf,
		 0);
581

Calisson's avatar
Calisson committed
582 583 584 585 586
  // for a call to phy_reset_ue later we need PHY_vars_UE_g allocated and pointing to UE
  PHY_vars_UE_g = (PHY_VARS_UE***)malloc(sizeof(PHY_VARS_UE**));
  PHY_vars_UE_g[0] = (PHY_VARS_UE**) malloc(sizeof(PHY_VARS_UE*));
  PHY_vars_UE_g[0][0] = UE;

587
  if (nb_rb_set == 0)
588
    nb_rb = eNB->frame_parms.N_RB_UL;
589

590
  printf("1 . rxdataF_comp[0] %p\n",eNB->pusch_vars[0]->rxdataF_comp[0][0]);
591
  printf("Setting mcs = %d\n",mcs);
592
  printf("n_frames = %d\n", n_frames);
593

knopp's avatar
knopp committed
594
  snr1 = snr0+snr_int;
595 596
  printf("SNR0 %f, SNR1 %f\n",snr0,snr1);

597
  frame_parms = &eNB->frame_parms;
598

599
  txdata = UE->common_vars.txdata;
600

601
  nsymb = (eNB->frame_parms.Ncp == NORMAL) ? 14 : 12;
602 603


604
  sprintf(bler_fname,"ULbler_mcs%d_nrb%d_ChannelModel%d_nsim%d.csv",mcs,nb_rb,chMod,n_frames);
605
  bler_fd = fopen(bler_fname,"w");
606 607 608 609
  if (bler_fd==NULL) {
    fprintf(stderr,"Problem creating file %s\n",bler_fname);
    exit(-1);
  }
610

611
  fprintf(bler_fd,"#SNR;mcs;nb_rb;TBS;rate;errors[0];trials[0];errors[1];trials[1];errors[2];trials[2];errors[3];trials[3]\n");
612 613

  if (test_perf != 0) {
614 615 616 617
    char hostname[1024];
    hostname[1023] = '\0';
    gethostname(hostname, 1023);
    printf("Hostname: %s\n", hostname);
618 619 620 621
    //char dirname[FILENAME_MAX];
    //sprintf(dirname, "%s//SIMU/USER/pre-ci-logs-%s", getenv("OPENAIR_TARGETS"),hostname);
    //mkdir(dirname, 0777);
    sprintf(time_meas_fname,"time_meas_prb%d_mcs%d_antrx%d_channel%s_tx%d.csv",
622
            N_RB_DL,mcs,n_rx,channel_model_input,transmission_mode);
623
    time_meas_fd = fopen(time_meas_fname,"w");
624 625 626 627
    if (time_meas_fd==NULL) {
      fprintf(stderr,"Cannot create file %s!\n",time_meas_fname);
      exit(-1);
    }
628
  }
629 630 631

  if(abstx) {
    // CSV file
632 633
    sprintf(csv_fname,"EULdataout_tx%d_mcs%d_nbrb%d_chan%d_nsimus%d_eren.m",transmission_mode,mcs,nb_rb,chMod,n_frames);
    csv_fdUL = fopen(csv_fname,"w");
634 635 636 637
    if (csv_fdUL == NULL) {
      fprintf(stderr,"Problem opening file %s\n",csv_fname);
      exit(-1);
    }
638 639
    fprintf(csv_fdUL,"data_all%d=[",mcs);
  }
640

641

642 643 644 645 646 647
  if (xforms==1) {
    fl_initialize (&argc, argv, NULL, 0, 0);
    form_enb = create_lte_phy_scope_enb();
    sprintf (title, "LTE PHY SCOPE eNB");
    fl_show_form (form_enb->lte_phy_scope_enb, FL_PLACE_HOTSPOT, FL_FULLBORDER, title);
  }
648

Bilel's avatar
Bilel committed
649
  UE->pdcch_vars[0][0]->crnti = 14;
650

651
  UE->frame_parms.soundingrs_ul_config_common.enabled_flag = srs_flag;
652
  UE->frame_parms.soundingrs_ul_config_common.srs_BandwidthConfig = 2;
653 654 655 656
  UE->frame_parms.soundingrs_ul_config_common.srs_SubframeConfig = 3;
  UE->soundingrs_ul_config_dedicated[eNB_id].srsConfigDedicatedSetup = srs_flag;
  UE->soundingrs_ul_config_dedicated[eNB_id].duration = 1;
  UE->soundingrs_ul_config_dedicated[eNB_id].srs_ConfigIndex = 2;
657 658 659
  UE->soundingrs_ul_config_dedicated[eNB_id].srs_Bandwidth = 0;
  UE->soundingrs_ul_config_dedicated[eNB_id].transmissionComb = 0;
  UE->soundingrs_ul_config_dedicated[eNB_id].freqDomainPosition = 0;
660
  UE->soundingrs_ul_config_dedicated[eNB_id].cyclicShift = 0;
661

662
  eNB->frame_parms.soundingrs_ul_config_common.enabled_flag = srs_flag;
663
  eNB->frame_parms.soundingrs_ul_config_common.srs_BandwidthConfig = 2;
664 665 666 667
  eNB->frame_parms.soundingrs_ul_config_common.srs_SubframeConfig = 3;
  eNB->soundingrs_ul_config_dedicated[UE_id].srsConfigDedicatedSetup = srs_flag;
  eNB->soundingrs_ul_config_dedicated[UE_id].duration = 1;
  eNB->soundingrs_ul_config_dedicated[UE_id].srs_ConfigIndex = 2;
668 669 670
  eNB->soundingrs_ul_config_dedicated[UE_id].srs_Bandwidth = 0;
  eNB->soundingrs_ul_config_dedicated[UE_id].transmissionComb = 0;
  eNB->soundingrs_ul_config_dedicated[UE_id].freqDomainPosition = 0;
671 672
  eNB->soundingrs_ul_config_dedicated[UE_id].cyclicShift = 0;

673
  eNB->cooperation_flag = cooperation_flag;
674

675 676 677 678 679 680
  eNB->pusch_config_dedicated[UE_id].betaOffset_ACK_Index = beta_ACK;
  eNB->pusch_config_dedicated[UE_id].betaOffset_RI_Index  = beta_RI;
  eNB->pusch_config_dedicated[UE_id].betaOffset_CQI_Index = beta_CQI;
  UE->pusch_config_dedicated[eNB_id].betaOffset_ACK_Index = beta_ACK;
  UE->pusch_config_dedicated[eNB_id].betaOffset_RI_Index  = beta_RI;
  UE->pusch_config_dedicated[eNB_id].betaOffset_CQI_Index = beta_CQI;
Florian Kaltenberger's avatar
Florian Kaltenberger committed
681

682
  UE->ul_power_control_dedicated[eNB_id].deltaMCS_Enabled = 1;
683

684 685 686 687 688
  // disable periodic cqi/ri reporting
  UE->cqi_report_config[eNB_id].CQI_ReportPeriodic.ri_ConfigIndex = -1;
  UE->cqi_report_config[eNB_id].CQI_ReportPeriodic.cqi_PMI_ConfigIndex = -1;


689 690
  printf("PUSCH Beta : ACK %f, RI %f, CQI %f\n",(double)beta_ack[beta_ACK]/8,(double)beta_ri[beta_RI]/8,(double)beta_cqi[beta_CQI]/8);

691 692
  UE2eNB = new_channel_desc_scm(eNB->frame_parms.nb_antennas_tx,
                                UE->frame_parms.nb_antennas_rx,
693
                                channel_model,
694 695
				N_RB2sampling_rate(eNB->frame_parms.N_RB_UL),
				N_RB2channel_bandwidth(eNB->frame_parms.N_RB_UL),
696 697 698 699 700 701 702
                                forgetting_factor,
                                delay,
                                0);
  // set Doppler
  UE2eNB->max_Doppler = maxDoppler;

  // NN: N_RB_UL has to be defined in ulsim
703 704
  eNB->ulsch[0] = new_eNB_ulsch(max_turbo_iterations,N_RB_DL,0);
  UE->ulsch[0]   = new_ue_ulsch(N_RB_DL,0);
705

706
  if (parallel_flag == 1) {
707 708
    extern void init_fep_thread(PHY_VARS_eNB *, pthread_attr_t *);
    extern void init_td_thread(PHY_VARS_eNB *, pthread_attr_t *);
709 710 711
    init_fep_thread(eNB,NULL);
    init_td_thread(eNB,NULL);
  }
712
  // Create transport channel structures for 2 transport blocks (MIMO)
713
  for (i=0; i<2; i++) {
714
    eNB->dlsch[0][i] = new_eNB_dlsch(1,8,1827072,N_RB_DL,0,&eNB->frame_parms);
715
    if (!eNB->dlsch[0][i]) {
716 717 718
      printf("Can't get eNB dlsch structures\n");
      exit(-1);
    }
719
    eNB->dlsch[0][i]->rnti = 14;
720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735
  }
  /* allocate memory for both subframes (only one is really used
   * but there is now "copy_harq_proc_struct" which needs both
   * to be valid)
   * TODO: refine this somehow (necessary?)
   */
  for (sf = 0; sf < 2; sf++) {
    for (i=0; i<2; i++) {
      UE->dlsch[sf][0][i]  = new_ue_dlsch(1,8,1827072,MAX_TURBO_ITERATIONS,N_RB_DL,0);
      if (!UE->dlsch[sf][0][i]) {
        printf("Can't get ue dlsch structures\n");
        exit(-1);
      }
      UE->dlsch[sf][0][i]->rnti   = 14;
    }
  }
736

737 738
  UE->dlsch_SI[0]  = new_ue_dlsch(1,1,1827072,MAX_TURBO_ITERATIONS,N_RB_DL,0);
  UE->dlsch_ra[0]  = new_ue_dlsch(1,1,1827072,MAX_TURBO_ITERATIONS,N_RB_DL,0);
739

740 741 742 743 744 745 746 747 748 749 750
  UE->measurements.rank[0] = 0;
  UE->transmission_mode[0] = 2;
  UE->pucch_config_dedicated[0].tdd_AckNackFeedbackMode = bundling_flag == 1 ? bundling : multiplexing;
  eNB->transmission_mode[0] = 2;
  eNB->pucch_config_dedicated[0].tdd_AckNackFeedbackMode = bundling_flag == 1 ? bundling : multiplexing;
  UE->frame_parms.pusch_config_common.ul_ReferenceSignalsPUSCH.groupHoppingEnabled = 1;
  eNB->frame_parms.pusch_config_common.ul_ReferenceSignalsPUSCH.groupHoppingEnabled = 1;
  UE->frame_parms.pusch_config_common.ul_ReferenceSignalsPUSCH.sequenceHoppingEnabled = 0;
  eNB->frame_parms.pusch_config_common.ul_ReferenceSignalsPUSCH.sequenceHoppingEnabled = 0;
  UE->frame_parms.pusch_config_common.ul_ReferenceSignalsPUSCH.groupAssignmentPUSCH = 0;
  eNB->frame_parms.pusch_config_common.ul_ReferenceSignalsPUSCH.groupAssignmentPUSCH = 0;
751 752


753
  UE->mac_enabled=0;
754
  
755 756
  eNB_rxtx_proc_t *proc_rxtx   = &eNB->proc.proc_rxtx[subframe&1];
  UE_rxtx_proc_t *proc_rxtx_ue = &UE->proc.proc_rxtx[subframe&1];
757 758
  proc_rxtx->frame_rx=1;
  proc_rxtx->subframe_rx=subframe;
759

760 761
  proc_rxtx->frame_tx=pdcch_alloc2ul_frame(&eNB->frame_parms,1,subframe);
  proc_rxtx->subframe_tx=pdcch_alloc2ul_subframe(&eNB->frame_parms,subframe);
762

763 764 765 766
  proc_rxtx_ue->frame_tx = proc_rxtx->frame_rx;
  proc_rxtx_ue->frame_rx = proc_rxtx->frame_tx;
  proc_rxtx_ue->subframe_tx = proc_rxtx->subframe_rx;
  proc_rxtx_ue->subframe_rx = proc_rxtx->subframe_tx;
knopp's avatar
knopp committed
767

768
  printf("Init UL hopping UE\n");
769
  init_ul_hopping(&UE->frame_parms);
770
  printf("Init UL hopping eNB\n");
771
  init_ul_hopping(&eNB->frame_parms);
772 773


774
  UE->dlsch[subframe&1][0][0]->harq_ack[ul_subframe2pdcch_alloc_subframe(&eNB->frame_parms,subframe)].send_harq_status = 1;
775

776 777
  UE->ulsch_Msg3_active[eNB_id] = 0;
  UE->ul_power_control_dedicated[eNB_id].accumulationEnabled=1;
778
  /*
779
  generate_ue_ulsch_params_from_dci((void *)&UL_alloc_pdu,
780
                                    14,
781
                                    proc_rxtx->subframe_tx,
782
                                    format0,
783
                                    UE,
784
				    proc_rxtx_ue,
785 786 787 788 789 790
                                    SI_RNTI,
                                    0,
                                    P_RNTI,
                                    CBA_RNTI,
                                    0,
                                    srs_flag);
791 792 793

  //  printf("RIV %d\n",UL_alloc_pdu.rballoc);

794
  generate_eNB_ulsch_params_from_dci(eNB,proc_rxtx,
795
				     (void *)&UL_alloc_pdu,
796 797 798
                                     14,
                                     format0,
                                     0,
799
				     SI_RNTI,
800 801 802 803
                                     0,
                                     P_RNTI,
                                     CBA_RNTI,
                                     srs_flag);
804
  */
805

806 807
  coded_bits_per_codeword = nb_rb * (12 * get_Qm_ul(mcs)) * nsymb;

808
  if (cqi_flag == 1) coded_bits_per_codeword-=UE->ulsch[0]->O;
809 810 811 812

  rate = (double)dlsch_tbs25[get_I_TBS(mcs)][nb_rb-1]/(coded_bits_per_codeword);

  printf("Rate = %f (mod %d), coded bits %d\n",rate,get_Qm_ul(mcs),coded_bits_per_codeword);
813 814


815 816 817

  for (ch_realization=0; ch_realization<n_ch_rlz; ch_realization++) {

818 819 820 821 822 823
    /*
      if(abstx){
      int ulchestim_f[300*12];
      int ulchestim_t[2*(frame_parms->ofdm_symbol_size)];
      }
    */
824 825

    if(abstx) {
826 827 828
      printf("**********************Channel Realization Index = %d **************************\n", ch_realization);
      saving_bler=1;
    }
829

830

knopp's avatar
knopp committed
831
    //    if ((subframe>5) || (subframe < 4))
832
    //      UE->frame++;
833 834

    for (SNR=snr0; SNR<snr1; SNR+=input_snr_step) {
835 836 837 838 839 840 841 842 843 844 845 846 847
      errs[0]=0;
      errs[1]=0;
      errs[2]=0;
      errs[3]=0;
      round_trials[0] = 0;
      round_trials[1] = 0;
      round_trials[2] = 0;
      round_trials[3] = 0;
      cqi_errors=0;
      ack_errors=0;
      cqi_crc_falsepositives=0;
      cqi_crc_falsenegatives=0;
      round=0;
848

849 850
      //randominit(0);

knopp's avatar
knopp committed
851

852
      harq_pid = subframe2harq_pid(&UE->frame_parms,proc_rxtx_ue->frame_tx,subframe);
853
      input_buffer_length = UE->ulsch[0]->harq_processes[harq_pid]->TBS/8;
854
      input_buffer = (unsigned char *)memalign(32,input_buffer_length+64);
855
      //      printf("UL frame %d/subframe %d, harq_pid %d\n",UE->frame,subframe,harq_pid);
856
      if (input_fdUL == NULL) {
857

858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878

        if (n_frames == 1) {
          trch_out_fdUL= fopen("ulsch_trchUL.txt","w");

          for (i=0; i<input_buffer_length; i++) {
            input_buffer[i] = taus()&0xff;

            for (j=0; j<8; j++)
              fprintf(trch_out_fdUL,"%d\n",(input_buffer[i]>>(7-j))&1);
          }

          fclose(trch_out_fdUL);
        } else {
          for (i=0; i<input_buffer_length; i++)
            input_buffer[i] = taus()&0xff;
        }
      } else {
        n_frames=1;
        i=0;

        while (!feof(input_fdUL)) {
879
          ret=fscanf(input_fdUL,"%s %s",input_val_str,input_val_str2);//&input_val1,&input_val2);
880
          if (ret != 2) printf("ERROR: error reading file\n");
881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902

          if ((i%4)==0) {
            ((short*)txdata[0])[i/2] = (short)((1<<15)*strtod(input_val_str,NULL));
            ((short*)txdata[0])[(i/2)+1] = (short)((1<<15)*strtod(input_val_str2,NULL));

            if ((i/4)<100)
              printf("sample %d => %e + j%e (%d +j%d)\n",i/4,strtod(input_val_str,NULL),strtod(input_val_str2,NULL),((short*)txdata[0])[i/4],((short*)txdata[0])[(i/4)+1]);//1,input_val2,);
          }

          i++;

          if (i>(FRAME_LENGTH_SAMPLES))
            break;
        }

        printf("Read in %d samples\n",i/4);
        //      write_output("txsig0UL.m","txs0", txdata[0],2*frame_parms->samples_per_tti,1,1);
        //    write_output("txsig1.m","txs1", txdata[1],FRAME_LENGTH_COMPLEX_SAMPLES,1,1);
        tx_lev = signal_energy(&txdata[0][0],
                               OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES);
        tx_lev_dB = (unsigned int) dB_fixed(tx_lev);

903 904
      }

905 906
      avg_iter = 0;
      iter_trials=0;
907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933
      reset_meas(&UE->phy_proc_tx);
      reset_meas(&UE->ofdm_mod_stats);
      reset_meas(&UE->ulsch_modulation_stats);
      reset_meas(&UE->ulsch_encoding_stats);
      reset_meas(&UE->ulsch_interleaving_stats);
      reset_meas(&UE->ulsch_rate_matching_stats);
      reset_meas(&UE->ulsch_turbo_encoding_stats);
      reset_meas(&UE->ulsch_segmentation_stats);
      reset_meas(&UE->ulsch_multiplexing_stats);

      reset_meas(&eNB->phy_proc_rx);
      reset_meas(&eNB->ofdm_demod_stats);
      reset_meas(&eNB->ulsch_channel_estimation_stats);
      reset_meas(&eNB->ulsch_freq_offset_estimation_stats);
      reset_meas(&eNB->rx_dft_stats);
      reset_meas(&eNB->ulsch_decoding_stats);
      reset_meas(&eNB->ulsch_turbo_decoding_stats);
      reset_meas(&eNB->ulsch_deinterleaving_stats);
      reset_meas(&eNB->ulsch_demultiplexing_stats);
      reset_meas(&eNB->ulsch_rate_unmatching_stats);
      reset_meas(&eNB->ulsch_tc_init_stats);
      reset_meas(&eNB->ulsch_tc_alpha_stats);
      reset_meas(&eNB->ulsch_tc_beta_stats);
      reset_meas(&eNB->ulsch_tc_gamma_stats);
      reset_meas(&eNB->ulsch_tc_ext_stats);
      reset_meas(&eNB->ulsch_tc_intl1_stats);
      reset_meas(&eNB->ulsch_tc_intl2_stats);
934

935
      // initialization 
936 937
      struct list time_vector_tx;
      initialize(&time_vector_tx);
938 939 940 941 942 943 944
      struct list time_vector_tx_ifft;
      initialize(&time_vector_tx_ifft);
      struct list time_vector_tx_mod;
      initialize(&time_vector_tx_mod);
      struct list time_vector_tx_enc;
      initialize(&time_vector_tx_enc);

945 946
      struct list time_vector_rx;
      initialize(&time_vector_rx);
947 948 949 950 951 952
      struct list time_vector_rx_fft;
      initialize(&time_vector_rx_fft);
      struct list time_vector_rx_demod;
      initialize(&time_vector_rx_demod);
      struct list time_vector_rx_dec;
      initialize(&time_vector_rx_dec);
953

954
      ndi=0;
955

956
      phy_reset_ue(0,0,0);
957 958
      UE->UE_mode[eNB_id]=PUSCH;

959 960
      for (trials = 0; trials<n_frames; trials++) {
        //      printf("*");
961 962
        //        UE->frame++;
        //        eNB->frame++;
963
	ndi = (1-ndi);
964 965 966 967
        fflush(stdout);
        round=0;

        while (round < 4) {
968 969
          eNB->ulsch[0]->harq_processes[harq_pid]->round=round;
          UE->ulsch[0]->harq_processes[harq_pid]->round=round;
970
	  //	  printf("Trial %d : Round %d (subframe %d, frame %d)\n",trials,round,proc_rxtx_ue->subframe_rx,proc_rxtx_ue->frame_rx);
971 972 973
          round_trials[round]++;


974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001
	  fill_ulsch_dci(eNB,(void*)&UL_alloc_pdu,first_rb,nb_rb,mcs,ndi,cqi_flag);

	  UE->ulsch_Msg3_active[eNB_id] = 0;
	  UE->ul_power_control_dedicated[eNB_id].accumulationEnabled=1;
	  generate_ue_ulsch_params_from_dci((void *)&UL_alloc_pdu,
					    14,
					    proc_rxtx->subframe_tx,
					    format0,
					    UE,
					    proc_rxtx_ue,
					    SI_RNTI,
					    0,
					    P_RNTI,
					    CBA_RNTI,
					    0,
					    srs_flag);

	  generate_eNB_ulsch_params_from_dci(eNB,proc_rxtx,
					     (void *)&UL_alloc_pdu,
					     14,
					     format0,
					     0,
					     SI_RNTI,
					     0,
					     P_RNTI,
					     CBA_RNTI,
					     srs_flag);
	  eNB->ulsch[0]->harq_processes[harq_pid]->subframe_scheduling_flag = 1;
1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020

          /////////////////////
          if (abstx) {
            if (trials==0 && round==0 && SNR==snr0) { //generate a new channel
              hold_channel = 0;
              flagMag=0;
            } else {
              hold_channel = 1;
              flagMag = 1;
            }
          } else {
            hold_channel = 0;
            flagMag=1;
          }

          ///////////////////////////////////////

          if (input_fdUL == NULL) {

1021 1022 1023 1024 1025 1026
	    eNB->proc.frame_rx = 1;
	    eNB->proc.subframe_rx = subframe;
	    proc_rxtx_ue->frame_tx = proc_rxtx->frame_rx;
	    proc_rxtx_ue->frame_rx = proc_rxtx->frame_tx;
	    proc_rxtx_ue->subframe_tx = proc_rxtx->subframe_rx;
	    proc_rxtx_ue->subframe_rx = proc_rxtx->subframe_tx;
1027

1028
	    phy_procedures_UE_TX(UE,proc_rxtx_ue,0,0,normal_txrx,no_relay);
1029

1030
	    /*
1031
            if (srs_flag)
1032
              generate_srs_tx(UE,0,AMP,subframe);
1033

1034
            generate_drs_pusch(UE,proc_rxtx_ue,0,
1035
                               AMP,subframe,
1036 1037
                               UE->ulsch[0]->harq_processes[harq_pid]->first_rb,
                               UE->ulsch[0]->harq_processes[harq_pid]->nb_rb,
1038 1039 1040
                               0);

            if ((cqi_flag == 1) && (n_frames == 1) ) {
1041 1042 1043
              printf("CQI information (O %d) %d %d\n",UE->ulsch[0]->O,
                     UE->ulsch[0]->o[0],UE->ulsch[0]->o[1]);
              print_CQI(UE->ulsch[0]->o,UE->ulsch[0]->uci_format,UE->frame_parms.N_RB_DL,0);
1044 1045
            }

1046
            UE->ulsch[0]->o_ACK[0] = taus()&1;
1047

1048
            start_meas(&UE->ulsch_encoding_stats);
1049 1050

            if (ulsch_encoding(input_buffer,
1051
                               UE,
1052 1053 1054 1055 1056 1057 1058 1059 1060 1061
                               harq_pid,
                               eNB_id,
                               2, // transmission mode
                               control_only_flag,
                               1// Nbundled
                              )==-1) {
              printf("ulsim.c Problem with ulsch_encoding\n");
              exit(-1);
            }

1062
            stop_meas(&UE->ulsch_encoding_stats);
1063

1064 1065
            start_meas(&UE->ulsch_modulation_stats);
            ulsch_modulation(UE->common_vars.txdataF,AMP,
1066
                             proc_rxtx_ue->frame_tx,subframe,&UE->frame_parms,
1067 1068
                             UE->ulsch[0]);
            stop_meas(&UE->ulsch_modulation_stats);
1069
	    */
1070 1071 1072



1073 1074 1075

	    /*
	    for (aa=0; aa<1; aa++) {
1076
              if (frame_parms->Ncp == EXTENDED)
1077 1078 1079
                PHY_ofdm_mod(&UE->common_vars.txdataF[aa][subframe*nsymb*OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES_NO_PREFIX],        // input
                             &txdata[aa][eNB->frame_parms.samples_per_tti*subframe],         // output
                             UE->frame_parms.ofdm_symbol_size,
1080
                             nsymb,                 // number of symbols
1081
                             UE->frame_parms.nb_prefix_samples,               // number of prefix samples
1082 1083
                             CYCLIC_PREFIX);
              else
1084 1085
                normal_prefix_mod(&UE->common_vars.txdataF[aa][subframe*nsymb*OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES_NO_PREFIX],
                                  &txdata[aa][eNB->frame_parms.samples_per_tti*subframe],
1086 1087 1088 1089
                                  nsymb,
                                  frame_parms);


1090 1091
              apply_7_5_kHz(UE,UE->common_vars.txdata[aa],subframe<<1);
              apply_7_5_kHz(UE,UE->common_vars.txdata[aa],1+(subframe<<1));
1092

1093
*/
1094

1095 1096 1097 1098 1099 1100 1101 1102
	    tx_lev = signal_energy(&UE->common_vars.txdata[0][eNB->frame_parms.samples_per_tti*subframe],
				   eNB->frame_parms.samples_per_tti);
	    
	    
            if (n_frames==1) {
              write_output("txsigF0UL.m","txsF0", &UE->common_vars.txdataF[0][eNB->frame_parms.ofdm_symbol_size*nsymb*subframe],eNB->frame_parms.ofdm_symbol_size*nsymb,1,
                           1);
              //write_output("txsigF1.m","txsF1", UE->common_vars.txdataF[0],FRAME_LENGTH_COMPLEX_SAMPLES_NO_PREFIX,1,1);
1103
            }
1104 1105 1106
	    
	  }  // input_fd == NULL
	  
1107 1108 1109
          tx_lev_dB = (unsigned int) dB_fixed_times10(tx_lev);

          if (n_frames==1) {
1110 1111
            write_output("txsig0UL.m","txs0", &txdata[0][eNB->frame_parms.samples_per_tti*subframe],2*frame_parms->samples_per_tti,1,1);
            //        write_output("txsig1UL.m","txs1", &txdata[1][eNB->frame_parms.samples_per_tti*subframe],2*frame_parms->samples_per_tti,1,1);
1112 1113 1114 1115
          }

          //AWGN
          //Set target wideband RX noise level to N0
1116
          sigma2_dB = N0;//10*log10((double)tx_lev)  +10*log10(UE->frame_parms.ofdm_symbol_size/(UE->frame_parms.N_RB_DL*12)) - SNR;
1117 1118 1119
          sigma2 = pow(10,sigma2_dB/10);

          // compute tx_gain to achieve target SNR (per resource element!)
1120
          tx_gain = sqrt(pow(10.0,.1*(N0+SNR))*(nb_rb*12/(double)UE->frame_parms.ofdm_symbol_size)/(double)tx_lev);
1121

1122 1123

	  if (n_frames==1)
1124 1125 1126 1127 1128
            printf("tx_lev = %d (%d.%d dB,%f), gain %f\n",tx_lev,tx_lev_dB/10,tx_lev_dB,10*log10((double)tx_lev),10*log10(tx_gain));


          // fill measurement symbol (19) with noise
          for (i=0; i<OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES; i++) {
1129
            for (aa=0; aa<eNB->frame_parms.nb_antennas_rx; aa++) {
1130

1131 1132
              ((short*) &eNB->common_vars.rxdata[0][aa][(frame_parms->samples_per_tti<<1) -frame_parms->ofdm_symbol_size])[2*i] = (short) ((sqrt(sigma2/2)*gaussdouble(0.0,1.0)));
              ((short*) &eNB->common_vars.rxdata[0][aa][(frame_parms->samples_per_tti<<1) -frame_parms->ofdm_symbol_size])[2*i+1] = (short) ((sqrt(sigma2/2)*gaussdouble(0.0,1.0)));
1133 1134 1135 1136 1137
            }
          }

          // multipath channel

1138
          for (i=0; i<eNB->frame_parms.samples_per_tti; i++) {
1139
            for (aa=0; aa<1; aa++) {
1140 1141
              s_re[aa][i] = ((double)(((short *)&UE->common_vars.txdata[aa][eNB->frame_parms.samples_per_tti*subframe]))[(i<<1)]);
              s_im[aa][i] = ((double)(((short *)&UE->common_vars.txdata[aa][eNB->frame_parms.samples_per_tti*subframe]))[(i<<1)+1]);
1142 1143 1144 1145 1146 1147
            }
          }

          if (awgn_flag == 0) {
            if (UE2eNB->max_Doppler == 0) {
              multipath_channel(UE2eNB,s_re,s_im,r_re,r_im,
1148
                                eNB->frame_parms.samples_per_tti,hold_channel);
1149 1150
            } else {
              multipath_tv_channel(UE2eNB,s_re,s_im,r_re,r_im,
1151
                                   2*eNB->frame_parms.samples_per_tti,hold_channel);
1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186
            }
          }

          if(abstx) {
            if(saving_bler==0)
              if (trials==0 && round==0) {
                // calculate freq domain representation to compute SINR
                freq_channel(UE2eNB, N_RB_DL,12*N_RB_DL + 1);

                // snr=pow(10.0,.1*SNR);
                fprintf(csv_fdUL,"%f,%d,%d,%f,%f,%f,",SNR,tx_lev,tx_lev_dB,sigma2_dB,tx_gain,SNR2);

                //fprintf(csv_fdUL,"%f,",SNR);
                for (u=0; u<12*nb_rb; u++) {
                  for (aarx=0; aarx<UE2eNB->nb_rx; aarx++) {
                    for (aatx=0; aatx<UE2eNB->nb_tx; aatx++) {
                      // abs_channel = (eNB2UE->chF[aarx+(aatx*eNB2UE->nb_rx)][u].x*eNB2UE->chF[aarx+(aatx*eNB2UE->nb_rx)][u].x + eNB2UE->chF[aarx+(aatx*eNB2UE->nb_rx)][u].y*eNB2UE->chF[aarx+(aatx*eNB2UE->nb_rx)][u].y);
                      channelx = UE2eNB->chF[aarx+(aatx*UE2eNB->nb_rx)][u].x;
                      channely = UE2eNB->chF[aarx+(aatx*UE2eNB->nb_rx)][u].y;
                      // if(transmission_mode==5){
                      fprintf(csv_fdUL,"%e+i*(%e),",channelx,channely);
                      // }
                      // else{
                      //  pilot_sinr = 10*log10(snr*abs_channel);
                      //  fprintf(csv_fd,"%e,",pilot_sinr);
                      // }
                    }
                  }
                }
              }
          }

          if (n_frames==1)
            printf("Sigma2 %f (sigma2_dB %f), tx_gain %f (%f dB)\n",sigma2,sigma2_dB,tx_gain,20*log10(tx_gain));

1187 1188 1189 1190
          for (i=0; i<eNB->frame_parms.samples_per_tti; i++) {
            for (aa=0; aa<eNB->frame_parms.nb_antennas_rx; aa++) {
              ((short*) &eNB->common_vars.rxdata[0][aa][eNB->frame_parms.samples_per_tti*subframe])[2*i] = (short) ((tx_gain*r_re[aa][i]) + sqrt(sigma2/2)*gaussdouble(0.0,1.0));
              ((short*) &eNB->common_vars.rxdata[0][aa][eNB->frame_parms.samples_per_tti*subframe])[2*i+1] = (short) ((tx_gain*r_im[aa][i]) + (iqim*tx_gain*r_re[aa][i]) + sqrt(
1191 1192 1193 1194 1195 1196
                    sigma2/2)*gaussdouble(0.0,1.0));
            }
          }

          if (n_frames==1) {
            printf("rx_level Null symbol %f\n",10*log10((double)signal_energy((int*)
1197 1198
                   &eNB->common_vars.rxdata[0][0][(eNB->frame_parms.samples_per_tti<<1) -eNB->frame_parms.ofdm_symbol_size],OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES/2)));
            printf("rx_level data symbol %f\n",10*log10(signal_energy((int*)&eNB->common_vars.rxdata[0][0][160+(eNB->frame_parms.samples_per_tti*subframe)],
1199 1200 1201
                   OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES/2)));
          }

1202
          SNRmeas = 10*log10(((double)signal_energy((int*)&eNB->common_vars.rxdata[0][0][160+(eNB->frame_parms.samples_per_tti*subframe)],
1203
                              OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES/2))/((double)signal_energy((int*)
1204 1205
                                  &eNB->common_vars.rxdata[0][0][(eNB->frame_parms.samples_per_tti<<1) -eNB->frame_parms.ofdm_symbol_size],
                                  OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES/2)) - 1)+10*log10(eNB->frame_parms.N_RB_UL/nb_rb);
1206 1207 1208 1209

          if (n_frames==1) {
            printf("SNRmeas %f\n",SNRmeas);

1210 1211
            //    write_output("rxsig0UL.m","rxs0", &eNB->common_vars.rxdata[0][0][eNB->frame_parms.samples_per_tti*subframe],eNB->frame_parms.samples_per_tti,1,1);
            //write_output("rxsig1UL.m","rxs1", &eNB->common_vars.rxdata[0][0][eNB->frame_parms.samples_per_tti*subframe],eNB->frame_parms.samples_per_tti,1,1);
1212 1213 1214
          }


1215 1216
	  eNB->fep = (parallel_flag == 1) ? eNB_fep_full_2thread        : eNB_fep_full;
	  eNB->td  = (parallel_flag == 1) ? ulsch_decoding_data_2thread : ulsch_decoding_data;
1217
	  eNB->do_prach = NULL;
1218

1219
	  phy_procedures_eNB_common_RX(eNB,proc_rxtx);
1220
	  phy_procedures_eNB_uespec_RX(eNB,proc_rxtx,no_relay);
1221

1222 1223 1224 1225

          if (cqi_flag > 0) {
            cqi_error = 0;

1226
            if (eNB->ulsch[0]->harq_processes[harq_pid]->Or1 < 32) {
1227
              for (i=2; i<4; i++) {
1228 1229
                //                printf("cqi %d : %d (%d)\n",i,eNB->ulsch[0]->o[i],UE->ulsch[0]->o[i]);
                if (eNB->ulsch[0]->harq_processes[harq_pid]->o[i] != UE->ulsch[0]->o[i])
1230 1231 1232 1233 1234 1235 1236 1237 1238
                  cqi_error = 1;
              }
            } else {

            }

            if (cqi_error == 1) {
              cqi_errors++;

1239
              if (eNB->ulsch[0]->harq_processes[harq_pid]->cqi_crc_status == 1)
1240 1241
                cqi_crc_falsepositives++;
            } else {
1242
              if (eNB->ulsch[0]->harq_processes[harq_pid]->cqi_crc_status == 0)
1243 1244 1245 1246
                cqi_crc_falsenegatives++;
            }
          }

1247
          if (eNB->ulsch[0]->harq_processes[harq_pid]->o_ACK[0] != UE->ulsch[0]->o_ACK[0])
1248 1249
            ack_errors++;

1250
          //    printf("ulsch_coding: O[%d] %d\n",i,o_flip[i]);
1251

1252 1253 1254 1255
	  
	  //          if (ret <= eNB->ulsch[0]->max_turbo_iterations) {
	  
	  if (eNB->ulsch[0]->harq_processes[harq_pid]->round == 0) {
1256

1257 1258
	    //  avg_iter += ret;
	    iter_trials++;
1259 1260

            if (n_frames==1) {
knopp's avatar