lte_sync_time.c 18.6 KB
Newer Older
1
2
3
4
5
/*
 * 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
Cedric Roux's avatar
Cedric Roux committed
6
 * the OAI Public License, Version 1.1  (the "License"); you may not use this file
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 * 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
 */
ghaddab's avatar
ghaddab committed
21

22
23
24
/* file: lte_sync_time.c
   purpose: coarse timing synchronization for LTE (using PSS)
   author: florian.kaltenberger@eurecom.fr, oscar.tonelli@yahoo.it
25
   date: 22.10.2009
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
*/

//#include <string.h>
#include "defs.h"
#include "PHY/defs.h"
#include "PHY/extern.h"
#include "SCHED/extern.h"
#include <math.h>

#ifdef OPENAIR2
#include "LAYER2/MAC/defs.h"
#include "LAYER2/MAC/extern.h"
#include "RRC/LITE/extern.h"
#include "PHY_INTERFACE/extern.h"
#endif
//#define DEBUG_PHY

int* sync_corr_ue0 = NULL;
int* sync_corr_ue1 = NULL;
int* sync_corr_ue2 = NULL;
46
47
int sync_tmp[2048*4] __attribute__((aligned(32)));
short syncF_tmp[2048*2] __attribute__((aligned(32)));
48
49
50



