Merge branch 'l1-sidelink' of https://gitlab.eurecom.fr/matzakos/LTE-D2D into l1-sidelink

openair1/PHY/LTE_ESTIMATION/lte_sync_time.c

@@ -47,13 +47,24 @@ int32_t sync_tmp[2048*4] __attribute__((aligned(32)));
 int16_t syncF_tmp[2048*2] __attribute__((aligned(32)));
 
 
+extern int16_t s6n_kHz_7_5[1920];
+extern int16_t s6e_kHz_7_5[1920];
+extern int16_t s25n_kHz_7_5[7680];
+extern int16_t s25e_kHz_7_5[7680];
+extern int16_t s50n_kHz_7_5[15360];
+extern int16_t s50e_kHz_7_5[15360];
+extern int16_t s75n_kHz_7_5[24576];
+extern int16_t s75e_kHz_7_5[24576];
+extern int16_t s100n_kHz_7_5[30720];
+extern int16_t s100e_kHz_7_5[30720];
+
 
 int lte_sync_time_init(LTE_DL_FRAME_PARMS *frame_parms )   // LTE_UE_COMMON *common_vars
 {
 
   int i,k;
 
-  sync_corr_ue0 = (int32_t *)malloc16(LTE_NUMBER_OF_SUBFRAMES_PER_FRAME*sizeof(int32_t)*frame_parms->samples_per_tti);
+  sync_corr_ue0 = (int32_t *)malloc16(4*LTE_NUMBER_OF_SUBFRAMES_PER_FRAME*sizeof(int32_t)*frame_parms->samples_per_tti);
   sync_corr_ue1 = (int32_t *)malloc16(4*LTE_NUMBER_OF_SUBFRAMES_PER_FRAME*sizeof(int32_t)*frame_parms->samples_per_tti);
   sync_corr_ue2 = (int32_t *)malloc16(LTE_NUMBER_OF_SUBFRAMES_PER_FRAME*sizeof(int32_t)*frame_parms->samples_per_tti);
 
@@ -124,24 +135,37 @@ int lte_sync_time_init(LTE_DL_FRAME_PARMS *frame_parms )   // LTE_UE_COMMON *com
 
   primary_synch0SL_time = (int16_t *)malloc16((frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples)*sizeof(int16_t)*2);
   if (primary_synch0SL_time) {
-    //    bzero(primary_synch0_time,(frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples)*sizeof(int));
     bzero(primary_synch0SL_time,(frame_parms->ofdm_symbol_size)*sizeof(int16_t)*2);
 #ifdef DEBUG_PHY
     LOG_D(PHY,"[openair][LTE_PHY][SYNC] primary_synch0SL_time allocated at %p\n", primary_synch0SL_time);
 #endif
   } else  AssertFatal(1==0,"primary_synch0SL_time not allocated\n");
+  primary_synch0SL_time_rx = (int16_t *)malloc16(2*(frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples)*sizeof(int16_t)*2);
+  if (primary_synch0SL_time_rx) {
+    bzero(primary_synch0SL_time_rx,(frame_parms->ofdm_symbol_size)*sizeof(int16_t)*2);
+#ifdef DEBUG_PHY
+    LOG_D(PHY,"[openair][LTE_PHY][SYNC] primary_synch0SL_time_rx allocated at %p\n", primary_synch0SL_time);
+#endif
+  } else  AssertFatal(1==0,"primary_synch0SL_time_rx not allocated\n");
 
 
-  //  primary_synch1_time = (int *)malloc16((frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples)*sizeof(int));
-  primary_synch1SL_time = (int16_t *)malloc16((frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples)*sizeof(int16_t)*2);
+
+  primary_synch1SL_time = (int16_t *)malloc16(((frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples))*sizeof(int16_t)*2);
 
   if (primary_synch1SL_time) {
-    //    bzero(primary_synch1_time,(frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples)*sizeof(int));
-    bzero(primary_synch1SL_time,(frame_parms->ofdm_symbol_size)*sizeof(int16_t)*2);
+    bzero(primary_synch1SL_time,(frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples)*sizeof(int16_t)*2);
 #ifdef DEBUG_PHY
     LOG_D(PHY,"[openair][LTE_PHY][SYNC] primary_synch1SL_time allocated at %p\n", primary_synch1SL_time);
 #endif
   } else  AssertFatal(1==0,"primary_synch1SL_time not allocated\n");
+  primary_synch1SL_time_rx = (int16_t *)malloc16(2*(frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples)*sizeof(int16_t)*2);
+  if (primary_synch1SL_time_rx) {
+    bzero(primary_synch1SL_time_rx,2*(frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples)*sizeof(int16_t)*2);
+#ifdef DEBUG_PHY
+    LOG_D(PHY,"[openair][LTE_PHY][SYNC] primary_synch1SL_time_rx allocated at %p\n", primary_synch1SL_time);
+#endif
+  } else  AssertFatal(1==0,"primary_synch1SL_time_rx not allocated\n");
+
 
 
   // generate oversampled sync_time sequences
@@ -301,41 +325,62 @@ int lte_sync_time_init(LTE_DL_FRAME_PARMS *frame_parms )   // LTE_UE_COMMON *com
     }
   }
 
