diff --git a/cmake_targets/CMakeLists.txt b/cmake_targets/CMakeLists.txt
index 81ea169b47977e065d6d24a5210e5c975e27babb..50e367f484d9c8aff3537b7061ec0c17ec93f2d9 100644
--- a/cmake_targets/CMakeLists.txt
+++ b/cmake_targets/CMakeLists.txt
@@ -1045,6 +1045,7 @@ set(PHY_SRC
   ${OPENAIR1_DIR}/PHY/LTE_ESTIMATION/freq_equalization.c
   ${OPENAIR1_DIR}/PHY/LTE_ESTIMATION/freq_equalization_NB_IoT.c
   ${OPENAIR1_DIR}/PHY/LTE_ESTIMATION/lte_sync_time.c
+  ${OPENAIR1_DIR}/PHY/LTE_ESTIMATION/lte_sync_time_NB_IoT.c
   ${OPENAIR1_DIR}/PHY/LTE_ESTIMATION/lte_sync_timefreq.c
   ${OPENAIR1_DIR}/PHY/LTE_ESTIMATION/lte_adjust_sync.c
   ${OPENAIR1_DIR}/PHY/LTE_ESTIMATION/lte_adjust_sync_NB_IoT.c
diff --git a/openair1/PHY/LTE_ESTIMATION/defs_NB_IoT.h b/openair1/PHY/LTE_ESTIMATION/defs_NB_IoT.h
index bc64ac744ef5ef29542694c2490904ad7e6d7a0e..d40945d8681eb1ecee3d9cbf026bac3fcaf2d985 100644
--- a/openair1/PHY/LTE_ESTIMATION/defs_NB_IoT.h
+++ b/openair1/PHY/LTE_ESTIMATION/defs_NB_IoT.h
@@ -33,6 +33,19 @@ int lte_est_timing_advance(NB_IoT_DL_FRAME_PARMS *frame_parms,
                            short coef);
 */
 
+////////// Vincent: NB-IoT DL synchronization //////////////////////////////////////////////////
+
+int lte_sync_time_init_NB_IoT(NB_IoT_DL_FRAME_PARMS *frame_parms ); 
+
+void lte_sync_time_free_NB_IoT(void); 
+
+int lte_sync_time_NB_IoT(int **rxdata, ///rx data in time domain
+                  NB_IoT_DL_FRAME_PARMS *frame_parms,
+                  int *eNB_id);
+
+
+////////////////////////////////////////////////////////////////////////////////////////////////
+
 int NB_IoT_est_timing_advance_pusch(PHY_VARS_eNB_NB_IoT* phy_vars_eNB,module_id_t UE_id);
 
 
@@ -61,10 +74,10 @@ int16_t lte_ul_freq_offset_estimation_NB_IoT(NB_IoT_DL_FRAME_PARMS *frame_parms,
                                       		 uint16_t nb_rb);
 
 void freq_equalization_NB_IoT(NB_IoT_DL_FRAME_PARMS *frame_parms,
-                       		  int **rxdataF_comp,
-                       		  int **ul_ch_mag,
-                       		  int **ul_ch_mag_b,
-                       		  unsigned char symbol,
+                         		  int **rxdataF_comp,
+                         		  int **ul_ch_mag,
+                         		  int **ul_ch_mag_b,
+                         		  unsigned char symbol,
                        	      unsigned short Msc_RS,
                               unsigned char Qm);
 
diff --git a/openair1/PHY/LTE_ESTIMATION/lte_sync_time_NB_IoT.c b/openair1/PHY/LTE_ESTIMATION/lte_sync_time_NB_IoT.c
new file mode 100644
index 0000000000000000000000000000000000000000..63666d6848ea5e17b3bcbcdf3e9dc9df8c800be3
--- /dev/null
+++ b/openair1/PHY/LTE_ESTIMATION/lte_sync_time_NB_IoT.c
@@ -0,0 +1,636 @@
+/*
+ * 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
+ */
+
+/* file: lte_sync_time.c
+   purpose: coarse timing synchronization for LTE (using PSS)
+   author: florian.kaltenberger@eurecom.fr, oscar.tonelli@yahoo.it
+   date: 22.10.2009
+*/
+
+//#include <string.h>
+#include "defs_NB_IoT.h"
+#include "PHY/defs_NB_IoT.h"
+#include "PHY/extern_NB_IoT.h"
+// #include "SCHED/extern_NB_IoT.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;
+int sync_tmp[2048*4] __attribute__((aligned(32)));
+short syncF_tmp[2048*2] __attribute__((aligned(32)));
+
+
+
+int lte_sync_time_init_NB_IoT(NB_IoT_DL_FRAME_PARMS *frame_parms )   // LTE_UE_COMMON *common_vars
+{
+
+  int i,k,k2,l;
+
+  sync_corr_ue0_NB_IoT = (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);
+
+  if (sync_corr_ue0) {
+#ifdef DEBUG_PHY
+    msg("[openair][LTE_PHY][SYNC] sync_corr_ue allocated at %p\n", sync_corr_ue0);
+#endif
+    //common_vars->sync_corr = sync_corr;
+  } else {
+    msg("[openair][LTE_PHY][SYNC] sync_corr_ue0 not allocated\n");
+    return(-1);
+  }
+
+//   if (sync_corr_ue1) {
+// #ifdef DEBUG_PHY
+//     msg("[openair][LTE_PHY][SYNC] sync_corr_ue allocated at %p\n", sync_corr_ue1);
+// #endif
+//     //common_vars->sync_corr = sync_corr;
+//   } else {
+//     msg("[openair][LTE_PHY][SYNC] sync_corr_ue1 not allocated\n");
+//     return(-1);
+//   }
+
+//   if (sync_corr_ue2) {
+// #ifdef DEBUG_PHY
+//     msg("[openair][LTE_PHY][SYNC] sync_corr_ue allocated at %p\n", sync_corr_ue2);
+// #endif
+//     //common_vars->sync_corr = sync_corr;
+//   } else {
+//     msg("[openair][LTE_PHY][SYNC] sync_corr_ue2 not allocated\n");
+//     return(-1);
+//   }
+
+  //  primary_synch0_time = (int *)malloc16((frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples)*sizeof(int)); 
+
+  // Consider the CPs 10 normal length + 1 longer due to first symbol in slot
+  primary_synch0_time_NB_IoT = (int16_t *)malloc16((frame_parms->ofdm_symbol_size*11 + frame_parms->nb_prefix_samples*10 + frame_parms->nb_prefix_samples0)*sizeof(int16_t)*2); // 11 symbols per subframe dedicated to primary synchro
+
+  if (primary_synch0_time_NB_IoT) {
+    //    bzero(primary_synch0_time,(frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples)*sizeof(int));
+    bzero(primary_synch0_time_NB_IoT,(frame_parms->ofdm_symbol_size)*sizeof(int16_t)*2*11);
+#ifdef DEBUG_PHY
+    msg("[openair][LTE_PHY][SYNC] primary_synch0_time allocated at %p\n", primary_synch0_time_NB_IoT);
+#endif
+  } else {
+    msg("[openair][LTE_PHY][SYNC] primary_synch0_time not allocated\n");
+    return(-1);
+  }
+
+  //  primary_synch1_time = (int *)malloc16((frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples)*sizeof(int));
+//   primary_synch1_time = (int16_t *)malloc16((frame_parms->ofdm_symbol_size)*sizeof(int16_t)*2);
+
+//   if (primary_synch1_time) {
+//     //    bzero(primary_synch1_time,(frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples)*sizeof(int));
+//     bzero(primary_synch1_time,(frame_parms->ofdm_symbol_size)*sizeof(int16_t)*2);
+// #ifdef DEBUG_PHY
+//     msg("[openair][LTE_PHY][SYNC] primary_synch1_time allocated at %p\n", primary_synch1_time);
+// #endif
+//   } else {
+//     msg("[openair][LTE_PHY][SYNC] primary_synch1_time not allocated\n");
+//     return(-1);
+//   }
+
+//   //  primary_synch2_time = (int *)malloc16((frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples)*sizeof(int));
+//   primary_synch2_time = (int16_t *)malloc16((frame_parms->ofdm_symbol_size)*sizeof(int16_t)*2);
+
+//   if (primary_synch2_time) {
+//     //    bzero(primary_synch2_time,(frame_parms->ofdm_symbol_size+frame_parms->nb_prefix_samples)*sizeof(int));
+//     bzero(primary_synch2_time,(frame_parms->ofdm_symbol_size)*sizeof(int16_t)*2);
+// #ifdef DEBUG_PHY
+//     msg("[openair][LTE_PHY][SYNC] primary_synch2_time allocated at %p\n", primary_synch2_time);
+// #endif
+//   } else {
+//     msg("[openair][LTE_PHY][SYNC] primary_synch2_time not allocated\n");
+//     return(-1);
+//   }
+
+
+  // generate oversampled sync_time sequences 
+
+  if (frame_parms->NB_IoT_RB_ID <= (frame_parms->N_RB_DL>>1)) { // NB-IoT RB is in the first half 
+    k = frame_parms->ofdm_symbol_size - frame_parms->N_RB_DL*6 + frame_parms->NB_IoT_RB_ID*12; 
+  }else{// second half: DC carrier offset 
+    k = 1 + 6*(2*frame_parms->NB_IoT_RB_ID - frame_parms->N_RB_DL); 
+  }
+
+  for (l=0; l<11 ; l++){
+    k2 = k; 
+    for (i=0; i<12; i++) { // 12 subcarriers in NB-IoT
+
+        syncF_tmp[2*k2] = primary_synch_NB_IoT[12*l + 2*i]>>2;  //we need to shift input to avoid overflow in fft
+        syncF_tmp[2*k2+1] = primary_synch_NB_IoT[12*l + 2*i+1]>>2;
+        k2++;
+
+    }
+
+    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
+  	     (short*)sync_tmp,
+  	     1); /// complex output
+      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;
+    }
+
+    for (i=0; i<frame_parms->ofdm_symbol_size; i++)
+      if (l < 4){ // Skip CP length
+        ((int32_t*)primary_synch0_time_NB_IoT)[l*(frame_parms->nb_prefix_samples + frame_parms->ofdm_symbol_size) + i] = sync_tmp[i];
+      }else{
+        ((int32_t*)primary_synch0_time_NB_IoT)[frame_parms->nb_prefix_samples0 + frame_parms->ofdm_symbol_size + 
+                                      (l-1)*(frame_parms->nb_prefix_samples + frame_parms->ofdm_symbol_size) + i] = sync_tmp[i];
+      }
+
+  }
+
+  // k=frame_parms->ofdm_symbol_size-36;
+
+  // 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++;
+
+  //   if (k >= frame_parms->ofdm_symbol_size) {
+  //     k++;  // skip DC carrier
+  //     k-=frame_parms->ofdm_symbol_size;
+  //   }
+  // }
+
+  // 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
+	 //     (short*)sync_tmp, /// complex output
+	 //     1);
+  //   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;
+  // }
+
+  // for (i=0; i<frame_parms->ofdm_symbol_size; i++)
+  //   ((int32_t*)primary_synch1_time)[i] = sync_tmp[i];
+
+  // k=frame_parms->ofdm_symbol_size-36;
+
+  // 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++;
+
+  //   if (k >= frame_parms->ofdm_symbol_size) {
+  //     k++;  // skip DC carrier
+  //     k-=frame_parms->ofdm_symbol_size;
+  //   }
+  // }
+
+  // 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
+	 //     (short*)sync_tmp, /// complex output
+	 //     1);
+  //   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;
+  // }
+
+  // for (i=0; i<frame_parms->ofdm_symbol_size; i++)
+  //   ((int32_t*)primary_synch2_time)[i] = sync_tmp[i];
+
+
+
+
+#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);
+}
+
+
+void lte_sync_time_free_NB_IoT(void)
+{
+
+
+  if (sync_corr_ue0) {
+    msg("Freeing sync_corr_ue (%p)...\n",sync_corr_ue0);
+    free(sync_corr_ue0);
+  }
+
+  // if (sync_corr_ue1) {
+  //   msg("Freeing sync_corr_ue (%p)...\n",sync_corr_ue1);
+  //   free(sync_corr_ue1);
+  // }
+
+  // if (sync_corr_ue2) {
+  //   msg("Freeing sync_corr_ue (%p)...\n",sync_corr_ue2);
+  //   free(sync_corr_ue2);
+  // }
+
+  if (primary_synch0_time_NB_IoT) {
+    msg("Freeing primary_sync0_time ...\n");
+    free(primary_synch0_time_NB_IoT);
+  }
+
+  // if (primary_synch1_time) {
+  //   msg("Freeing primary_sync1_time ...\n");
+  //   free(primary_synch1_time);
+  // }
+
+  // if (primary_synch2_time) {
+  //   msg("Freeing primary_sync2_time ...\n");
+  //   free(primary_synch2_time);
+  // }
+
+  sync_corr_ue0_NB_IoT = NULL;
+  // sync_corr_ue1 = NULL;
+  // sync_corr_ue2 = NULL;
+  primary_synch0_time_NB_IoT = NULL;
+  // primary_synch1_time = NULL;
+  // primary_synch2_time = NULL;
+}
+
+static inline int abs32(int x)
+{
+  return (((int)((short*)&x)[0])*((int)((short*)&x)[0]) + ((int)((short*)&x)[1])*((int)((short*)&x)[1]));
+}
+
+#ifdef DEBUG_PHY
+int debug_cnt=0;
+#endif
+
+#define SHIFT 17
+
+int lte_sync_time_NB_IoT(int **rxdata, ///rx data in time domain
+                  NB_IoT_DL_FRAME_PARMS *frame_parms,
+                  int *eNB_id)
+{
+
+
+
+  // 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 sync_out = 0,sync_out2 = 0;
+  int tmp = 0;
+  // int length =   LTE_NUMBER_OF_SUBFRAMES_PER_FRAME*frame_parms->samples_per_tti>>1;
+  int length =   LTE_NUMBER_OF_SUBFRAMES_PER_FRAME*frame_parms->samples_per_tti;
+
+  //msg("[SYNC TIME] Calling sync_time.\n");
+  if (sync_corr_ue0 == NULL) {
+    msg("[SYNC TIME] sync_corr_ue0 not yet allocated! Exiting.\n");
+    return(-1);
+  }
+
+  // if (sync_corr_ue1 == NULL) {
+  //   msg("[SYNC TIME] sync_corr_ue1 not yet allocated! Exiting.\n");
+  //   return(-1);
+  // }
+
+  // if (sync_corr_ue2 == NULL) {
+  //   msg("[SYNC TIME] sync_corr_ue2 not yet allocated! Exiting.\n");
+  //   return(-1);
+  // }
+
+  peak_val = 0;
+  peak_pos = 0;
+  // sync_source = 0;
+
+
+  for (n=0; n<length; n+=4) {
+
+#ifdef RTAI_ENABLED
+
+    // This is necessary since the sync takes a long time and it seems to block all other threads thus screwing up RTAI. If we pause it for a little while during its execution we give RTAI a chance to catch up with its other tasks.
+    if ((n%frame_parms->samples_per_tti == 0) && (n>0) && (openair_daq_vars.sync_state==0)) {
+#ifdef DEBUG_PHY
+      msg("[SYNC TIME] pausing for 1000ns, n=%d\n",n);
+#endif
+      rt_sleep(nano2count(1000));
+    }
+
+#endif
+
+    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;
+
+    // for (s=0; s<3; s++) {
+    //   sync_out[s]=0;
+    //   sync_out2[s]=0;
+    // }
+
+    //    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];
+      // for (ar=0; ar<frame_parms->nb_antennas_rx; ar++) {
+      for (ar=0; ar<1; ar++) {
+
+        result  = dot_product((short*)primary_synch0_time_NB_IoT, (short*) &(rxdata[ar][n]), 11*frame_parms->ofdm_symbol_size, SHIFT);
+        // result2 = dot_product((short*)primary_synch0_time, (short*) &(rxdata[ar][n+length]), 11*frame_parms->ofdm_symbol_size, SHIFT);
+
+        ((short*)sync_corr_ue0_NB_IoT)[2*n] += ((short*) &result)[0];
+        ((short*)sync_corr_ue0_NB_IoT)[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];
+      }
+
+      // for (ar=0; ar<frame_parms->nb_antennas_rx; ar++) {
+      //   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);
+      //   ((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];
+      // }
+
+      // for (ar=0; ar<frame_parms->nb_antennas_rx; ar++) {
+
+      //   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);
+      //   ((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];
+      // }
+
+    }
+
+    // calculate the absolute value of sync_corr[n]
+
+    sync_corr_ue0_NB_IoT[n] = abs32(sync_corr_ue0_NB_IoT[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]);
+
+    // for (s=0; s<3; s++) {
+    tmp = (abs32(sync_out)>>1); // + (abs32(sync_out2)>>1);
+
+    if (tmp>peak_val) {
+      peak_val = tmp;
+      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]);
+      */
+    }
+    // }
+  }
+
+  // *eNB_id = sync_source;
+
+  LOG_D(PHY,"[UE] lte_sync_time: Peak found at pos %d, val = %d (%d dB)\n",peak_pos,peak_val,dB_fixed(peak_val)/2);
+
+
+#ifdef DEBUG_PHY
+  if (debug_cnt == 0) {
+    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);
+    //    exit(-1);
+  } else {
+    debug_cnt++;
+  }
+
+
+#endif
+
+
+  return(peak_pos);
+
+}
+
+//#define DEBUG_PHY
+
+// int lte_sync_time_eNB(int32_t **rxdata, ///rx data in time domain
+//                       LTE_DL_FRAME_PARMS *frame_parms,
+//                       uint32_t length,
+//                       uint32_t *peak_val_out,
+//                       uint32_t *sync_corr_eNB)
+// {
+
+//   // perform a time domain correlation using the oversampled sync sequence
+
+//   unsigned int n, ar, peak_val, peak_pos;
+//   uint64_t mean_val;
+//   int result;
+//   short *primary_synch_time;
+//   int eNB_id = frame_parms->Nid_cell%3;
+
+//   // msg("[SYNC TIME] Calling sync_time_eNB(%p,%p,%d,%d)\n",rxdata,frame_parms,eNB_id,length);
+//   if (sync_corr_eNB == NULL) {
+//     LOG_E(PHY,"[SYNC TIME] sync_corr_eNB not yet allocated! Exiting.\n");
+//     return(-1);
+//   }
+
+//   switch (eNB_id) {
+//   case 0:
+//     primary_synch_time = (short*)primary_synch0_time;
+//     break;
+
+//   case 1:
+//     primary_synch_time = (short*)primary_synch1_time;
+//     break;
+
+//   case 2:
+//     primary_synch_time = (short*)primary_synch2_time;
+//     break;
+
+//   default:
+//     LOG_E(PHY,"[SYNC TIME] Illegal eNB_id!\n");
+//     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];
+//       for (ar=0; ar<frame_parms->nb_antennas_rx; ar++)  {
+
+//         result = dot_product((short*)primary_synch_time, (short*) &(rxdata[ar][n]), frame_parms->ofdm_symbol_size, SHIFT);
+//         //((short*)sync_corr)[2*n]   += ((short*) &result)[0];
+//         //((short*)sync_corr)[2*n+1] += ((short*) &result)[1];
+//         sync_corr_eNB[n] += abs32(result);
+
+//       }
+
+//     }
+
+//     /*
+//     if (eNB_id == 2) {
+//       printf("sync_time_eNB %d : %d,%d (%d)\n",n,sync_corr_eNB[n],mean_val,
+//        peak_val);
+//     }
+//     */
+//     mean_val += sync_corr_eNB[n];
+
+//     if (sync_corr_eNB[n]>peak_val) {
+//       peak_val = sync_corr_eNB[n];
+//       peak_pos = n;
+//     }
+//   }
+
+//   mean_val/=length;
+
+//   *peak_val_out = peak_val;
+
+//   if (peak_val <= (40*(uint32_t)mean_val)) {
+//     LOG_D(PHY,"[SYNC TIME] No peak found (%u,%u,%"PRIu64",%"PRIu64")\n",peak_pos,peak_val,mean_val,40*mean_val);
+//     return(-1);
+//   } else {
+//     LOG_D(PHY,"[SYNC TIME] Peak found at pos %u, val = %u, mean_val = %"PRIu64"\n",peak_pos,peak_val,mean_val);
+//     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,
+//                            uint8_t sect_id,
+//                            int32_t *sync_val)
+// {
+
+//   uint8_t UE_id;
+//   uint8_t CC_id = phy_vars_eNB->CC_id;
+
+//   msg("[PHY] EMUL lte_sync_time_eNB_emul eNB %d, sect_id %d\n",phy_vars_eNB->Mod_id,sect_id);
+//   *sync_val = 0;
+
+//   for (UE_id=0; UE_id<NB_UE_INST; UE_id++) {
+//     //msg("[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);
+//     if ((PHY_vars_UE_g[UE_id][CC_id]->generate_prach == 1) && (phy_vars_eNB->Mod_id == (UE_id % NB_eNB_INST))) {
+//       *sync_val = 1;
+//       return(0);
+//     }
+//   }
+
+//   return(-1);
+// }
+// #endif
diff --git a/openair1/PHY/LTE_TRANSPORT/dlsch_demodulation_NB_IoT.c b/openair1/PHY/LTE_TRANSPORT/dlsch_demodulation_NB_IoT.c
index c9ecc295304e7a6dddc6b51c007f0fbfd38e0e71..c46b362553f79da29ddac8b7714410addacdd560 100644
--- a/openair1/PHY/LTE_TRANSPORT/dlsch_demodulation_NB_IoT.c
+++ b/openair1/PHY/LTE_TRANSPORT/dlsch_demodulation_NB_IoT.c
@@ -4138,17 +4138,17 @@ unsigned short dlsch_extract_rbs_single_NB_IoT(int **rxdataF,
           //dl_ch0++;
         }
 