51
52
int lte_sync_time_init(LTE_DL_FRAME_PARMS *frame_parms )   // LTE_UE_COMMON *common_vars
{
53
54
55
56
57
58

  int i,k;

  sync_corr_ue0 = (int *)malloc16(LTE_NUMBER_OF_SUBFRAMES_PER_FRAME*sizeof(int)*frame_parms->samples_per_tti);
  sync_corr_ue1 = (int *)malloc16(LTE_NUMBER_OF_SUBFRAMES_PER_FRAME*sizeof(int)*frame_parms->samples_per_tti);
  sync_corr_ue2 = (int *)malloc16(LTE_NUMBER_OF_SUBFRAMES_PER_FRAME*sizeof(int)*frame_parms->samples_per_tti);
59

60
61
  if (sync_corr_ue0) {
#ifdef DEBUG_PHY
62
    LOG_D(PHY,"[openair][LTE_PHY][SYNC] sync_corr_ue allocated at %p\n", sync_corr_ue0);
63
64
#endif
    //common_vars->sync_corr = sync_corr;
65
  } else {
66
    LOG_E(PHY,"[openair][LTE_PHY][SYNC] sync_corr_ue0 not allocated\n");
67
68
69
70
71
    return(-1);
  }

  if (sync_corr_ue1) {
#ifdef DEBUG_PHY
72
    LOG_D(PHY,"[openair][LTE_PHY][SYNC] sync_corr_ue allocated at %p\n", sync_corr_ue1);
73
74
#endif
    //common_vars->sync_corr = sync_corr;
75
  } else {
76
    LOG_E(PHY,"[openair][LTE_PHY][SYNC] sync_corr_ue1 not allocated\n");
77
78
79
80
81
    return(-1);
  }

  if (sync_corr_ue2) {
#ifdef DEBUG_PHY
82
    LOG_D(PHY,"[openair][LTE_PHY][SYNC] sync_corr_ue allocated at %p\n", sync_corr_ue2);
83
84
#endif
    //common_vars->sync_corr = sync_corr;
85
  } else {
86
    LOG_E(PHY,"[openair][LTE_PHY][SYNC] sync_corr_ue2 not allocated\n");
87
88
89
90
    return(-1);
  }

  //  primary_synch0_time = (int *)malloc16((frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples)*sizeof(int));
gauthier's avatar
gauthier committed
91
  primary_synch0_time = (int16_t *)malloc16((frame_parms->ofdm_symbol_size)*sizeof(int16_t)*2);
92

93
94
  if (primary_synch0_time) {
    //    bzero(primary_synch0_time,(frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples)*sizeof(int));
gauthier's avatar
gauthier committed
95
    bzero(primary_synch0_time,(frame_parms->ofdm_symbol_size)*sizeof(int16_t)*2);
96
#ifdef DEBUG_PHY
97
    LOG_D(PHY,"[openair][LTE_PHY][SYNC] primary_synch0_time allocated at %p\n", primary_synch0_time);
98
#endif
99
  } else {
100
    LOG_E(PHY,"[openair][LTE_PHY][SYNC] primary_synch0_time not allocated\n");
101
102
103
104
    return(-1);
  }

  //  primary_synch1_time = (int *)malloc16((frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples)*sizeof(int));
gauthier's avatar
gauthier committed
105
  primary_synch1_time = (int16_t *)malloc16((frame_parms->ofdm_symbol_size)*sizeof(int16_t)*2);
106

107
108
  if (primary_synch1_time) {
    //    bzero(primary_synch1_time,(frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples)*sizeof(int));
gauthier's avatar
gauthier committed
109
    bzero(primary_synch1_time,(frame_parms->ofdm_symbol_size)*sizeof(int16_t)*2);
110
#ifdef DEBUG_PHY
111
    LOG_D(PHY,"[openair][LTE_PHY][SYNC] primary_synch1_time allocated at %p\n", primary_synch1_time);
112
#endif
113
  } else {
114
    LOG_E(PHY,"[openair][LTE_PHY][SYNC] primary_synch1_time not allocated\n");
115
116
117
118
    return(-1);
  }

  //  primary_synch2_time = (int *)malloc16((frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples)*sizeof(int));
gauthier's avatar
gauthier committed
119
  primary_synch2_time = (int16_t *)malloc16((frame_parms->ofdm_symbol_size)*sizeof(int16_t)*2);
120

121
122
  if (primary_synch2_time) {
    //    bzero(primary_synch2_time,(frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples)*sizeof(int));
gauthier's avatar
gauthier committed
123
    bzero(primary_synch2_time,(frame_parms->ofdm_symbol_size)*sizeof(int16_t)*2);
124
#ifdef DEBUG_PHY
125
    LOG_D(PHY,"[openair][LTE_PHY][SYNC] primary_synch2_time allocated at %p\n", primary_synch2_time);
126
#endif
127
  } else {
128
    LOG_E(PHY,"[openair][LTE_PHY][SYNC] primary_synch2_time not allocated\n");
129
130
131
132
133
134
    return(-1);
  }


  // generate oversampled sync_time sequences
  k=frame_parms->ofdm_symbol_size-36;
135

136
137
138
139
  for (i=0; i<72; i++) {
    syncF_tmp[2*k] = primary_synch0[2*i]>>2;  //we need to shift input to avoid overflow in fft
    syncF_tmp[2*k+1] = primary_synch0[2*i+1]>>2;
    k++;
140

141
142
143
144
145
146
    if (k >= frame_parms->ofdm_symbol_size) {
      k++;  // skip DC carrier
      k-=frame_parms->ofdm_symbol_size;
    }
  }

147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
  switch (frame_parms->N_RB_DL) {
  case 6:
    idft128((short*)syncF_tmp,          /// complex input
	   (short*)sync_tmp, /// complex output
	   1);
    break;
  case 25:
    idft512((short*)syncF_tmp,          /// complex input
	   (short*)sync_tmp, /// complex output
	   1);
    break;
  case 50:
    idft1024((short*)syncF_tmp,          /// complex input
	    (short*)sync_tmp, /// complex output
	    1);
    break;
    
  case 75:
    idft1536((short*)syncF_tmp,          /// complex input
166
167
	     (short*)sync_tmp,
	     1); /// complex output
168
169
170
    break;
  case 100:
    idft2048((short*)syncF_tmp,          /// complex input
171
172
	     (short*)sync_tmp, /// complex output
	     1);
173
174
175
176
177
    break;
  default:
    LOG_E(PHY,"Unsupported N_RB_DL %d\n",frame_parms->N_RB_DL);
    break;
  }
178
179

  for (i=0; i<frame_parms->ofdm_symbol_size; i++)
180
    ((int32_t*)primary_synch0_time)[i] = sync_tmp[i];
181
182

  k=frame_parms->ofdm_symbol_size-36;
183

184
185
186
187
  for (i=0; i<72; i++) {
    syncF_tmp[2*k] = primary_synch1[2*i]>>2;  //we need to shift input to avoid overflow in fft
    syncF_tmp[2*k+1] = primary_synch1[2*i+1]>>2;
    k++;
188

189
190
191
192
193
194
    if (k >= frame_parms->ofdm_symbol_size) {
      k++;  // skip DC carrier
      k-=frame_parms->ofdm_symbol_size;
    }
  }

195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
  switch (frame_parms->N_RB_DL) {
  case 6:
    idft128((short*)syncF_tmp,          /// complex input
	   (short*)sync_tmp, /// complex output
	   1);
    break;
  case 25:
    idft512((short*)syncF_tmp,          /// complex input
	   (short*)sync_tmp, /// complex output
	   1);
    break;
  case 50:
    idft1024((short*)syncF_tmp,          /// complex input
	    (short*)sync_tmp, /// complex output
	    1);
    break;
    
  case 75:
    idft1536((short*)syncF_tmp,          /// complex input
214
215
	     (short*)sync_tmp, /// complex output
	     1);
216
217
218
219
220
221
222
223
224
225
    break;
  case 100:
    idft2048((short*)syncF_tmp,          /// complex input
	    (short*)sync_tmp, /// complex output
	    1);
    break;
  default:
    LOG_E(PHY,"Unsupported N_RB_DL %d\n",frame_parms->N_RB_DL);
    break;
  }
226
227

  for (i=0; i<frame_parms->ofdm_symbol_size; i++)
228
    ((int32_t*)primary_synch1_time)[i] = sync_tmp[i];
229
230

  k=frame_parms->ofdm_symbol_size-36;
231

232
233
234
235
  for (i=0; i<72; i++) {
    syncF_tmp[2*k] = primary_synch2[2*i]>>2;  //we need to shift input to avoid overflow in fft
    syncF_tmp[2*k+1] = primary_synch2[2*i+1]>>2;
    k++;
236

237
238
239
240
241
242
    if (k >= frame_parms->ofdm_symbol_size) {
      k++;  // skip DC carrier
      k-=frame_parms->ofdm_symbol_size;
    }
  }

243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
  switch (frame_parms->N_RB_DL) {
  case 6:
    idft128((short*)syncF_tmp,          /// complex input
	   (short*)sync_tmp, /// complex output
	   1);
    break;
  case 25:
    idft512((short*)syncF_tmp,          /// complex input
	   (short*)sync_tmp, /// complex output
	   1);
    break;
  case 50:
    idft1024((short*)syncF_tmp,          /// complex input
	    (short*)sync_tmp, /// complex output
	    1);
    break;
    
  case 75:
    idft1536((short*)syncF_tmp,          /// complex input
262
263
	     (short*)sync_tmp, /// complex output
	     1);
264
265
266
267
268
269
270
271
272
273
    break;
  case 100:
    idft2048((short*)syncF_tmp,          /// complex input
	    (short*)sync_tmp, /// complex output
	    1);
    break;
  default:
    LOG_E(PHY,"Unsupported N_RB_DL %d\n",frame_parms->N_RB_DL);
    break;
  }
274
275

  for (i=0; i<frame_parms->ofdm_symbol_size; i++)
276
    ((int32_t*)primary_synch2_time)[i] = sync_tmp[i];
277
278
279
280
281
282
283
284
285
286
287
288
289




#ifdef DEBUG_PHY
  write_output("primary_sync0.m","psync0",primary_synch0_time,frame_parms->ofdm_symbol_size,1,1);
  write_output("primary_sync1.m","psync1",primary_synch1_time,frame_parms->ofdm_symbol_size,1,1);
  write_output("primary_sync2.m","psync2",primary_synch2_time,frame_parms->ofdm_symbol_size,1,1);
#endif
  return (1);
}


