Merge branch 'ru_rau_enhancement_L1_renaming' into rau_rru_reciprocity_measurements

This is for internal use at eurecom. No documentation provided.

common/ran_context.h

@@ -79,6 +79,8 @@ typedef struct {
   int *nb_L1_CC;
   /// Number of RU instances in this node
   int nb_RU;
+  /// Flag to start collecting channel estimates sent from the RRUs
+  int collect;
   /// FlexRAN context variables
   flexran_agent_info_t **flexran;
   /// eNB context variables

common/utils/T/T_messages.txt

@@ -45,6 +45,22 @@ ID = ENB_PHY_INPUT_SIGNAL
     DESC = eNodeB received signal in the time domain for a duration of 1ms
     GROUP = ALL:PHY:GRAPHIC:HEAVY:ENB
     FORMAT = int,eNB_ID : int,frame : int,subframe : int,antenna : buffer,rxdata
+ID = RAU_INPUT_SIGNAL
+    DESC = RAU received data from the RRUs
+    GROUP = ALL:PHY:GRAPHIC:HEAVY:ENB
+    FORMAT = int,tag : int,frame : int,subframe : buffer,rxdataF
+ID = RAU_INPUT_DMRS
+    DESC = RAU received DMRS from the RRUs
+    GROUP = ALL:PHY:GRAPHIC:HEAVY:ENB
+    FORMAT = int,tag : int,frame : int,subframe : buffer,rxdataF_ext
+ID = CALIBRATION_CHANNEL_ESTIMATES
+    DESC = RAU received DMRS estimates from the RRUs
+    GROUP = ALL:PHY:GRAPHIC:HEAVY:ENB
+    FORMAT = int,tag : int,frame : int,subframe : buffer,calib_ch
+ID = CALIBRATION_CHANNEL_ESTIMATES_TIME
+    DESC = RAU received DMRS estimates in the time domain from the RRUs
+    GROUP = ALL:PHY:GRAPHIC:HEAVY:ENB
+    FORMAT = int,tag : int,frame : int,subframe : buffer,calib_ch_time
 ID = ENB_PHY_OUTPUT_SIGNAL
     DESC = eNodeB sent signal in the time domain for a duration of 1ms
     GROUP = ALL:PHY:HEAVY:ENB

common/utils/T/tracer/extract.c

@@ -131,9 +131,8 @@ int main(int n, char **v)
       continue;
     if (fwrite(e.e[buffer_arg].b, e.e[buffer_arg].bsize, 1, out) != 1)
       { perror(output_file); exit(1); }
-    found++;
-    if (found == count)
-      break;
+    found = 1;
+    //break;
   }
 
   if (found == 0) printf("ERROR: event not found\n");

openair1/PHY/INIT/lte_init_ru.c