+  uint16_t *kHz7_5ptr;
+
+
   switch (frame_parms->N_RB_DL) {
   case 6:
     idft128((int16_t*)syncF_tmp,          /// complex input
 	   (int16_t*)sync_tmp, /// complex output
 	   1);
+    kHz7_5ptr = (frame_parms->Ncp==0) ? (((uint32_t*)s6n_kHz_7_5)+138): (((uint32_t*)s6e_kHz_7_5)+160);
+
     break;
   case 25:
     idft512((int16_t*)syncF_tmp,          /// complex input
 	   (int16_t*)sync_tmp, /// complex output
 	   1);
+    kHz7_5ptr = (frame_parms->Ncp==0) ? (((uint32_t*)s25n_kHz_7_5)+552) : (((uint32_t*)s25e_kHz_7_5)+640);
+
     break;
   case 50:
     idft1024((int16_t*)syncF_tmp,          /// complex input
 	    (int16_t*)sync_tmp, /// complex output
 	    1);
+    kHz7_5ptr = (frame_parms->Ncp==0) ? &s50n_kHz_7_5[2*1104] : s50e_kHz_7_5[2*1280];
+    printf("%p\n",kHz7_5ptr);
     break;
     
   case 75:
     idft1536((int16_t*)syncF_tmp,          /// complex input
 	     (int16_t*)sync_tmp,
 	     1); /// complex output
+    kHz7_5ptr = (frame_parms->Ncp==0) ? (((uint32_t*)s75n_kHz_7_5)+1656) : (((uint32_t*)s75e_kHz_7_5)+1920);
+
     break;
   case 100:
     idft2048((int16_t*)syncF_tmp,          /// complex input
 	     (int16_t*)sync_tmp, /// complex output
 	     1);
+    kHz7_5ptr = (frame_parms->Ncp==0) ? (((uint32_t*)s100n_kHz_7_5)+2208) : (((uint32_t*)s100e_kHz_7_5)+2560);
+
     break;
   default:
     LOG_E(PHY,"Unsupported N_RB_DL %d\n",frame_parms->N_RB_DL);
+    kHz7_5ptr = NULL;
     break;
   }
-
-  for (i=0; i<frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples; i++)
+  int imod;
+  for (i=0; i<(frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples)*2; i++) {
+    imod = i%(frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples);
+    if (i<(frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples))
 	((int32_t*)primary_synch0SL_time)[i] = sync_tmp[(i+(frame_parms->ofdm_symbol_size-frame_parms->nb_prefix_samples))%frame_parms->ofdm_symbol_size];
 
+    primary_synch0SL_time_rx[i<<1]     = (int16_t)(((int32_t)primary_synch0SL_time[imod<<1]*kHz7_5ptr[i<<1])>>15) - (int16_t)(((int32_t)primary_synch0SL_time[1+(imod<<1)]*kHz7_5ptr[1+(i<<1)])>>15);
+    primary_synch0SL_time_rx[1+(i<<1)] = (int16_t)(((int32_t)primary_synch0SL_time[imod<<1]*kHz7_5ptr[1+(i<<1)])>>15) + (int16_t)(((int32_t)primary_synch0SL_time[1+(imod<<1)]*kHz7_5ptr[i<<1])>>15);
+  }
+
+
   k=frame_parms->ofdm_symbol_size-36;
 
   for (i=0; i<72; i++) {
@@ -380,18 +425,28 @@ int lte_sync_time_init(LTE_DL_FRAME_PARMS *frame_parms )   // LTE_UE_COMMON *com
     break;
   }
 
-  for (i=0; i<frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples; i++)
+  for (i=0; i<(frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples)*2; i++) {
+    imod = i%(frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples);
+    if (i<(frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples))
       ((int32_t*)primary_synch1SL_time)[i] = sync_tmp[(i+(frame_parms->ofdm_symbol_size-frame_parms->nb_prefix_samples))%frame_parms->ofdm_symbol_size];
 
+    primary_synch1SL_time_rx[i<<1]     = (int16_t)(((int32_t)primary_synch1SL_time[imod<<1]*kHz7_5ptr[i<<1])>>15) - 
+                                         (int16_t)(((int32_t)primary_synch1SL_time[1+(imod<<1)]*kHz7_5ptr[1+(i<<1)])>>15);
+    primary_synch1SL_time_rx[1+(i<<1)] = (int16_t)(((int32_t)primary_synch1SL_time[imod<<1]*kHz7_5ptr[1+(i<<1)])>>15) +
+                                         (int16_t)(((int32_t)primary_synch1SL_time[1+(imod<<1)]*kHz7_5ptr[i<<1])>>15);
+  }
+
 
   /*
   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);
   write_output("primary_syncSL0.m","psyncSL0",primary_synch0SL_time,frame_parms->ofdm_symbol_size,1,1);
-  */  write_output("primary_syncSL1.m","psyncSL1",primary_synch1SL_time,frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples,1,1);
-  
     
+  write_output("primary_syncSL1.m","psyncSL1",primary_synch1SL_time_rx,2*(frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples),1,1);
+  write_output("primary_syncSL0.m","psyncSL0",primary_synch0SL_time_rx,2*(frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples),1,1);
+  write_output("kHz75.m","kHz75",kHz7_5ptr,2*1096,1,1);
+ */ 
   return (1);
 }
 