290
291
void lte_sync_time_free(void)
{
292

293

294
  if (sync_corr_ue0) {
295
    LOG_D(PHY,"Freeing sync_corr_ue (%p)...\n",sync_corr_ue0);
296
297
    free(sync_corr_ue0);
  }
298

299
  if (sync_corr_ue1) {
300
    LOG_D(PHY,"Freeing sync_corr_ue (%p)...\n",sync_corr_ue1);
301
302
    free(sync_corr_ue1);
  }
303

304
  if (sync_corr_ue2) {
305
    LOG_D(PHY,"Freeing sync_corr_ue (%p)...\n",sync_corr_ue2);
306
307
    free(sync_corr_ue2);
  }
308

309
  if (primary_synch0_time) {
310
    LOG_D(PHY,"Freeing primary_sync0_time ...\n");
311
312
    free(primary_synch0_time);
  }
313

314
  if (primary_synch1_time) {
315
    LOG_D(PHY,"Freeing primary_sync1_time ...\n");
316
317
    free(primary_synch1_time);
  }
318

319
  if (primary_synch2_time) {
320
    LOG_D(PHY,"Freeing primary_sync2_time ...\n");
321
322
    free(primary_synch2_time);
  }
323

324
325
326
  sync_corr_ue0 = NULL;
  sync_corr_ue1 = NULL;
  sync_corr_ue2 = NULL;
gauthier's avatar
gauthier committed
327
328
329
  primary_synch0_time = NULL;
  primary_synch1_time = NULL;
  primary_synch2_time = NULL;
330
331
}

332
333
static inline int abs32(int x)
{
334
335
336
  return (((int)((short*)&x)[0])*((int)((short*)&x)[0]) + ((int)((short*)&x)[1])*((int)((short*)&x)[1]));
}

337
#ifdef DEBUG_PHY
338
int debug_cnt=0;
339
340
#endif

341
342
#define SHIFT 17

343
int lte_sync_time(int **rxdata, ///rx data in time domain
344
345
346
                  LTE_DL_FRAME_PARMS *frame_parms,
                  int *eNB_id)
{
347
348
349
350
351
352
353
354
355
356
357



  // perform a time domain correlation using the oversampled sync sequence

  unsigned int n, ar, s, peak_pos, peak_val, sync_source;
  int result,result2;
  int sync_out[3] = {0,0,0},sync_out2[3] = {0,0,0};
  int tmp[3] = {0,0,0};
  int length =   LTE_NUMBER_OF_SUBFRAMES_PER_FRAME*frame_parms->samples_per_tti>>1;

358
  //LOG_D(PHY,"[SYNC TIME] Calling sync_time.\n");
359
  if (sync_corr_ue0 == NULL) {
360
    LOG_E(PHY,"[SYNC TIME] sync_corr_ue0 not yet allocated! Exiting.\n");
361
362
    return(-1);
  }
363

364
  if (sync_corr_ue1 == NULL) {
365
    LOG_E(PHY,"[SYNC TIME] sync_corr_ue1 not yet allocated! Exiting.\n");
366
367
    return(-1);
  }
368

369
  if (sync_corr_ue2 == NULL) {
370
    LOG_E(PHY,"[SYNC TIME] sync_corr_ue2 not yet allocated! Exiting.\n");
371
372
373
374
375
376
377
    return(-1);
  }

  peak_val = 0;
  peak_pos = 0;
  sync_source = 0;

378

379
380
381
382
383
384
385
386
  for (n=0; n<length; n+=4) {

    sync_corr_ue0[n] = 0;
    sync_corr_ue0[n+length] = 0;
    sync_corr_ue1[n] = 0;
    sync_corr_ue1[n+length] = 0;
    sync_corr_ue2[n] = 0;
    sync_corr_ue2[n+length] = 0;
387
388

    for (s=0; s<3; s++) {
389
390
391
      sync_out[s]=0;
      sync_out2[s]=0;
    }
392

393
394
395
396
    //    if (n<(length-frame_parms->ofdm_symbol_size-frame_parms->nb_prefix_samples)) {
    if (n<(length-frame_parms->ofdm_symbol_size)) {

      //calculate dot product of primary_synch0_time and rxdata[ar][n] (ar=0..nb_ant_rx) and store the sum in temp[n];
397
398
      for (ar=0; ar<frame_parms->nb_antennas_rx; ar++) {

399
400
        result  = dot_product((short*)primary_synch0_time, (short*) &(rxdata[ar][n]), frame_parms->ofdm_symbol_size, SHIFT);
        result2 = dot_product((short*)primary_synch0_time, (short*) &(rxdata[ar][n+length]), frame_parms->ofdm_symbol_size, SHIFT);
401
402
403
404
405
406
407
408
409

        ((short*)sync_corr_ue0)[2*n] += ((short*) &result)[0];
        ((short*)sync_corr_ue0)[2*n+1] += ((short*) &result)[1];
        ((short*)sync_corr_ue0)[2*(length+n)] += ((short*) &result2)[0];
        ((short*)sync_corr_ue0)[(2*(length+n))+1] += ((short*) &result2)[1];
        ((short*)sync_out)[0] += ((short*) &result)[0];
        ((short*)sync_out)[1] += ((short*) &result)[1];
        ((short*)sync_out2)[0] += ((short*) &result2)[0];
        ((short*)sync_out2)[1] += ((short*) &result2)[1];
410
      }
411
412

      for (ar=0; ar<frame_parms->nb_antennas_rx; ar++) {
413
414
        result = dot_product((short*)primary_synch1_time, (short*) &(rxdata[ar][n]), frame_parms->ofdm_symbol_size, SHIFT);
        result2 = dot_product((short*)primary_synch1_time, (short*) &(rxdata[ar][n+length]), frame_parms->ofdm_symbol_size, SHIFT);
415
416
417
418
419
420
421
422
423
        ((short*)sync_corr_ue1)[2*n] += ((short*) &result)[0];
        ((short*)sync_corr_ue1)[2*n+1] += ((short*) &result)[1];
        ((short*)sync_corr_ue1)[2*(length+n)] += ((short*) &result2)[0];
        ((short*)sync_corr_ue1)[(2*(length+n))+1] += ((short*) &result2)[1];

        ((short*)sync_out)[2] += ((short*) &result)[0];
        ((short*)sync_out)[3] += ((short*) &result)[1];
        ((short*)sync_out2)[2] += ((short*) &result2)[0];
        ((short*)sync_out2)[3] += ((short*) &result2)[1];
424
425
      }

426
427
      for (ar=0; ar<frame_parms->nb_antennas_rx; ar++) {

428
429
        result = dot_product((short*)primary_synch2_time, (short*) &(rxdata[ar][n]), frame_parms->ofdm_symbol_size, SHIFT);
        result2 = dot_product((short*)primary_synch2_time, (short*) &(rxdata[ar][n+length]), frame_parms->ofdm_symbol_size, SHIFT);
430
431
432
433
434
435
436
437
        ((short*)sync_corr_ue2)[2*n] += ((short*) &result)[0];
        ((short*)sync_corr_ue2)[2*n+1] += ((short*) &result)[1];
        ((short*)sync_corr_ue2)[2*(length+n)] += ((short*) &result2)[0];
        ((short*)sync_corr_ue2)[(2*(length+n))+1] += ((short*) &result2)[1];
        ((short*)sync_out)[4] += ((short*) &result)[0];
        ((short*)sync_out)[5] += ((short*) &result)[1];
        ((short*)sync_out2)[4] += ((short*) &result2)[0];
        ((short*)sync_out2)[5] += ((short*) &result2)[1];
438
      }
439

440
    }
441

442
443
444
445
446
447
448
449
450
    // calculate the absolute value of sync_corr[n]

    sync_corr_ue0[n] = abs32(sync_corr_ue0[n]);
    sync_corr_ue0[n+length] = abs32(sync_corr_ue0[n+length]);
    sync_corr_ue1[n] = abs32(sync_corr_ue1[n]);
    sync_corr_ue1[n+length] = abs32(sync_corr_ue1[n+length]);
    sync_corr_ue2[n] = abs32(sync_corr_ue2[n]);
    sync_corr_ue2[n+length] = abs32(sync_corr_ue2[n+length]);

451
    for (s=0; s<3; s++) {
452
      tmp[s] = (abs32(sync_out[s])>>1) + (abs32(sync_out2[s])>>1);
453

454
      if (tmp[s]>peak_val) {
455
456
457
458
459
460
461
462
        peak_val = tmp[s];
        peak_pos = n;
        sync_source = s;
        /*
        printf("s %d: n %d sync_out %d, sync_out2  %d (sync_corr %d,%d), (%d,%d) (%d,%d)\n",s,n,abs32(sync_out[s]),abs32(sync_out2[s]),sync_corr_ue0[n],
               sync_corr_ue0[n+length],((int16_t*)&sync_out[s])[0],((int16_t*)&sync_out[s])[1],((int16_t*)&sync_out2[s])[0],((int16_t*)&sync_out2[s])[1]);
        */
      }
463
464
465
466
    }
  }

  *eNB_id = sync_source;
467

468
  LOG_I(PHY,"[UE] lte_sync_time: Sync source = %d, Peak found at pos %d, val = %d (%d dB)\n",sync_source,peak_pos,peak_val,dB_fixed(peak_val)/2);
469

470

471
#ifdef DEBUG_PHY
472
  if (debug_cnt == 0) {
473
474
475
476
    write_output("sync_corr0_ue.m","synccorr0",sync_corr_ue0,2*length,1,2);
    write_output("sync_corr1_ue.m","synccorr1",sync_corr_ue1,2*length,1,2);
    write_output("sync_corr2_ue.m","synccorr2",sync_corr_ue2,2*length,1,2);
    write_output("rxdata0.m","rxd0",rxdata[0],length<<1,1,1);
477
    //    exit(-1);
478
  } else {
479
480
    debug_cnt++;
  }
481

482

483
484
485
486
487
488
489
490
491
#endif


  return(peak_pos);

}

//#define DEBUG_PHY

gauthier's avatar
gauthier committed
492
int lte_sync_time_eNB(int32_t **rxdata, ///rx data in time domain
493
494
495
496
497
                      LTE_DL_FRAME_PARMS *frame_parms,
                      uint32_t length,
                      uint32_t *peak_val_out,
                      uint32_t *sync_corr_eNB)
{
498
499
500

  // perform a time domain correlation using the oversampled sync sequence

501
502
  unsigned int n, ar, peak_val, peak_pos;
  uint64_t mean_val;
503
504
505
506
  int result;
  short *primary_synch_time;
  int eNB_id = frame_parms->Nid_cell%3;

507
  // LOG_E(PHY,"[SYNC TIME] Calling sync_time_eNB(%p,%p,%d,%d)\n",rxdata,frame_parms,eNB_id,length);
508
  if (sync_corr_eNB == NULL) {
509
    LOG_E(PHY,"[SYNC TIME] sync_corr_eNB not yet allocated! Exiting.\n");
510
511
512
513
514
515
516
    return(-1);
  }

  switch (eNB_id) {
  case 0:
    primary_synch_time = (short*)primary_synch0_time;
    break;
517

518
519
520
  case 1:
    primary_synch_time = (short*)primary_synch1_time;
    break;
521

522
523
524
  case 2:
    primary_synch_time = (short*)primary_synch2_time;
    break;
525

526
  default:
527
    LOG_E(PHY,"[SYNC TIME] Illegal eNB_id!\n");
528
529
530
531
532
533
534
535
536
537
538
539
540
541
    return (-1);
  }

  peak_val = 0;
  peak_pos = 0;
  mean_val = 0;

  for (n=0; n<length; n+=4) {

    sync_corr_eNB[n] = 0;

    if (n<(length-frame_parms->ofdm_symbol_size-frame_parms->nb_prefix_samples)) {

      //calculate dot product of primary_synch0_time and rxdata[ar][n] (ar=0..nb_ant_rx) and store the sum in temp[n];
542
      for (ar=0; ar<frame_parms->nb_antennas_rx; ar++)  {
543

544
        result = dot_product((short*)primary_synch_time, (short*) &(rxdata[ar][n]), frame_parms->ofdm_symbol_size, SHIFT);
545
546
547
        //((short*)sync_corr)[2*n]   += ((short*) &result)[0];
        //((short*)sync_corr)[2*n+1] += ((short*) &result)[1];
        sync_corr_eNB[n] += abs32(result);
548
549
550
551

      }

    }
552

553
554
555
    /*
    if (eNB_id == 2) {
      printf("sync_time_eNB %d : %d,%d (%d)\n",n,sync_corr_eNB[n],mean_val,
556
       peak_val);
557
558
    }
    */
559
    mean_val += sync_corr_eNB[n];
560
561
562
563
564
565
566

    if (sync_corr_eNB[n]>peak_val) {
      peak_val = sync_corr_eNB[n];
      peak_pos = n;
    }
  }

567
568
  mean_val/=length;

569
570
  *peak_val_out = peak_val;

571
  if (peak_val <= (40*(uint32_t)mean_val)) {
572
    LOG_D(PHY,"[SYNC TIME] No peak found (%u,%u,%"PRIu64",%"PRIu64")\n",peak_pos,peak_val,mean_val,40*mean_val);
573
    return(-1);
574
  } else {
575
    LOG_D(PHY,"[SYNC TIME] Peak found at pos %u, val = %u, mean_val = %"PRIu64"\n",peak_pos,peak_val,mean_val);
576
577
578
579
580
581
582
583
584
585
586
    return(peak_pos);
  }

}

#ifdef PHY_ABSTRACTION
#include "SIMULATION/TOOLS/defs.h"
#include "SIMULATION/RF/defs.h"
//extern channel_desc_t *UE2eNB[NUMBER_OF_UE_MAX][NUMBER_OF_eNB_MAX];

int lte_sync_time_eNB_emul(PHY_VARS_eNB *phy_vars_eNB,
587
588
589
                           uint8_t sect_id,
                           int32_t *sync_val)
{
590

gauthier's avatar
gauthier committed
591
  uint8_t UE_id;
knopp's avatar
   
knopp committed
592
  uint8_t CC_id = phy_vars_eNB->CC_id;
593

594
  LOG_E(PHY,"[PHY] EMUL lte_sync_time_eNB_emul eNB %d, sect_id %d\n",phy_vars_eNB->Mod_id,sect_id);
595
  *sync_val = 0;
596
597

  for (UE_id=0; UE_id<NB_UE_INST; UE_id++) {
598
    //LOG_E(PHY,"[PHY] EMUL : eNB %d checking UE %d (PRACH %d) PL %d dB\n",phy_vars_eNB->Mod_id,UE_id,PHY_vars_UE_g[UE_id]->generate_prach,UE2eNB[UE_id][phy_vars_eNB->Mod_id]->path_loss_dB);
knopp's avatar
   
knopp committed
599
    if ((PHY_vars_UE_g[UE_id][CC_id]->generate_prach == 1) && (phy_vars_eNB->Mod_id == (UE_id % NB_eNB_INST))) {
600
601
602
603
      *sync_val = 1;
      return(0);
    }
  }
604

605
606
607
  return(-1);
}
#endif