@@ -46,9 +46,9 @@ int phy_init_RU(RU_t *ru) {
 
   LOG_I(PHY,"Initializing RU signal buffers (if_south %s) nb_tx %d\n",ru_if_types[ru->if_south],ru->nb_tx);
 
-  if (ru->is_slave == 1) {
+  //if (ru->is_slave == 1) {
  	 generate_ul_ref_sigs_rx();
-  }
+  //}
 
   if (ru->if_south <= REMOTE_IF5) { // this means REMOTE_IF5 or LOCAL_RF, so allocate memory for time-domain signals 
     // Time-domain signals
@@ -62,12 +62,12 @@ int phy_init_RU(RU_t *ru) {
 	     fp->samples_per_tti*10*sizeof(int32_t));
     }
 
-    if (ru->is_slave == 1) {
+    //if (ru->is_slave == 1) {
         calibration->drs_ch_estimates_time = (int32_t**)malloc16_clear(ru->nb_rx*sizeof(int32_t*));
         for (i=0; i<ru->nb_rx; i++) {    
         	calibration->drs_ch_estimates_time[i] = (int32_t*)malloc16_clear(2*sizeof(int32_t)*fp->ofdm_symbol_size);
         }
-    }
+    //}
 
 
     for (i=0;i<ru->nb_rx;i++) {
@@ -107,7 +107,7 @@ int phy_init_RU(RU_t *ru) {
       LOG_I(PHY,"rxdataF[%d] %p for RU %d\n",i,ru->common.rxdataF[i],ru->idx);
     }
     
-     if (ru->is_slave == 1) {
+     //if (ru->is_slave == 1) {
      	// allocate FFT output buffers after extraction (RX)
     	calibration->rxdataF_ext = (int32_t**)malloc16(2*sizeof(int32_t*));
 	calibration->drs_ch_estimates = (int32_t**)malloc16(2*sizeof(int32_t*));
@@ -117,7 +117,7 @@ int phy_init_RU(RU_t *ru) {
       		LOG_I(PHY,"rxdataF_ext[%d] %p for RU %d\n",i,calibration->rxdataF_ext[i],ru->idx);
                 calibration->drs_ch_estimates[i] = (int32_t*)malloc16_clear(sizeof(int32_t)*fp->N_RB_UL*12*fp->symbols_per_tti);
     	}
-     }
+     //}
 
     /* number of elements of an array X is computed as sizeof(X) / sizeof(X[0]) */
     //AssertFatal(ru->nb_rx <= sizeof(ru->prach_rxsigF) / sizeof(ru->prach_rxsigF[0]),
@@ -196,12 +196,12 @@ void phy_free_RU(RU_t *ru)
   if (ru->if_south <= REMOTE_IF5) { // this means REMOTE_IF5 or LOCAL_RF, so free memory for time-domain signals
     for (i = 0; i < ru->nb_tx; i++) free_and_zero(ru->common.txdata[i]);
     for (i = 0; i < ru->nb_rx; i++) free_and_zero(ru->common.rxdata[i]);
-    if (ru->is_slave == 1) {  
+    //if (ru->is_slave == 1) {  
     	for (i = 0; i < ru->nb_rx; i++) {
        		free_and_zero(calibration->drs_ch_estimates_time[i]);
         }
         free_and_zero(calibration->drs_ch_estimates_time);
-    }
+    //}
     free_and_zero(ru->common.txdata);
     free_and_zero(ru->common.rxdata);
   } // else: IF5 or local RF -> nothing to free()
@@ -217,14 +217,14 @@ void phy_free_RU(RU_t *ru)
     // free FFT output buffers (RX)
     for (i = 0; i < ru->nb_rx; i++) free_and_zero(ru->common.rxdataF[i]);
     free_and_zero(ru->common.rxdataF);
-    if (ru->is_slave == 1) {
+    //if (ru->is_slave == 1) {
     	for (i = 0; i < ru->nb_rx; i++) {
         	free_and_zero(calibration->rxdataF_ext[i]);
   		free_and_zero(calibration->drs_ch_estimates[i]);
         }
         free_and_zero(calibration->rxdataF_ext);
         free_and_zero(calibration->drs_ch_estimates);
-    }
+    //}
 
     for (i = 0; i < ru->nb_rx; i++) {
       free_and_zero(ru->prach_rxsigF[i]);

openair1/PHY/LTE_TRANSPORT/if4_tools.c

@@ -117,6 +117,57 @@ void send_IF4p5(RU_t *ru, int frame, int subframe, uint16_t packet_type) {
       slotoffsetF  += fp->ofdm_symbol_size;
       blockoffsetF += fp->ofdm_symbol_size;    
     }
+  } else if (packet_type == IF4p5_PULCALIB) {
+    	LOG_D(PHY,"send PULCALIB_IF4p5: RU %d frame %d, subframe %d\n",ru->idx,frame,subframe);
+
+    AssertFatal(subframe_select(fp,subframe)==SF_S, "calling PULCALIB in non-S subframe\n"); 
+    db_fulllength = 12*fp->N_RB_UL;
+    db_halflength = (db_fulllength)>>1;
+    slotoffsetF   = 0;
+    blockoffsetF  = (fp->ofdm_symbol_size)-db_halflength;
+    
+
+    if (eth->flags == ETH_RAW_IF4p5_MODE) {
+      packet_header = (IF4p5_header_t *)(tx_buffer + MAC_HEADER_SIZE_BYTES);
+      data_block = (uint16_t*)(tx_buffer + MAC_HEADER_SIZE_BYTES + sizeof_IF4p5_header_t);
+    } else {
+      packet_header = (IF4p5_header_t *)(tx_buffer);
+      data_block = (uint16_t*)(tx_buffer + sizeof_IF4p5_header_t);
+    }    
+    gen_IF4p5_ul_header(packet_header, packet_type, frame, subframe);
+
+    AssertFatal(rxdataF[0]!=NULL,"rxdataF[0] is null\n");
+    for (symbol_id=0; symbol_id<11; symbol_id++) {
+    if (symbol_id==3 || symbol_id==10) {
+      for (int antenna_id=0; antenna_id<ru->nb_tx; antenna_id++) {
+        for (element_id=0; element_id<db_halflength; element_id++) {
+          i = (uint16_t*) &rxdataF[antenna_id][blockoffsetF+element_id];
+          data_block[element_id] = ((uint16_t) lin2alaw_if4p5[*i]) | (lin2alaw_if4p5[*(i+1)]<<8);
+
+          i = (uint16_t*) &rxdataF[antenna_id][slotoffsetF+element_id];
+          data_block[element_id+db_halflength] = ((uint16_t) lin2alaw_if4p5[*i]) | (lin2alaw_if4p5[*(i+1)]<<8);
+         }
+      }
+      VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_COMPR_IF, 0 );
+      packet_header->frame_status &= ~(0x7);
+      packet_header->frame_status |= (ru->nb_rx-1);
+
+      packet_header->frame_status &= ~(0x000f<<26);
+      packet_header->frame_status |= (symbol_id&0x000f)<<26; 
+      if (ru->idx<=1) VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE_IF0+ru->idx, 1 );          
+      if ((ru->ifdevice.trx_write_func(&ru->ifdevice,
+                                       symbol_id,
+                                       &tx_buffer,
+                                       db_fulllength*ru->nb_rx, 
+                                       1,
+                                       IF4p5_PULCALIB)) < 0) {
+        perror("ETHERNET write for IF4p5_PULCALIB\n");
+      }
+      if (ru->idx<=1) VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE_IF0+ru->idx, 0 );
+      }
+      slotoffsetF  += fp->ofdm_symbol_size;
+      blockoffsetF += fp->ofdm_symbol_size;
+  }
   } else if ((packet_type == IF4p5_PULFFT)||
 	     (packet_type == IF4p5_PULTICK)){
     db_fulllength = 12*fp->N_RB_UL;
@@ -388,6 +439,35 @@ void recv_IF4p5(RU_t *ru, int *frame, int *subframe, uint16_t *packet_type, uint
       data_block+=db_fulllength;
     }
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_DECOMPR_IF, 0 );	
+  } else if (*packet_type == IF4p5_PULCALIB) {
+    db_fulllength/=ru->nb_rx;
+    db_halflength/=ru->nb_rx;         
+    *symbol_number = ((packet_header->frame_status)>>26)&0x000f;         
+
+    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_RECV_IF4_SYMBOL, *symbol_number );
+    if (ru->idx==0) LOG_D(PHY,"UL_IF4p5: RU %d : frame %d, subframe %d, symbol %d\n",ru->idx,*frame,*subframe,*symbol_number);
+
+
+    slotoffsetF = (*symbol_number)*(fp->ofdm_symbol_size);
+    blockoffsetF = slotoffsetF + fp->ofdm_symbol_size - db_halflength;
+    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_DECOMPR_IF, 1 );
+    for (int antenna_id=0;antenna_id<ru->nb_rx;antenna_id++) { 
+      for (element_id=0; element_id<db_halflength; element_id++) {
+        i = (uint16_t*) &rxdataF[antenna_id][blockoffsetF+element_id];
+        *i = alaw2lin_if4p5[ (data_block[element_id] & 0xff) ]; 
+        *(i+1) = alaw2lin_if4p5[ (data_block[element_id]>>8) ];
+
+        i = (uint16_t*) &rxdataF[antenna_id][slotoffsetF+element_id];
+        *i = alaw2lin_if4p5[ (data_block[element_id+db_halflength] & 0xff) ]; 
+        *(i+1) = alaw2lin_if4p5[ (data_block[element_id+db_halflength]>>8) ];
+
+        //if (element_id==0) LOG_I(PHY,"recv_if4p5: symbol %d rxdata0 = (%u,%u)\n",*symbol_number,*i,*(i+1));
+      }
+      LOG_D(PHY,"PULCALIB_IF4p5: CC_id %d : frame %d, subframe %d (symbol %d)=> %d dB\n",ru->idx,*frame,*subframe,*symbol_number,
+            dB_fixed(signal_energy((int*)&rxdataF[antenna_id][slotoffsetF],db_halflength)+
+                     signal_energy((int*)&rxdataF[antenna_id][blockoffsetF],db_halflength)));
+    }
+    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_DECOMPR_IF, 0 );
   } else if (*packet_type >= IF4p5_PRACH &&
 	     *packet_type <= IF4p5_PRACH + 4) {  
 

openair1/PHY/LTE_TRANSPORT/if4_tools.h

@@ -44,6 +44,7 @@
 #define IF4p5_PRACH_BR_CE2 0x0024
 #define IF4p5_PRACH_BR_CE3 0x0025
 #define IF4p5_PULTICK 0x0026
+#define IF4p5_PULCALIB 0x0027
 
 struct IF4p5_header {  
   /// Type

openair1/PHY/MODULATION/ul_7_5_kHz.c

@@ -99,7 +99,7 @@ void remove_7_5_kHz(RU_t *ru,uint8_t slot)
 #endif
     // apply 7.5 kHz
 
-    //      if (((slot>>1)&1) == 0) { // apply the sinusoid from the table directly
+    //      if (((slot>>1)&1) == 0)  // apply the sinusoid from the table directly
     for (i=0; i<(len>>2); i++) {
 
 #if defined(__x86_64__) || defined(__i386__)
@@ -157,7 +157,32 @@ void remove_7_5_kHz(RU_t *ru,uint8_t slot)
                            (2*frame_parms->nb_prefix_samples)+
                            frame_parms->nb_prefix_samples0],
              (frame_parms->ofdm_symbol_size + frame_parms->nb_prefix_samples)*sizeof(int32_t));
-}  
+    }
+    
+    // undo 7.5 kHz offset for symbol 10 in case RU is master (for OTA synchronization)
+
+/*    if (slot == 3){
+      memcpy((void*)&rxdata_7_5kHz[aa][(3*frame_parms->ofdm_symbol_size)+
+                                (2*frame_parms->nb_prefix_samples)+
+                                frame_parms->nb_prefix_samples0],
+             (void*)&rxdata[aa][slot_offset+ru->N_TA_offset+
+                           (3*frame_parms->ofdm_symbol_size)+
+                           (2*frame_parms->nb_prefix_samples)+
+                           frame_parms->nb_prefix_samples0],
+             (frame_parms->ofdm_symbol_size + frame_parms->nb_prefix_samples)*sizeof(int32_t));
+    }*/
+
+    if (slot == 3){
+      memcpy((void*)&rxdata_7_5kHz[aa][(10*frame_parms->ofdm_symbol_size)+
+                                (8*frame_parms->nb_prefix_samples)+
+                                2*frame_parms->nb_prefix_samples0],
+             (void*)&rxdata[aa][slot_offset+ru->N_TA_offset+
+                           (3*frame_parms->ofdm_symbol_size)+
+                           (2*frame_parms->nb_prefix_samples)+
+                           frame_parms->nb_prefix_samples0],
+             (frame_parms->ofdm_symbol_size + frame_parms->nb_prefix_samples)*sizeof(int32_t));
+    }
+
 }
 }
 

openair1/PHY/defs_eNB.h

@@ -299,7 +299,8 @@ typedef enum {
   RU_RUN    = 3,
   RU_ERROR  = 4,
   RU_SYNC   = 5,
-  RU_CHECK_SYNC = 6
+  RU_CHECK_SYNC = 6,
+  RU_LOST_SYNC = 7
 } rru_state_t;
 
 /// Some commamds to RRU. Not sure we should do it like this !