@@ -620,17 +675,13 @@ int lte_sync_timeSL(PHY_VARS_UE *ue,
 
   int length =   4*LTE_NUMBER_OF_SUBFRAMES_PER_FRAME*frame_parms->samples_per_tti;
   
-  int32_t sync_corr0[frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples];
-  int32_t sync_corr1[frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples];
-
-
   // circular copy of beginning to end of rxdata buffer. Note: buffer should be big enough upon calling this function
   for (int ar=0;ar<frame_parms->nb_antennas_rx;ar++) memcpy((void*)&ue->common_vars.rxdata_syncSL[ar][2*length],
 							    (void*)&ue->common_vars.rxdata_syncSL[ar][0],
 							    frame_parms->ofdm_symbol_size);
 
   int32_t tmp0,tmp1;
-  int32_t magtmp0,magtmp1,lev0,lev1,maxlev0=0,maxlev1=0;
+  int32_t magtmp0,magtmp1,maxlev0=0,maxlev1=0;
   int     maxpos0=0,maxpos1=0;
   int64_t avg0=0,avg1=0;
   int32_t result;
@@ -648,37 +699,25 @@ int lte_sync_timeSL(PHY_VARS_UE *ue,
   
 
 
-  // remove 7.5 kHz
-  for (int slot=0;slot<80;slot++) {
-    remove_7_5_kHz(&ru_tmp,slot);
-    for (int ar=0;ar<frame_parms->nb_antennas_rx;ar++) {
-      memcpy((void*)&rxdata[ar][slot*(frame_parms->samples_per_tti/2)],
-	     (void*)&rxdata_7_5kHz[ar][(slot&1)*2*(frame_parms->samples_per_tti/2)],
-	     sizeof(int16_t)*(2*frame_parms->samples_per_tti/2));
-    }
-  }
-  
   for (int n=0; n<length; n+=4) {
 
-    int nprime = n % (frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples);
-    
     tmp0 = 0;
     tmp1 = 0;
 
     //calculate dot product of primary_synch0_time and rxdata[ar][n] (ar=0..nb_ant_rx) and store the sum in temp[n];
     for (int ar=0; ar<frame_parms->nb_antennas_rx; ar++) {
       
-      result  = dot_product((int16_t*)primary_synch0SL_time,
+      result  = dot_product((int16_t*)primary_synch0SL_time_rx,
 			    (int16_t*) &(rxdata[ar][n]),
-			    frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples,
+			    (frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples)*2,
 			    11);
       
       ((int16_t*)&tmp0)[0] += ((int16_t*) &result)[0];
       ((int16_t*)&tmp0)[1] += ((int16_t*) &result)[1];
 
-      result  = dot_product((int16_t*)primary_synch1SL_time,
+      result  = dot_product((int16_t*)primary_synch1SL_time_rx,
 			    (int16_t*) &(rxdata[ar][n]),
-			    frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples,
+			    (frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples)*2,
 			    11);
 
       ((int16_t*)&tmp1)[0] += ((int16_t*) &result)[0];
@@ -693,22 +732,14 @@ int lte_sync_timeSL(PHY_VARS_UE *ue,
 
     // this does max |tmpi(n)|^2 + |tmpi(n-L)|^2 and argmax |tmpi(n)|^2 + |tmpi(n-L)|^2
     
-    if (n>(frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples)) {
-
-      //      if (n<4096) printf("syncSL: sample %d (nprime %d) : , mag0 %d, prev0 %d, mag1 %d, prev1 %d\n",
-      //      			 n,nprime,magtmp0,sync_corr0[nprime],magtmp1,sync_corr1[nprime]);
-      lev0 = magtmp0 + sync_corr0[nprime];
-      lev1 = magtmp1 + sync_corr1[nprime];
-      
-      if (lev0>maxlev0) { maxlev0 = lev0; maxpos0 = n-(frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples); }
-      if (lev1>maxlev1) { maxlev1 = lev1; maxpos1 = n-(frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples); }
+    if (magtmp0>maxlev0) { maxlev0 = magtmp0; maxpos0 = n; }
+    if (magtmp1>maxlev1) { maxlev1 = magtmp1; maxpos1 = n; }
     avg0 += magtmp0;
     avg1 += magtmp1;
-      
+    if (n<4*FRAME_LENGTH_COMPLEX_SAMPLES) {
+      sync_corr_ue1[n] = magtmp1;       
+      sync_corr_ue0[n] = magtmp0;       
     }
-    sync_corr0[nprime]=magtmp0;
-    sync_corr1[nprime]=magtmp1;
-    if (n<4*FRAME_LENGTH_COMPLEX_SAMPLES) sync_corr_ue1[n] = magtmp1; 
   }
   avg0/=(length/4);
   avg1/=(length/4);

openair1/PHY/LTE_TRANSPORT/initial_syncSL.c

@@ -60,6 +60,13 @@ int initial_syncSL(PHY_VARS_UE *ue) {
     
     if (rx_psbch(ue) == -1) {
       ue->slbch_errors++;
+/*
+      write_output("rxsig0.m","rxs0",&ue->common_vars.rxdata_syncSL[0][0],40*ue->frame_parms.samples_per_tti,1,1);
+      write_output("corr0.m","rxsync0",sync_corr_ue0,40*ue->frame_parms.samples_per_tti,1,2);
+      write_output("corr1.m","rxsync1",sync_corr_ue1,40*ue->frame_parms.samples_per_tti,1,2);
+
+      exit(-1);
+*/
       return(-1);
     }
     else {
@@ -80,7 +87,8 @@ int initial_syncSL(PHY_VARS_UE *ue) {
     }
   }
   else {
-     write_output("rxsig0.m","rxs0",&ue->common_vars.rxdata[0][ue->frame_parms.samples_per_tti*subframe],ue->frame_parms.samples_per_tti,1,1);
+     /*write_output("rxsig0.m","rxs0",&ue->common_vars.rxdata[0][ue->frame_parms.samples_per_tti*subframe],ue->frame_parms.samples_per_tti,1,1);
      exit(-1);
+*/
   }
 }

openair1/PHY/LTE_TRANSPORT/slbch.c

@@ -42,7 +42,7 @@
 #define PSBCH_A 40
 #define PSBCH_E 1008 //12REs/PRB*6PRBs*7symbols*2 bits/RB
 
-#define PSBCH_DEBUG 1
+//#define PSBCH_DEBUG 1
 
 
 
@@ -149,7 +149,7 @@ int rx_psbch(PHY_VARS_UE *ue) {
   ru_tmp.N_TA_offset=0;
   ru_tmp.common.rxdata_7_5kHz     = (int32_t**)malloc16(ue->frame_parms.nb_antennas_rx*sizeof(int32_t*)); 
   for (int aa=0;aa<ue->frame_parms.nb_antennas_rx;aa++) 
-    ru_tmp.common.rxdata_7_5kHz[aa] = (int32_t*)&ue->common_vars.rxdata_syncSL[aa][ue->rx_offsetSL*2];
+    ru_tmp.common.rxdata_7_5kHz[aa] = ue->sl_rxdata_7_5kHz[aa];//(int32_t*)&ue->common_vars.rxdata_syncSL[aa][ue->rx_offsetSL*2];
   ru_tmp.common.rxdataF = (int32_t**)rxdataF;
   ru_tmp.nb_rx = ue->frame_parms.nb_antennas_rx;
 

openair1/PHY/LTE_TRANSPORT/slsss.c

@@ -96,12 +96,14 @@ int slpss_ch_est(PHY_VARS_UE *ue,
 		 int32_t sss0_ext[4][72],
 		 int32_t pss1_ext[4][72],
 		 int32_t sss1_ext[4][72],
+                 int64_t sss0_comp[72],
+		 int64_t sss1_comp[72],
 		 int Nid2)
 {
 
   int16_t *pss;
-  int16_t *pss0_ext2,*sss0_ext2,*sss0_ext3,*sss1_ext3,tmp0_re,tmp0_im,tmp1_re,tmp1_im,tmp0_re2,tmp0_im2,tmp1_re2,tmp1_im2;
-
+  int16_t *pss0_ext2,*sss0_ext2,tmp0_re,tmp0_im,tmp1_re,tmp1_im;
+  int32_t *sss0comp,*sss1comp,tmp0_re2,tmp0_im2,tmp1_re2,tmp1_im2;
   int16_t *pss1_ext2,*sss1_ext2;
   uint8_t aarx,i;
   LTE_DL_FRAME_PARMS *frame_parms = &ue->frame_parms;
@@ -121,8 +123,8 @@ int slpss_ch_est(PHY_VARS_UE *ue,
     break;
   }
 
-  sss0_ext3 = (int16_t*)&sss0_ext[0][5];
-  sss1_ext3 = (int16_t*)&sss1_ext[0][5];
+  sss0comp = (int32_t*)&sss0_comp[5];
+  sss1comp = (int32_t*)&sss1_comp[5];
 
   for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
 
@@ -139,31 +141,33 @@ int slpss_ch_est(PHY_VARS_UE *ue,
       tmp1_re = (int16_t)((((pss1_ext2[i<<1]) * (int32_t)pss[i<<1])>>15)     + (((pss1_ext2[1+(i<<1)]) * (int32_t)pss[1+(i<<1)])>>15));
       tmp1_im = (int16_t)((((pss1_ext2[i<<1]) * (int32_t)pss[1+(i<<1)])>>15) - (((pss1_ext2[1+(i<<1)]) * (int32_t)pss[(i<<1)])>>15));
 
-      //      printf("H*(%d,%d) : (%d,%d)\n",aarx,i,tmp_re,tmp_im);
+      //printf("H*(%d,%d) : (%d,%d)\n",aarx,i,tmp0_re,tmp0_im);
       // This is R(SSS0) \cdot H*(PSS)
-      tmp0_re2 = (int16_t)(((tmp0_re * (int32_t)sss0_ext2[i<<1])>>12)  - 
-			   ((tmp0_im * (int32_t)sss0_ext2[1+(i<<1)])>>12));
-      tmp0_im2 = (int16_t)(((tmp0_re * (int32_t)sss0_ext2[1+(i<<1)])>>12) + 
-			   ((tmp0_im * (int32_t)sss0_ext2[(i<<1)])>>12));
+      tmp0_re2 = (tmp0_re * (int32_t)sss0_ext2[i<<1])  - 
+		 (tmp0_im * (int32_t)sss0_ext2[1+(i<<1)]);
+      tmp0_im2 = (tmp0_re * (int32_t)sss0_ext2[1+(i<<1)]) + 
+	         (tmp0_im * (int32_t)sss0_ext2[(i<<1)]);
       // This is R(SSS1) \cdot H*(PSS)
-      tmp1_re2 = (int16_t)(((tmp1_re * (int32_t)sss1_ext2[i<<1])>>12)  - 
-			   ((tmp1_im * (int32_t)sss1_ext2[1+(i<<1)])>>12));
-      tmp1_im2 = (int16_t)(((tmp1_re * (int32_t)sss1_ext2[1+(i<<1)])>>12) + 
-			   ((tmp1_im * (int32_t)sss1_ext2[(i<<1)])>>12));
+      tmp1_re2 = (tmp1_re * (int32_t)sss1_ext2[i<<1])  - 
+		 (tmp1_im * (int32_t)sss1_ext2[1+(i<<1)]);
+      tmp1_im2 = (tmp1_re * (int32_t)sss1_ext2[1+(i<<1)]) + 
+		 (tmp1_im * (int32_t)sss1_ext2[(i<<1)]);
     
       //      printf("SSSi(%d,%d) : (%d,%d)\n",aarx,i,sss_ext2[i<<1],sss_ext2[1+(i<<1)]);
-      //      printf("SSSo(%d,%d) : (%d,%d)\n",aarx,i,tmp_re2,tmp_im2);
+            //printf("SSScomp0(%d,%d) : (%d,%d)\n",aarx,i,tmp0_re2,tmp0_im2);
+            //printf("SSScomp1(%d,%d) : (%d,%d)\n",aarx,i,tmp1_re2,tmp1_im2);
+
       // MRC on RX antennas
       if (aarx==0) {
-        sss0_ext3[i<<1]      = tmp0_re2;
-        sss0_ext3[1+(i<<1)]  = tmp0_im2;
-        sss1_ext3[i<<1]      = tmp1_re2;
-        sss1_ext3[1+(i<<1)]  = tmp1_im2;
+        sss0comp[i<<1]      = tmp0_re2;
+        sss0comp[1+(i<<1)]  = tmp0_im2;
+        sss1comp[i<<1]      = tmp1_re2;
+        sss1comp[1+(i<<1)]  = tmp1_im2;
       } else {
-        sss0_ext3[i<<1]      += tmp0_re2;
-        sss0_ext3[1+(i<<1)]  += tmp0_im2;
-        sss1_ext3[i<<1]      += tmp1_re2;
-        sss1_ext3[1+(i<<1)]  += tmp1_im2;
+        sss0comp[i<<1]      += tmp0_re2;
+        sss0comp[1+(i<<1)]  += tmp0_im2;
+        sss1comp[i<<1]      += tmp1_re2;
+        sss1comp[1+(i<<1)]  += tmp1_im2;
       }
     }
   }
@@ -207,7 +211,8 @@ int _do_slpss_sss_extract(PHY_VARS_UE *ue,
       pss1_symb = 2;
       sss0_symb = 11;
       sss1_symb = 12;
-      rxdataF   =  ue->sl_rxdataF;
+      rxdataF   =  (int32_t**)ue->sl_rxdataF;
+
       pss0_rxF  =  &rxdataF[aarx][(rx_offset + (pss0_symb*(frame_parms->ofdm_symbol_size)))];
       sss0_rxF  =  &rxdataF[aarx][(rx_offset + (sss0_symb*(frame_parms->ofdm_symbol_size)))];
       pss1_rxF  =  &rxdataF[aarx][(rx_offset + (pss1_symb*(frame_parms->ofdm_symbol_size)))];
@@ -292,6 +297,9 @@ int rx_slsss(PHY_VARS_UE *ue,int32_t *tot_metric,uint8_t *phase_max,int Nid2)
   uint8_t i;
   int32_t pss0_ext[4][72],pss1_ext[4][72];
   int32_t sss0_ext[4][72],sss1_ext[4][72];
+  int64_t sss0_comp[72],sss1_comp[72];
+  int16_t sss0_comp16[144],sss1_comp16[144];
+
   uint8_t phase;
   uint16_t Nid1;
   int16_t *sss0,*sss1;
@@ -319,12 +327,17 @@ int rx_slsss(PHY_VARS_UE *ue,int32_t *tot_metric,uint8_t *phase_max,int Nid2)
     memcpy((void*)&ru_tmp.frame_parms,(void*)&ue->frame_parms,sizeof(LTE_DL_FRAME_PARMS));
     ru_tmp.N_TA_offset=0;
     ru_tmp.common.rxdata_7_5kHz     = (int32_t**)malloc16(ue->frame_parms.nb_antennas_rx*sizeof(int32_t*)); 
-    for (int aa=0;aa<ue->frame_parms.nb_antennas_rx;aa++) 
-      ru_tmp.common.rxdata_7_5kHz[aa] = (int32_t*)&ue->common_vars.rxdata_syncSL[aa][ue->rx_offsetSL*2];
+    ru_tmp.common.rxdata            = (int32_t**)malloc16(ue->frame_parms.nb_antennas_rx*sizeof(int32_t*)); 
+    for (int aa=0;aa<ue->frame_parms.nb_antennas_rx;aa++) { 
+      ru_tmp.common.rxdata_7_5kHz[aa] = (int32_t*)ue->sl_rxdata_7_5kHz[aa];
+      ru_tmp.common.rxdata[aa]        = (int32_t*)ue->common_vars.rxdata_syncSL[aa];
+    }
     ru_tmp.common.rxdataF = (int32_t**)rxdataF;
     ru_tmp.nb_rx = ue->frame_parms.nb_antennas_rx;
     
     
+    remove_7_5_kHz(&ru_tmp,0);
+    remove_7_5_kHz(&ru_tmp,1);
     // PSS
     slot_fep_ul(&ru_tmp,1,0,0);
     slot_fep_ul(&ru_tmp,2,0,0);
@@ -333,6 +346,7 @@ int rx_slsss(PHY_VARS_UE *ue,int32_t *tot_metric,uint8_t *phase_max,int Nid2)
     slot_fep_ul(&ru_tmp,5,1,0);
     
     free(ru_tmp.common.rxdata_7_5kHz); 
+    free(ru_tmp.common.rxdata); 
   } else { // TDD
     AssertFatal(1==0,"TDD not supported for Sidelink\n");
   }
@@ -345,8 +359,12 @@ int rx_slsss(PHY_VARS_UE *ue,int32_t *tot_metric,uint8_t *phase_max,int Nid2)
 		    0);
 
   //  write_output("rxdataF0.m","rxF0",&rxdataF[0][0],2*14*ue->frame_parms.ofdm_symbol_size,1,1);
-    write_output("pss0_ext.m","pss0ext",pss0_ext,72,1,1);
+  /*  write_output("pss0_ext.m","pss0ext",pss0_ext,72,1,1);
     write_output("sss0_ext.m","sss0ext",sss0_ext,72,1,1);
+    write_output("pss1_ext.m","pss1ext",pss1_ext,72,1,1);
+    write_output("sss1_ext.m","sss1ext",sss1_ext,72,1,1); */
+
+
 
   //  exit(-1);
 
@@ -358,18 +376,40 @@ int rx_slsss(PHY_VARS_UE *ue,int32_t *tot_metric,uint8_t *phase_max,int Nid2)
 	       sss0_ext,
 	       pss1_ext,
 	       sss1_ext,
+	       sss0_comp,
+	       sss1_comp,
 	       Nid2);
 
-    write_output("sss0_comp0.m","sss0comp0",sss0_ext,72,1,1);
-    write_output("sss1_comp0.m","sss1comp0",sss1_ext,72,1,1);
+  // rescale from 64 to 16 bit resolution keeping 8 bits of dynamic range
+  uint32_t maxval=0;
+  int32_t *sss0comp=(int32_t*)sss0_comp,*sss1comp=(int32_t*)sss1_comp;
+  for (i=10;i<134;i++) {
+      if (sss0comp[i] >=0) maxval=(uint64_t)max(maxval,sss0comp[i]);
+      else maxval=(uint64_t)max(maxval,-sss0comp[i]);
+      if (sss1comp[i] >=0) maxval=(uint64_t)max(maxval,sss1comp[i]);
+      else maxval=(uint64_t)max(maxval,-sss1comp[i]);
+  }
+  uint8_t log2maxval = log2_approx64(maxval);
+  uint8_t shift;
+  if (log2maxval < 8) shift = 0; else shift = log2maxval-8; 
+
+
+
+
+  for (i=0;i<144;i++) {
+      sss0_comp16[i] = (int16_t)(sss0comp[i]>>shift);
+      sss1_comp16[i] = (int16_t)(sss1comp[i]>>shift);
+  }
+    /*write_output("sss0_comp0.m","sss0comp0",sss0_comp16,72,1,1);
+    write_output("sss1_comp0.m","sss1comp0",sss1_comp16,72,1,1);*/
   //  exit(-1);
   // now do the SSS detection based on the precomputed sequences in PHY/LTE_TRANSPORT/sss.h
 
   *tot_metric = -99999999;
 
 
-  sss0 = (int16_t*)&sss0_ext[0][5];
-  sss1 = (int16_t*)&sss1_ext[0][5];
+  sss0 = &sss0_comp16[10];
+  sss1 = &sss1_comp16[10];
 
 
   for (phase=0; phase<7; phase++) { // phase offset between PSS and SSS

openair1/PHY/extern.h

@@ -65,6 +65,9 @@ extern const int16_t *primary_synch1_time; //!< index: [0..ofdm_symbol_size*2[
 extern const int16_t *primary_synch2_time; //!< index: [0..ofdm_symbol_size*2[
 extern const int16_t *primary_synch0SL_time;
 extern const int16_t *primary_synch1SL_time;
+extern int16_t *primary_synch0SL_time_rx;
+extern int16_t *primary_synch1SL_time_rx;
+
 extern int *sync_corr_ue0; //!< index [0..10*samples_per_tti[
 extern int *sync_corr_ue1; //!< index [0..10*samples_per_tti[
 extern int *sync_corr_ue2; //!< index [0..10*samples_per_tti[

openair1/PHY/vars.h

@@ -40,6 +40,8 @@ const int16_t *primary_synch2_time;
 
 const int16_t *primary_synch0SL_time;
 const int16_t *primary_synch1SL_time;
+int16_t *primary_synch0SL_time_rx;
+int16_t *primary_synch1SL_time_rx;
 
 
 #include "PHY/CODING/vars.h"

openair1/SIMULATION/LTE_PHY/slschsim.c

@@ -354,14 +354,15 @@ int main(int argc, char **argv) {
 	UE->slss_generated=0;
 	frame = absSF/10;
 	subframe= absSF%10;
+        if (do_SLSS==0) {
 	   check_and_generate_psdch(UE,frame,subframe);
 	   UE->slsch_active = 1;
 	   check_and_generate_pscch(UE,frame,subframe);
 	   proc.subframe_tx = subframe;
 	   proc.frame_tx    = frame;
 	   check_and_generate_pssch(UE,&proc,frame,subframe);
+        }
 	   check_and_generate_slss(UE,frame,subframe);
-	
 	if (UE->psdch_generated>0 || UE->pscch_generated > 0 || UE->pssch_generated > 0 || UE->slss_generated > 0) {
 	  AssertFatal(UE->pscch_generated<3,"Illegal pscch_generated %d\n",UE->pscch_generated);
 	  // FEP