-        // PBCH
-        if (subframe==0) {
-          rb_alloc_ind = 0;
-        }
+        // // PBCH
+        // if (subframe==0) {
+        //   rb_alloc_ind = 0;
+        // }
 
-        //SSS
-        if (subframe==0 && frame%2==0) {
+        //NSSS subframe
+        if (subframe==9 && frame%2==0) {
           rb_alloc_ind = 0;
         }
 
-        //PSS
+        //NPSS subframe
         if (subframe==5) {
           rb_alloc_ind = 0;
         }
diff --git a/openair1/PHY/extern_NB_IoT.h b/openair1/PHY/extern_NB_IoT.h
index 7a640d7d63f9c71662e43486e06af17655e9fde9..68b7a9823add1789e43b9049b3fbf3a88e1e0185 100644
--- a/openair1/PHY/extern_NB_IoT.h
+++ b/openair1/PHY/extern_NB_IoT.h
@@ -58,18 +58,20 @@ extern PHY_VARS_eNB_NB_IoT * PHY_vars_eNB_NB_IoT_g[MAX_eNB_NB_IoT][MAX_NUM_CCs];
 //extern MAC_xface_NB_IoT *mac_xface_NB_IoT;
 
 extern IF_Module_t *if_inst;
-/*
 
-extern short primary_synch0[144];
+
+extern short primary_synch_NB_IoT[264];
+/*
 extern short primary_synch1[144];
 extern short primary_synch2[144];
 extern unsigned char primary_synch0_tab[72];
 extern unsigned char primary_synch1_tab[72];
-extern unsigned char primary_synch2_tab[72];
-extern int16_t *primary_synch0_time; //!< index: [0..ofdm_symbol_size*2[
-extern int16_t *primary_synch1_time; //!< index: [0..ofdm_symbol_size*2[
-extern int16_t *primary_synch2_time; //!< index: [0..ofdm_symbol_size*2[
-extern int *sync_corr_ue0; //!< index [0..10*samples_per_tti[
+extern unsigned char primary_synch2_tab[72]; */
+extern int16_t *primary_synch0_time_NB_IoT; //!< index: [0..ofdm_symbol_size*2[
+// extern int16_t *primary_synch1_time; //!< index: [0..ofdm_symbol_size*2[
+// extern int16_t *primary_synch2_time; //!< index: [0..ofdm_symbol_size*2[
+extern int *sync_corr_ue0_NB_IoT; //!< 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[