@@ -311,9 +312,13 @@ typedef enum {
 } rru_cmd_t;
 
 typedef struct RU_t_s{
+  /// tag of this ru
+  uint32_t tag;
+  /// number of slave RRUs
+  uint32_t p;
   /// index of this ru
   uint32_t idx;
- /// Pointer to configuration file
+  /// Pointer to configuration file
   char *rf_config_file;
   /// southbound interface
   RU_if_south_t if_south;
@@ -345,6 +350,8 @@ typedef struct RU_t_s{
   int wait_cnt;
   /// counter to delay start of slave RUs until stable synchronization
   int wait_check;
+  /// counter to count missed synch events during synchronization of RU
+  int missed_synch_events;
   /// Total gain of receive chain
   uint32_t             rx_total_gain_dB;
   /// number of bands that this device can support
@@ -534,6 +541,10 @@ typedef struct RRU_capabilities_s {
 
 typedef struct RRU_config_s {
 
+  /// tag of an RU
+  uint32_t tag;
+  /// number of slave RRUs
+  uint32_t p;
   /// Fronthaul format
   RU_if_south_t FH_fmt;
   /// number of EUTRA bands (<=4) configured in RRU

openair1/SCHED/ru_procedures.c

@@ -84,7 +84,7 @@ void feptx0(RU_t *ru,int slot) {
 
   slot_offset = subframe*fp->samples_per_tti + (slot*(fp->samples_per_tti>>1));
 
-  //LOG_D(PHY,"SFN/SF:RU:TX:%d/%d Generating slot %d\n",ru->proc.frame_tx, ru->proc.subframe_tx,slot);
+  LOG_D(PHY,"SFN/SF:RU:TX:%d/%d Generating slot %d\n",ru->proc.frame_tx, ru->proc.subframe_tx,slot);
 
   for (aa=0; aa<ru->nb_tx; aa++) {
     if (fp->Ncp == EXTENDED) PHY_ofdm_mod(&ru->common.txdataF_BF[aa][slot*slot_sizeF],
@@ -116,7 +116,8 @@ void feptx0(RU_t *ru,int slot) {
 			   0,
 			   fp->N_RB_DL,
 			   aa);
-      } 
+      }
+
       normal_prefix_mod(&ru->common.txdataF_BF[aa][slot*slot_sizeF],
                         (int*)&ru->common.txdata[aa][slot_offset],
                         num_symb,
@@ -225,7 +226,9 @@ void feptx_ofdm_2thread(RU_t *ru) {
 
   //VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_RU_FEPTX_OFDM , 1 );
 
-  if (subframe_select(fp,subframe)==SF_DL) {
+  // The 2nd check is to force the slave RRUs to send DMRS at symbol 10-subframe 1-slot 1 
+  if (subframe_select(fp,subframe)==SF_DL || ((subframe_select(fp,subframe)==SF_DL || subframe==1) /*&& ru->is_slave==1*/)) {
+  //  if (subframe_select(fp,subframe)==SF_DL) {
     // If this is not an S-subframe
     if (pthread_mutex_timedlock(&proc->mutex_feptx,&wait) != 0) {
       printf("[RU] ERROR pthread_mutex_lock for feptx thread (IC %d)\n", proc->instance_cnt_feptx);
@@ -510,8 +513,7 @@ void fep0(RU_t *ru,int slot) {
   LTE_DL_FRAME_PARMS *fp = &ru->frame_parms;
   int l;
 
-    //printf("fep0: slot %d\n",slot);
-
+  LOG_D(PHY,"fep0: slot %d, subframe %d\n",slot,proc->subframe_rx);
   //VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_RU_FEPRX+slot, 1);
   remove_7_5_kHz(ru,(slot&1)+(proc->subframe_rx<<1));
   for (l=0; l<fp->symbols_per_tti/2; l++) {
@@ -681,6 +683,58 @@ void ru_fep_full_2thread(RU_t *ru) {
     printf("delay in fep wait on condition in frame_rx: %d  subframe_rx: %d \n",proc->frame_rx,proc->subframe_rx);
   }
 
+
+  /*  if (proc->subframe_rx==1 && ru->is_slave==0) {
+//        LOG_I(PHY,"******************** Master receives DMRS from slave\n");   
+        ru->wait_check++;
+        ulsch_extract_rbs_single(ru->common.rxdataF,
+                                 calibration->rxdataF_ext,
+                                 0,
+                                 fp->N_RB_DL,
+                                 3%(fp->symbols_per_tti/2),// l = symbol within slot
+                                 10/(fp->symbols_per_tti/2),// Ns = slot number 
+                                 fp);
+	/*      if (proc->frame_rx==205) { // libra
+                LOG_I(PHY,"~~~~~~~~~~~~~~~~~~~~~~~~@@@@@@@@@@@@@@@@@@ ru_fep_full_2thread: frame %d, subframe %d\n",$
+                //LOG_M("rxdata.m","rxdata",&ru->common.rxdata[0][0], fp->samples_per_tti*2,1,1); // save 2 first su$
+                LOG_M("rxdata.m","rxdata",&ru->common.rxdata[0][0], fp->samples_per_tti*10,1,1); // save 1 frame
+                //LOG_M("rxdataF.m","rxdataF",&ru->common.rxdataF[0][0],2*fp->ofdm_symbol_size*fp->symbols_per_tti,1$
+                LOG_M("rxdataF.m","rxdataF",&ru->common.rxdataF[0][0],fp->ofdm_symbol_size*fp->symbols_per_tti*10,1,$
+                LOG_M("rxdataF_ext.m","rxdataFext",&calibration->rxdataF_ext[0][0], 14*12*(fp->N_RB_DL),1,1);
+                //exit(-1);
+        }*/
+/*      if (proc->frame_rx==204) { //aquila
+                LOG_I(PHY,"~~~~~~~~~~~~~~~~~~~~~~~~@@@@@@@@@@@@@@@@@@ ru_fep_full_2thread: frame %d, subframe %d\n",$
+                //LOG_M("rxdata.m","rxdata",&ru->common.rxdata[0][0], fp->samples_per_tti*2,1,1); // save 2 first su$
+                LOG_M("rxdata.m","rxdata",&ru->common.rxdata[0][0], fp->samples_per_tti*10,1,1); // save 1 frame
+                //LOG_M("rxdataF.m","rxdataF",&ru->common.rxdataF[0][0],2*fp->ofdm_symbol_size*fp->symbols_per_tti,1$
+                LOG_M("rxdataF.m","rxdataF",&ru->common.rxdataF[0][0],fp->ofdm_symbol_size*fp->symbols_per_tti*10,1,$
+                LOG_M("rxdataF_ext.m","rxdataFext",&calibration->rxdataF_ext[0][0], 14*12*(fp->N_RB_DL),1,1);
+                //exit(-1);
+	 }*/
+        /*lte_ul_channel_estimation_RRU(fp,
+                                  calibration->drs_ch_estimates,
+                                  calibration->drs_ch_estimates_time,
+                                  calibration->rxdataF_ext,
+                                  fp->N_RB_DL, 
+                                  proc->frame_rx,
+                                  proc->subframe_rx,
+                                  0,
+                                  0,
+                                  0,
+                                  10,
+                                  0,
+                                  0);
+
+        if (ru->wait_check==1000) {
+                LOG_M("rxdata.m","rxdata",&ru->common.rxdata[0][0], fp->samples_per_tti*2,1,1); // save 2 first subframes
+                LOG_M("rxdataF.m","rxdataF",&ru->common.rxdataF[0][0],2*fp->ofdm_symbol_size*fp->symbols_per_tti,1,1);
+                LOG_M("rxdataF_ext.m","rxdataFext",&calibration->rxdataF_ext[0][10*12*fp->N_RB_DL], 12*(fp->N_RB_DL),1,1);
+                //LOG_M("channel_est.m","ch_est",&calibration->drs_ch_estimates[0][10*12*fp->N_RB_DL], 12*(fp->N_RB_DL),1,1);
+                LOG_I(PHY,"******************** Master receives DMRS from slave at frame %d\n",proc->frame_rx); 
+        }
+  }*/
+
   if (proc->subframe_rx==1 && ru->is_slave==1/* && ru->state == RU_CHECK_SYNC*/) {
 
         //LOG_I(PHY,"Running check synchronization procedure for frame %d\n", proc->frame_rx);
@@ -692,6 +746,17 @@ void ru_fep_full_2thread(RU_t *ru) {
                                  3/(fp->symbols_per_tti/2),// Ns = slot number 
                                  fp);
         
+/*        if (proc->frame_rx==189) {
+        LOG_I(PHY,"~~~~~~~~~~~~~~~~~~~~~~~~@@@@@@@@@@@@@@@@@@ ru_fep_full_2thread: su$
+        //LOG_M("rxdata.m","rxdata",&ru->common.rxdata[0][0], fp->samples_per_tti*2,1$
+        LOG_M("rxdata.m","rxdata",&ru->common.rxdata[0][0], fp->samples_per_tti*10,1,$
+        //LOG_M("rxdataF.m","rxdataF",&ru->common.rxdataF[0][0],2*fp->ofdm_symbol_siz$
+        LOG_M("rxdataF.m","rxdataF",&ru->common.rxdataF[0][0],fp->ofdm_symbol_size*fp$
+        LOG_M("rxdataF_ext.m","rxdataFext",&calibration->rxdataF_ext[0][0], 14*12*(fp$
+        //exit(-1);
+        }
+*/
+
 	/*lte_ul_channel_estimation((PHY_VARS_eNB *)NULL,
 				  proc,
                                   ru->idx,
@@ -718,10 +783,26 @@ void ru_fep_full_2thread(RU_t *ru) {
      				     		       ru->idx);
         if (ru->state == RU_CHECK_SYNC) {
           if ((check_sync_pos >= 0 && check_sync_pos<8) || (check_sync_pos < 0 && check_sync_pos>-8)) {
-    		  LOG_I(PHY,"~~~~~~~~~~~    check_sync_pos %d, frame %d, cnt %d\n",check_sync_pos,proc->frame_rx,ru->wait_check); 
+    		  LOG_I(PHY,"~~~~~~~~~~~    check_sync_pos %d, frame %d, cnt %d, missed %d\n",check_sync_pos,proc->frame_rx,ru->wait_check,ru->missed_synch_events); 
                   ru->wait_check++;
           }
+          else {
+            ru->missed_synch_events++;
+            LOG_I(PHY,"!!!!!!!!!!!!    check_sync_pos %d, frame %d, cnt %d, missed %d\n",check_sync_pos,proc->frame_rx,ru->wait_check,ru->missed_synch_events);
+          }
+          
+          if (ru->missed_synch_events > 2) {
+            ru->in_synch = 0;
+            if (ru->stop_rf) {
+               ru->stop_rf(ru);
+               ru->state = RU_SYNC;
+               ru->cmd   = EMPTY;
+               LOG_I(PHY,"RU %d rf device stopped\n",ru->idx);
+               LOG_M("rxdata.m","rxdata",&ru->common.rxdata[0][0], fp->samples_per_tti*2,1,1);
+               exit(-1);
+            } else AssertFatal(1==0,"ru->stop_rf doesn't exist\n");
 
+          } 
           if (ru->wait_check==20) { 
 	  	ru->state = RU_RUN;
  		ru->wait_check = 0;
@@ -731,19 +812,22 @@ void ru_fep_full_2thread(RU_t *ru) {
         	LOG_I(PHY,"Sending RRU_sync_ok to RAU\n");
         	AssertFatal((ru->ifdevice.trx_ctlsend_func(&ru->ifdevice,&rru_config_msg,rru_config_msg.len)!=-1),"Failed to send msg to RAU %d\n",ru->idx);
                 //LOG_I(PHY,"~~~~~~~~~ RU_RUN\n");
-          	/*LOG_M("dmrs_time.m","dmrstime",calibration->drs_ch_estimates_time[0], (fp->ofdm_symbol_size),1,1);
-		LOG_M("rxdataF_ext.m","rxdataFext",&calibration->rxdataF_ext[0][36*fp->N_RB_DL], 12*(fp->N_RB_DL),1,1);		
-		LOG_M("drs_seq0.m","drsseq0",ul_ref_sigs_rx[0][0][23],600,1,1);
-		LOG_M("rxdata.m","rxdata",&ru->common.rxdata[0][0], fp->samples_per_tti*2,1,1);
-		exit(-1);*/
+          	//LOG_M("dmrs_time.m","dmrstime",calibration->drs_ch_estimates_time[0], (fp->ofdm_symbol_size),1,1);
+		//LOG_M("rxdataF_ext.m","rxdataFext",&calibration->rxdataF_ext[0][36*fp->N_RB_DL], 12*(fp->N_RB_DL),1,1);		
+		//LOG_M("drs_seq0.m","drsseq0",ul_ref_sigs_rx[0][0][23],600,1,1);
+		//LOG_M("rxdata.m","rxdata",&ru->common.rxdata[0][0], fp->samples_per_tti*2,1,1);
+		//exit(-1);
 	 } 
        }
        else if (ru->state == RU_RUN) {
        	// check for synchronization error
        	if (check_sync_pos >= 8 || check_sync_pos<=-8) {
 	 	LOG_E(PHY,"~~~~~~~~~~~~~~ check_sync_pos %d, frame %d ---> LOST SYNC-EXIT\n", check_sync_pos, proc->frame_rx);
-LOG_M("rxdata.m","rxdata",&ru->common.rxdata[0][0], fp->samples_per_tti*2,1,1);		
-exit(-1);
+                /*
+		LOG_M("dmrs_time.m","dmrstime",calibration->drs_ch_estimates_time[0], (fp->ofdm_symbol_size),1,1);
+		LOG_M("rxdata.m","rxdata",&ru->common.rxdata[0][0], fp->samples_per_tti*2,1,1);		
+		exit(-1);
+                */
 	}
        }
     

targets/ARCH/ETHERNET/USERSPACE/LIB/eth_raw.c

@@ -216,6 +216,8 @@ int trx_eth_write_raw_IF4p5(openair0_device *device, openair0_timestamp timestam
     packet_size = RAW_IF4p5_PULFFT_SIZE_BYTES(nblocks);    
   } else if (flags == IF4p5_PULTICK) {
     packet_size = RAW_IF4p5_PULTICK_SIZE_BYTES;    
+  } else if (flags == IF4p5_PULCALIB) {
+    packet_size = RAW_IF4p5_PULCALIB_SIZE_BYTES(nblocks);
   } else if (flags == IF5_MOBIPASS) {
     packet_size = RAW_IF5_MOBIPASS_SIZE_BYTES;
   } else {

targets/ARCH/ETHERNET/USERSPACE/LIB/eth_udp.c

@@ -235,7 +235,9 @@ int trx_eth_write_udp_IF4p5(openair0_device *device, openair0_timestamp timestam
   } else if (flags == IF4p5_PULFFT) {
     packet_size = UDP_IF4p5_PULFFT_SIZE_BYTES(nblocks); 
   } else if (flags == IF4p5_PULTICK) {
-    packet_size = UDP_IF4p5_PULTICK_SIZE_BYTES; 
+    packet_size = UDP_IF4p5_PULTICK_SIZE_BYTES;
+  } else if (flags == IF4p5_PULCALIB) {
+    packet_size = UDP_IF4p5_PULCALIB_SIZE_BYTES(nblocks); 
   } else if ((flags >= IF4p5_PRACH)&&
              (flags <= (IF4p5_PRACH+4))) {  
     packet_size = UDP_HEADER_SIZE_BYTES + IPV4_HEADER_SIZE_BYTES + sizeof_IF4p5_header_t + (nsamps<<1);   

targets/ARCH/ETHERNET/USERSPACE/LIB/if_defs.h

@@ -75,10 +75,12 @@
 #define RAW_IF4p5_PULFFT_SIZE_BYTES(nblocks) (MAC_HEADER_SIZE_BYTES + sizeof_IF4p5_header_t + DATA_BLOCK_SIZE_BYTES(nblocks))  
 #define RAW_IF4p5_PULTICK_SIZE_BYTES (MAC_HEADER_SIZE_BYTES + sizeof_IF4p5_header_t)  
 #define RAW_IF4p5_PRACH_SIZE_BYTES (MAC_HEADER_SIZE_BYTES + sizeof_IF4p5_header_t + PRACH_BLOCK_SIZE_BYTES)
+#define RAW_IF4p5_PULCALIB_SIZE_BYTES(nblocks) (MAC_HEADER_SIZE_BYTES + sizeof_IF4p5_header_t + DATA_BLOCK_SIZE_BYTES(nblocks)) 
 #define UDP_IF4p5_PDLFFT_SIZE_BYTES(nblocks) (UDP_HEADER_SIZE_BYTES + IPV4_HEADER_SIZE_BYTES + sizeof_IF4p5_header_t + DATA_BLOCK_SIZE_BYTES(nblocks))  
 #define UDP_IF4p5_PULFFT_SIZE_BYTES(nblocks) (UDP_HEADER_SIZE_BYTES + IPV4_HEADER_SIZE_BYTES + sizeof_IF4p5_header_t + DATA_BLOCK_SIZE_BYTES(nblocks))  
 #define UDP_IF4p5_PULTICK_SIZE_BYTES (UDP_HEADER_SIZE_BYTES + IPV4_HEADER_SIZE_BYTES + sizeof_IF4p5_header_t)  
 #define UDP_IF4p5_PRACH_SIZE_BYTES (UDP_HEADER_SIZE_BYTES + IPV4_HEADER_SIZE_BYTES + sizeof_IF4p5_header_t + PRACH_BLOCK_SIZE_BYTES)
+#define UDP_IF4p5_PULCALIB_SIZE_BYTES(nblocks) (UDP_HEADER_SIZE_BYTES + IPV4_HEADER_SIZE_BYTES + sizeof_IF4p5_header_t + DATA_BLOCK_SIZE_BYTES(nblocks))
 
 // Mobipass packet sizes
 #define RAW_IF5_MOBIPASS_BLOCK_SIZE_BYTES 1280

targets/RT/USER/lte-ru.c

@@ -201,42 +201,124 @@ void fh_if5_south_in(RU_t *ru,int *frame, int *subframe) {
 void fh_if4p5_south_in(RU_t *ru,int *frame,int *subframe) {
   LTE_DL_FRAME_PARMS *fp = &ru->frame_parms;
   RU_proc_t *proc = &ru->proc;
-  int f,sf;
+  RU_CALIBRATION *calibration = &ru->calibration;
+  int f,sf,Ns,l,u;
+
   uint16_t packet_type;
   uint32_t symbol_number=0;
   uint32_t symbol_mask_full;
-  int pultick_received=0;
+  int pultick_received=0;  
 
+  if (ru->is_slave==1 && ru->wait_cnt!=0) RC.collect = 0;
 
-  if ((fp->frame_type == TDD) && (subframe_select(fp,*subframe)==SF_S))  
-    symbol_mask_full = (1<<fp->ul_symbols_in_S_subframe)-1;   
-  else     
+  if ((fp->frame_type == TDD) && (subframe_select(fp,*subframe)==SF_S)) {
+    if (*subframe == 1) {  
+    	symbol_mask_full = (1<<11)-1;
+    } else {    	
+    	symbol_mask_full = (1<<fp->ul_symbols_in_S_subframe)-1;   
+    }
+  } else {     
     symbol_mask_full = (1<<fp->symbols_per_tti)-1; 
+  }
+  
   LOG_D(PHY,"fh_if4p5_south_in: RU %d, frame %d, subframe %d, ru %d, mask %x\n",ru->idx,*frame,*subframe,ru->idx,proc->symbol_mask[*subframe]);
   AssertFatal(proc->symbol_mask[*subframe]==0 || proc->symbol_mask[*subframe]==symbol_mask_full,"rx_fh_if4p5: proc->symbol_mask[%d] = %x\n",*subframe,proc->symbol_mask[*subframe]);
+  if (proc->symbol_mask[*subframe] == symbol_mask_full) proc->symbol_mask[*subframe] = 0;
+  
   if (proc->symbol_mask[*subframe]==0) { // this is normal case, if not true then we received a PULTICK before the previous subframe was finished 
-     do {
-       recv_IF4p5(ru, &f, &sf, &packet_type, &symbol_number);
-       if (oai_exit == 1 || ru->cmd== STOP_RU) break;
-       if (packet_type == IF4p5_PULFFT) proc->symbol_mask[sf] = proc->symbol_mask[sf] | (1<<symbol_number);
-       else if (packet_type == IF4p5_PULTICK) {           
-         proc->symbol_mask[sf] = symbol_mask_full;
-         pultick_received++;
-/*
-         if ((proc->first_rx==0) && (f!=*frame)) LOG_E(PHY,"rx_fh_if4p5: PULTICK received frame %d != expected %d (RU %d) \n",f,*frame, ru->idx);       
-         else if ((proc->first_rx==0) && (sf!=*subframe)) LOG_E(PHY,"rx_fh_if4p5: PULTICK received subframe %d != expected %d (first_rx %d)\n",sf,*subframe,proc->first_rx);       
-         else break; */
-         if (f==*frame || sf==*subframe) break;
-       } else if (packet_type == IF4p5_PRACH) {
-      // nothing in RU for RAU
-       }
-       LOG_D(PHY,"rx_fh_if4p5: subframe %d symbol mask %x\n",*subframe,proc->symbol_mask[*subframe]);
-     } while(proc->symbol_mask[*subframe] != symbol_mask_full);    
-  }
-  else {
-   f = *frame;
-   sf = *subframe;
-  }
+  	do {
+    		recv_IF4p5(ru, &f, &sf, &packet_type, &symbol_number);
+    		if (oai_exit == 1 || ru->cmd== STOP_RU) break;
+    		if (packet_type == IF4p5_PULFFT) proc->symbol_mask[sf] = proc->symbol_mask[sf] | (1<<symbol_number);
+    		else if (packet_type == IF4p5_PULCALIB) {
+    			proc->symbol_mask[sf] = (2<<symbol_number)-1;
+			LOG_D(PHY,"symbol_mask[%d] %d\n",sf,proc->symbol_mask[sf]);
+    		}
+    		else if (packet_type == IF4p5_PULTICK) {           
+			proc->symbol_mask[sf] = symbol_mask_full;
+	                pultick_received++;
+			/*
+         		if ((proc->first_rx==0) && (f!=*frame)) LOG_E(PHY,"rx_fh_if4p5: PULTICK received frame %d != expected %d (RU %d) \n",f,*frame, ru->idx);       
+         		else if ((proc->first_rx==0) && (sf!=*subframe)) LOG_E(PHY,"rx_fh_if4p5: PULTICK received subframe %d != expected %d (first_rx %d)\n",sf,*subframe,proc->first_rx);       
+         		else break; */
+         		if (f==*frame || sf==*subframe) break;
+      		} else if (packet_type == IF4p5_PRACH) {
+      			// nothing in RU for RAU
+    		}
+    		LOG_D(PHY,"rx_fh_if4p5: RU %d, subframe %d symbol %d, mask %x\n",ru->idx,sf,symbol_number,proc->symbol_mask[*subframe]);
+  	} while(proc->symbol_mask[*subframe] != symbol_mask_full);    
+   else {
+   	f = *frame;
+   	sf = *subframe;
+   }
+
+  T(T_RAU_INPUT_SIGNAL, T_INT(ru->idx), T_INT(f), T_INT(sf),
+          T_BUFFER(&ru->common.rxdataF[0][0],
+          fp->symbols_per_tti*fp->ofdm_symbol_size*sizeof(int32_t)));
+
+  if (ru->is_slave==1 && ru->wait_cnt==0 /*&& ru->state!=RU_LOST_SYNC*/) RC.collect = 1;
+
+  if (ru->wait_cnt==0 && packet_type == IF4p5_PULCALIB && RC.collect==1) {
+
+  	T(T_RAU_INPUT_SIGNAL, T_INT(ru->idx), T_INT(f), T_INT(sf),
+          T_BUFFER(&ru->common.rxdataF[0][0],
+          fp->symbols_per_tti*fp->ofdm_symbol_size*sizeof(int32_t)));
+
+        // Estimate calibration channel estimates:
+  	Ns = (ru->is_slave==0 ? 1 : 1);
+	l = (ru->is_slave==0 ? 10 : 10);
+	u = (ru->is_slave==0 ? 0 : 0);
+	ru->frame_parms.nb_antennas_rx = ru->nb_rx;		
+        ulsch_extract_rbs_single(ru->common.rxdataF,
+                                 calibration->rxdataF_ext,
+                                 0,
+                                 fp->N_RB_DL,
+				 3%(fp->symbols_per_tti/2),// l = symbol within slot
+                                 Ns, 
+                                 fp);
+
+	// OR should I call just: lte_ul_channel_estimation();
+   	/*lte_ul_channel_estimation((PHY_VARS_eNB *)NULL,
+                                  proc,
+                                  ru->idx,
+                                  3%(fp->symbols_per_tti/2),
+                                  Ns);
+	*/
+        lte_ul_channel_estimation_RRU(fp,
+                                  calibration->drs_ch_estimates,
+                                  calibration->drs_ch_estimates_time,
+                                  calibration->rxdataF_ext,
+                                  fp->N_RB_DL, 
+                                  f,
+                                  sf,
+                                  u,
+                                  0,
+                                  0,
+                                  l,
+                                  0,
+                                  0);
+	
+		T(T_CALIBRATION_CHANNEL_ESTIMATES, T_INT(ru->idx), T_INT(f), T_INT(sf),
+                T_BUFFER(&calibration->drs_ch_estimates[0][l*12*fp->N_RB_UL],
+                12*fp->N_RB_UL*sizeof(int32_t)));
+
+		T(T_RAU_INPUT_DMRS, T_INT(ru->idx), T_INT(f), T_INT(sf),
+                T_BUFFER(&calibration->rxdataF_ext[0][l*12*fp->N_RB_UL],
+                12*fp->N_RB_UL*sizeof(int32_t)));
+
+		T(T_CALIBRATION_CHANNEL_ESTIMATES_TIME, T_INT(ru->idx), T_INT(f), T_INT(sf),
+                T_BUFFER(calibration->drs_ch_estimates_time[0],
+                fp->ofdm_symbol_size*sizeof(int32_t)));
+
+/*		if (f==251 && ru->idx==0) {
+			//LOG_M("rxdataF_ext.m","rxdataFext",&calibration->rxdataF_ext[0][0], 14*12*(fp->N_RB_DL),1,1);
+			LOG_M("dmrs_time.m","dmrstime",calibration->drs_ch_estimates_time[0], fp->ofdm_symbol_size,1,1);
+			//exit(-1);
+		}*/
+  //}
+ }
+  
+
   //calculate timestamp_rx, timestamp_tx based on frame and subframe
   proc->subframe_rx  = sf;
   proc->frame_rx     = f;
@@ -414,7 +496,7 @@ void fh_if4p5_north_asynch_in(RU_t *ru,int *frame,int *subframe) {
   symbol_number = 0;
   symbol_mask = 0;
   symbol_mask_full = ((subframe_select(fp,*subframe) == SF_S) ? (1<<fp->dl_symbols_in_S_subframe) : (1<<fp->symbols_per_tti))-1;
-  LOG_D(PHY,"fh_if4p5_north_asynch_in: RU %d, frame %d, subframe %d\n",ru->idx,*frame,*subframe);
+  LOG_D(PHY,"fh_if4p5_north_asynch_in: RU %d, frame %d, subframe %d, packet_type %x\n",ru->idx,*frame,*subframe,packet_type);
   do {   
     recv_IF4p5(ru, &frame_tx, &subframe_tx, &packet_type, &symbol_number);
     LOG_D(PHY,"income frame.subframe %d.%d, our frame.subframe.symbol_number %d.%d.%d (symbol mask %x)\n",frame_tx,subframe_tx,*frame,*subframe,symbol_number,symbol_mask);
@@ -441,6 +523,15 @@ void fh_if4p5_north_asynch_in(RU_t *ru,int *frame,int *subframe) {
                   "frame_tx %d is not what we expect %d\n",frame_tx,*frame);
       AssertFatal(subframe_tx == *subframe,
 		  "In frame_tx %d : subframe_tx %d is not what we expect %d\n",frame_tx,subframe_tx,*subframe);
+	*/
+	      if (frame_tx != *frame) { 
+        LOG_W(PHY,"frame_tx %d is not what we expect %d\n",frame_tx,*frame);
+         *frame=frame_tx;
+      }
+      if (subframe_tx != *subframe) {
+         LOG_W(PHY,"In frame_tx %d : subframe_tx %d is not what we expect %d\n",frame_tx,subframe_tx,*subframe);
+         *subframe=subframe_tx;
+      }
     }
 
     if (packet_type == IF4p5_PDLFFT) {
@@ -469,7 +560,6 @@ void fh_if4p5_north_asynch_in(RU_t *ru,int *frame,int *subframe) {
     VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_IF4P5_NORTH_ASYNCH_IN,subframe_tx);
   }
 
-
   if (ru->feptx_ofdm) ru->feptx_ofdm(ru);
 
   if (ru->fh_south_out) ru->fh_south_out(ru);
@@ -493,10 +583,19 @@ void fh_if4p5_north_out(RU_t *ru) {
  	 VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_IF4P5_NORTH_OUT, proc->subframe_rx );
          VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_IF4P5_NORTH_OUT, proc->frame_rx );
   }
-  LOG_D(PHY,"fh_if4p5_north_out: Sending IF4p5_PULFFT SFN.SF %d.%d\n",proc->frame_rx,proc->subframe_rx);
   if ((fp->frame_type == TDD) && (subframe_select(fp,subframe)!=SF_UL)) {
     /// **** in TDD during DL send_IF4 of ULTICK to RCC **** ///
-    send_IF4p5(ru, proc->frame_rx, proc->subframe_rx, IF4p5_PULTICK);
+    if (subframe_select(fp,subframe)==SF_S && subframe==1 /*&& ru->state==RU_RUN*/) {
+        send_IF4p5(ru, proc->frame_rx, proc->subframe_rx, IF4p5_PULCALIB);
+        LOG_D(PHY,"~~~~~~******* Sending PULCALIB frame %d, subframe %d\n",proc->frame_rx,proc->subframe_rx);
+	T(T_RAU_INPUT_DMRS, T_INT(ru->idx), T_INT(proc->frame_rx), T_INT(proc->subframe_rx),
+          T_BUFFER(&ru->common.rxdataF[0][proc->subframe_rx*fp->symbols_per_tti*fp->ofdm_symbol_size],
+          fp->symbols_per_tti*fp->ofdm_symbol_size*sizeof(int32_t))); 
+     } else {
+        send_IF4p5(ru, proc->frame_rx, proc->subframe_rx, IF4p5_PULTICK);
+        LOG_D(PHY,"~~~~~~******* Sending PULTICK frame %d, subframe %d\n",proc->frame_rx,proc->subframe_rx); 
+    }
+    LOG_D(PHY,"fh_if4p5_north_out: Sending IF4p5_PULCALIB SFN.SF %d.%d\n",proc->frame_rx,proc->subframe_rx);
     ru->north_out_cnt++;
     return;
   }
@@ -590,7 +689,7 @@ void rx_rf(RU_t *ru,int *frame,int *subframe) {
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_READ, 0 );
 
   ru->south_in_cnt++;
-  LOG_D(PHY,"south_in_cnt %d\n",ru->south_in_cnt);
+  LOG_D(PHY,"south_in_cnt %d : frame %d, subframe %d\n",ru->south_in_cnt,*frame,*subframe);
 
   if (ru->cmd==RU_FRAME_RESYNCH) {
     LOG_I(PHY,"Applying frame resynch %d => %d\n",*frame,ru->cmdval);
@@ -687,8 +786,8 @@ void rx_rf(RU_t *ru,int *frame,int *subframe) {
 void tx_rf(RU_t *ru) {
   RU_proc_t *proc = &ru->proc;
   LTE_DL_FRAME_PARMS *fp = &ru->frame_parms;
-  void *txp[ru->nb_tx];
-  unsigned int txs;
+  void *txp[ru->nb_tx],*txp1[ru->nb_tx]; 
+  unsigned int txs,txs1;
   int i;
   T(T_ENB_PHY_OUTPUT_SIGNAL, T_INT(0), T_INT(0), T_INT(proc->frame_tx), T_INT(proc->subframe_tx),
     T_INT(0), T_BUFFER(&ru->common.txdata[0][proc->subframe_tx * fp->samples_per_tti], fp->samples_per_tti * 4));
@@ -700,20 +799,28 @@ void tx_rf(RU_t *ru) {
   if ((SF_type == SF_DL) ||
       (SF_type == SF_S)) {
     int siglen=fp->samples_per_tti,flags=1;
-
+    int siglen2=fp->samples_per_tti+fp->nb_prefix_samples;
+    int sigoff2=2*fp->nb_prefix_samples0+8*fp->nb_prefix_samples+10*fp->ofdm_symbol_size;
+    
     if (SF_type == SF_S) {
-      int txsymb = fp->dl_symbols_in_S_subframe+(ru->is_slave==0 ? 1 : 0);
+      int txsymb = fp->dl_symbols_in_S_subframe+(ru->is_slave==0 ? 1 : -1);
       AssertFatal(txsymb>0,"illegal txsymb %d\n",txsymb);
-      /* end_of_burst_delay is used to stop TX only "after a while".
+      //siglen = fp->nb_prefix_samples0 + (txsymb*fp->ofdm_symbol_size) + (txsymb-1)*fp->nb_prefix_samples;
+      
+       /* end_of_burst_delay is used to stop TX only "after a while".
        * If we stop right after effective signal, with USRP B210 and
        * B200mini, we observe a high EVM on the S subframe (on the
        * PSS).
        * A value of 400 (for 30.72MHz) solves this issue. This is
        * the default.
        */
-      siglen = (fp->ofdm_symbol_size + fp->nb_prefix_samples0)
+       siglen = (fp->ofdm_symbol_size + fp->nb_prefix_samples0)
                + (txsymb - 1) * (fp->ofdm_symbol_size + fp->nb_prefix_samples)
                + ru->end_of_burst_delay;
+       if (ru->state==RU_RUN && proc->frame_tx%ru->p==ru->tag) {
+       	siglen2 = fp->ofdm_symbol_size + fp->nb_prefix_samples; // length of symbol 10
+       }
+
       flags=3; // end of burst
     }
 
@@ -733,9 +840,11 @@ void tx_rf(RU_t *ru) {
 #elif defined(__arm__)
     sf_extension = (sf_extension)&0xfffffffc;
 #endif
-
-    for (i=0; i<ru->nb_tx; i++)
-      txp[i] = (void *)&ru->common.txdata[i][(proc->subframe_tx*fp->samples_per_tti)-sf_extension];
+    
+    for (i=0; i<ru->nb_tx; i++) {
+      txp[i] = (void*)&ru->common.txdata[i][(proc->subframe_tx*fp->samples_per_tti)-sf_extension];
+      txp1[i] = (void*)&ru->common.txdata[i][(proc->subframe_tx*fp->samples_per_tti)+(sigoff2)-sf_extension]; // pointer to 1st sample of 10th symbol
+    }
 
     /* add fail safe for late command */
     if(late_control!=STATE_BURST_NORMAL) { //stop burst
@@ -780,6 +889,22 @@ void tx_rf(RU_t *ru) {
 				      siglen+sf_extension,
 				      ru->nb_tx,
 				      flags);
+    LOG_D(PHY,"txs %d, siglen %d, sf_extension %d\n",txs,siglen,sf_extension);
+
+    if (ru->state==RU_RUN && proc->frame_tx%ru->p==ru->tag && proc->subframe_tx==1) {
+    	txs1 = ru->rfdevice.trx_write_func(&ru->rfdevice,
+                                      proc->timestamp_tx+(ru->ts_offset+sigoff2)-ru->openair0_cfg.tx_sample_advance-sf_extension,
+                                      txp1,
+                                      siglen2+sf_extension,
+                                      ru->nb_tx,
+                                      flags);
+        //LOG_M("txdata.m","txdata",&ru->common.txdata[0][0], fp->samples_per_tti*10,1,1); // save 1 frame
+	//exit(-1);
+	int se1 = dB_fixed(signal_energy(txp1[0],siglen2+sf_extension));
+        LOG_D(PHY,"******** frame %d subframe %d RRU sends DMRS of energy10 %d, energy3 %d\n",proc->frame_tx,proc->subframe_tx,se1,dB_fixed(signal_energy(txp[0],siglen+sf_extension)));
+        //LOG_D(PHY,"txs1 %d, siglen2 %d, sf_extension %d\n",txs1,siglen2,sf_extension);
+    }
+
     ru->south_out_cnt++;
     LOG_D(PHY,"south_out_cnt %d\n",ru->south_out_cnt);
     int se = dB_fixed(signal_energy(txp[0],siglen+sf_extension));
@@ -787,12 +912,20 @@ void tx_rf(RU_t *ru) {
     if (SF_type == SF_S) LOG_D(PHY,"[TXPATH] RU %d tx_rf (en %d,len %d), writing to TS %llu, frame %d, unwrapped_frame %d, subframe %d\n",ru->idx,se,siglen+sf_extension,
 	  (long long unsigned int)proc->timestamp_tx,proc->frame_tx,proc->frame_tx_unwrap,proc->subframe_tx);
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE, 0 );
-
+    
     //    AssertFatal(txs ==  siglen+sf_extension,"TX : Timeout (sent %d/%d)\n",txs, siglen);
-    if( (txs !=  siglen+sf_extension) && (late_control==STATE_BURST_NORMAL) ) { /* add fail safe for late command */
+    if (/*ru->is_slave==1 &&*/ ru->state==RU_RUN && proc->frame_tx%ru->p==ru->tag && proc->subframe_tx==1) {
+        if( (txs1!=siglen2+sf_extension) && (late_control==STATE_BURST_NORMAL) ){ /* add fail safe for late command */
+                late_control=STATE_BURST_TERMINATE;
+                LOG_E(PHY,"TX : Timeout (sent %d/%d) state =%d\n",txs1, siglen2,late_control);
+        }
+    }
+
+    if( (txs!=siglen+sf_extension) && (late_control==STATE_BURST_NORMAL) ){ /* add fail safe for late command */
       late_control=STATE_BURST_TERMINATE;
       LOG_E(PHY,"TX : Timeout (sent %d/%d) state =%d\n",txs, siglen,late_control);
     }
+    
   }
 }
 
@@ -1097,6 +1230,7 @@ void wakeup_L1s(RU_t *ru) {
   PHY_VARS_eNB *eNB=eNB_list[0];
   L1_proc_t *proc      = &eNB->proc;
   struct timespec t;
+
   LOG_D(PHY,"wakeup_L1s (num %d) for RU %d ru->eNB_top:%p\n",ru->num_eNB,ru->idx, ru->eNB_top);
 
   // call eNB function directly
@@ -1630,8 +1764,9 @@ void *ru_thread( void *param ) {
       ru->wait_cnt = 100;
     }
     else { 
-      ru->wait_cnt = 0;
-      ru->wait_check = 0;
+         ru->wait_cnt = 0;
+	 ru->wait_check = 0;
+         ru->missed_synch_events=0;
     }
     
     
@@ -1871,15 +2006,15 @@ void *ru_thread_synch(void *arg) {
 				   &avg);
       LOG_I(PHY,"RU synch cnt %d: %d, val %llu (%d dB,%d dB)\n",cnt,ru->rx_offset,(unsigned long long)peak_val,dB_fixed64(peak_val),dB_fixed64(avg));
       cnt++;
-      if (/*ru->rx_offset >= 0*/dB_fixed(peak_val)>=85 && cnt>10) {
+      if (ru->rx_offset >= 0 && avg>0 && dB_fixed(peak_val/avg)>=15 && cnt>10) {
 	LOG_I(PHY,"Estimated peak_val %d dB, avg %d => timing offset %llu\n",dB_fixed(peak_val),dB_fixed(avg),(unsigned long long int)ru->rx_offset);
 	ru->in_synch = 1;
-/*
-        LOG_M("ru_sync_rx.m","rurx",&ru->common.rxdata[0][0],LTE_NUMBER_OF_SUBFRAMES_PER_FRAME*fp->samples_per_tti,1,1);
+
+        /*LOG_M("ru_sync_rx.m","rurx",&ru->common.rxdata[0][0],LTE_NUMBER_OF_SUBFRAMES_PER_FRAME*fp->samples_per_tti,1,1);
         LOG_M("ru_sync_corr.m","sync_corr",ru->dmrs_corr,LTE_NUMBER_OF_SUBFRAMES_PER_FRAME*fp->samples_per_tti,1,6);
         LOG_M("ru_dmrs.m","rudmrs",&ru->dmrssync[0],fp->ofdm_symbol_size,1,1);
-  */      
-//exit(-1);
+        exit(-1);*/
+
       } // sync_pos > 0
       else //AssertFatal(cnt<1000,"Cannot find synch reference\n");
           { 

targets/RT/USER/ru_control.c

@@ -126,7 +126,9 @@ int send_config(RU_t *ru, RRU_CONFIG_msg_t rru_config_msg){
   rru_config_msg.type = RRU_config;
   rru_config_msg.len  = sizeof(RRU_CONFIG_msg_t)-MAX_RRU_CONFIG_SIZE+sizeof(RRU_config_t);
 
-  LOG_I(PHY,"Sending Configuration to RRU %d (num_bands %d,band0 %d,txfreq %u,rxfreq %u,att_tx %d,att_rx %d,N_RB_DL %d,N_RB_UL %d,3/4FS %d, prach_FO %d, prach_CI %d\n",ru->idx,
+  LOG_I(PHY,"Sending Configuration to RRU %d (RRU p %d,RRU tag %d,num_bands %d,band0 %d,txfreq %u,rxfreq %u,att_tx %d,att_rx %d,N_RB_DL %d,N_RB_UL %d,3/4FS %d, prach_FO %d, prach_CI %d\n",ru->idx,
+        ((RRU_config_t *)&rru_config_msg.msg[0])->p,
+        ((RRU_config_t *)&rru_config_msg.msg[0])->tag,
 	((RRU_config_t *)&rru_config_msg.msg[0])->num_bands,
 	((RRU_config_t *)&rru_config_msg.msg[0])->band_list[0],
 	((RRU_config_t *)&rru_config_msg.msg[0])->tx_freq[0],
@@ -234,7 +236,9 @@ int attach_rru(RU_t *ru) {
 		    
   rru_config_msg.type = RRU_config;
   rru_config_msg.len  = sizeof(RRU_CONFIG_msg_t)-MAX_RRU_CONFIG_SIZE+sizeof(RRU_config_t);
-  LOG_I(PHY,"Sending Configuration to RRU %d (num_bands %d,band0 %d,txfreq %u,rxfreq %u,att_tx %d,att_rx %d,N_RB_DL %d,N_RB_UL %d,3/4FS %d, prach_FO %d, prach_CI %d)\n",ru->idx,
+  LOG_I(PHY,"Sending Configuration to RRU %d (RRU p %d,RRU tag %d,num_bands %d,band0 %d,txfreq %u,rxfreq %u,att_tx %d,att_rx %d,N_RB_DL %d,N_RB_UL %d,3/4FS %d, prach_FO %d, prach_CI %d)\n",ru->idx,
+        ((RRU_config_t *)&rru_config_msg.msg[0])->p,
+        ((RRU_config_t *)&rru_config_msg.msg[0])->tag,
 	((RRU_config_t *)&rru_config_msg.msg[0])->num_bands,
 	((RRU_config_t *)&rru_config_msg.msg[0])->band_list[0],
 	((RRU_config_t *)&rru_config_msg.msg[0])->tx_freq[0],
@@ -327,7 +331,9 @@ int connect_rau(RU_t *ru) {
       LOG_I(PHY,"Waiting for configuration from RAU\n");     
     }    
     else {
-      LOG_I(PHY,"Configuration received from RAU  (num_bands %d,band0 %d,txfreq %u,rxfreq %u,att_tx %d,att_rx %d,N_RB_DL %d,N_RB_UL %d,3/4FS %d, prach_FO %d, prach_CI %d)\n",
+      LOG_I(PHY,"Configuration received from RAU  (RRU p %d,RRU tag %d,num_bands %d,band0 %d,txfreq %u,rxfreq %u,att_tx %d,att_rx %d,N_RB_DL %d,N_RB_UL %d,3/4FS %d, prach_FO %d, prach_CI %d)\n",
+            ((RRU_config_t *)&rru_config_msg.msg[0])->p,
+            ((RRU_config_t *)&rru_config_msg.msg[0])->tag,
 	    ((RRU_config_t *)&rru_config_msg.msg[0])->num_bands,
 	    ((RRU_config_t *)&rru_config_msg.msg[0])->band_list[0],
 	    ((RRU_config_t *)&rru_config_msg.msg[0])->tx_freq[0],
@@ -425,12 +431,14 @@ void configure_ru(int idx,
   config->N_RB_DL[0]             = ru->frame_parms.N_RB_DL;
   config->N_RB_UL[0]             = ru->frame_parms.N_RB_UL;
   config->threequarter_fs[0]     = ru->frame_parms.threequarter_fs;
+  config->tag			 = idx;
+  config->p			 = RC.nb_RU;
   if (ru->if_south==REMOTE_IF4p5) {
     config->prach_FreqOffset[0]  = ru->frame_parms.prach_config_common.prach_ConfigInfo.prach_FreqOffset;
     config->prach_ConfigIndex[0] = ru->frame_parms.prach_config_common.prach_ConfigInfo.prach_ConfigIndex;
     LOG_I(PHY,"REMOTE_IF4p5: prach_FrequOffset %d, prach_ConfigIndex %d\n",
 	  config->prach_FreqOffset[0],config->prach_ConfigIndex[0]);
-    
+     
 #if (RRC_VERSION >= MAKE_VERSION(14, 0, 0))
     int i;
     for (i=0;i<4;i++) {
@@ -451,6 +459,8 @@ void configure_rru(int idx,
   RRU_config_t *config = (RRU_config_t *)arg;
   RU_t         *ru         = RC.ru[idx];
 
+  ru->tag						   		   = config->tag;
+  ru->p									   = config->p;
   ru->frame_parms.eutra_band                                               = config->band_list[0];
   ru->frame_parms.dl_CarrierFreq                                           = config->tx_freq[0];
   ru->frame_parms.ul_CarrierFreq                                           = config->rx_freq[0];
@@ -568,7 +578,9 @@ void* ru_thread_control( void* param ) {
 				
 	    case RRU_config: // RRU
 	      if (ru->if_south == LOCAL_RF){
-		LOG_I(PHY,"Configuration received from RAU  (num_bands %d,band0 %d,txfreq %u,rxfreq %u,att_tx %d,att_rx %d,N_RB_DL %d,N_RB_UL %d,3/4FS %d, prach_FO %d, prach_CI %d)\n",
+		LOG_I(PHY,"Configuration received from RAU  (RRU p %d,RRU tag %d,num_bands %d,band0 %d,txfreq %u,rxfreq %u,att_tx %d,att_rx %d,N_RB_DL %d,N_RB_UL %d,3/4FS %d, prach_FO %d, prach_CI %d)\n",
+                      ((RRU_config_t *)&rru_config_msg.msg[0])->p,
+		      ((RRU_config_t *)&rru_config_msg.msg[0])->tag,
 		      ((RRU_config_t *)&rru_config_msg.msg[0])->num_bands,
 		      ((RRU_config_t *)&rru_config_msg.msg[0])->band_list[0],
 		      ((RRU_config_t *)&rru_config_msg.msg[0])->tx_freq[0],
@@ -693,7 +705,7 @@ void* ru_thread_control( void* param ) {
 	      if (ru->if_south == LOCAL_RF) LOG_E(PHY,"Received RRU_config_ok msg...Ignoring\n");
 	      else{
 		if (ru->is_slave == 1){
-                  printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Received RRU_sync_ok from RRU %d\n",ru->idx);
+                  printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Received RRU_sync_ok from RRU %d\n",ru->idx);
 		  // Just change the state of the RRU to unblock ru_thread()
 		  ru->state = RU_RUN;		
 		}else LOG_E(PHY,"Received RRU_sync_ok from a master RRU...Ignoring\n"); 	
@@ -721,8 +733,15 @@ void* ru_thread_control( void* param ) {
 		}else{
 		  LOG_I(PHY,"RRU not running, can't stop\n"); 
 		}
-	      }else LOG_E(PHY,"Received RRU_stop msg...Ignoring\n");
-	      
+	      }else { // RAU
+	       	/*if (ru->is_slave == 1){
+                  printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Received RRU_stop from RRU %d\n",ru->idx);
+                  // Just change the state of the RRU to unblock ru_thread()
+                  ru->state = RU_LOST_SYNC;
+		  //RC.collect = 0;
+		}*/
+		LOG_E(PHY,"Received RRU_stop msg...Ignoring\n");
+	      }
 	      break;
 
 	    default: