diff --git a/common/utils/LOG/vcd_signal_dumper.c b/common/utils/LOG/vcd_signal_dumper.c
index b1cfa56d0f..12b0627a23 100644
--- a/common/utils/LOG/vcd_signal_dumper.c
+++ b/common/utils/LOG/vcd_signal_dumper.c
@@ -82,10 +82,29 @@ const char* eurecomVariablesNames[] = {
   "frame_number_if4p5_north_out",
   "subframe_number_if4p5_north_asynch_in",
   "frame_number_if4p5_north_asynch_in",
-  "subframe_number_if4p5_south_out",
-  "frame_number_if4p5_south_out",
-  "subframe_number_if4p5_south_in",
-  "frame_number_if4p5_south_in",
+  "subframe_number_if4p5_south_out_ru",
+  "subframe_number_if4p5_south_out_ru1",
+  "frame_number_if4p5_south_out_ru",
+  "frame_number_if4p5_south_out_ru1",
+  "subframe_number_if4p5_south_in_ru",
+  "subframe_number_if4p5_south_in_ru1",
+  "frame_number_if4p5_south_in_ru",
+  "frame_number_if4p5_south_in_ru1",
+  "subframe_number_wakeup_l1s_ru",
+  "subframe_number_wakeup_l1s_ru1",
+  "frame_number_wakeup_l1s_ru",
+  "frame_number_wakeup_l1s_ru1",
+  "subframe_number_wakeup_rxtx_rx_ru",
+  "subframe_number_wakeup_rxtx_rx_ru1",
+  "frame_number_wakeup_rxtx_rx_ru",
+  "frame_number_wakeup_rxtx_rx_ru1",
+  "subframe_number_wakeup_rxtx_tx_ru",
+  "subframe_number_wakeup_rxtx_tx_ru1",
+  "frame_number_wakeup_rxtx_tx_ru",
+  "frame_number_wakeup_rxtx_tx_ru1",
+  "ic_enb",
+  "l1_proc_ic",
+  "l1_proc_tx_ic",
   "runtime_TX_eNB",
   "runtime_RX_eNB",
   "frame_number_TX0_UE",
@@ -424,10 +443,10 @@ const char* eurecomFunctionsNames[] = {
   "test",
   
   /* IF4/IF5 signals */
-  "send_if4",
-  "send_if4_RU1",
-  "recv_if4",
-  "recv_if4_RU1",
+  "send_if4_ru",
+  "send_if4_ru1",
+  "recv_if4_ru",
+  "recv_if4_ru1",
   "send_if5",
   "recv_if5",
 
diff --git a/common/utils/LOG/vcd_signal_dumper.h b/common/utils/LOG/vcd_signal_dumper.h
index 840f9c2188..707905ce4d 100644
--- a/common/utils/LOG/vcd_signal_dumper.h
+++ b/common/utils/LOG/vcd_signal_dumper.h
@@ -59,10 +59,29 @@ typedef enum {
   VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_IF4P5_NORTH_OUT,
   VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_IF4P5_NORTH_ASYNCH_IN,
   VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_IF4P5_NORTH_ASYNCH_IN,
-  VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_IF4P5_SOUTH_OUT,
-  VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_IF4P5_SOUTH_OUT,
-  VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_IF4P5_SOUTH_IN,
-  VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_IF4P5_SOUTH_IN,
+  VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_IF4P5_SOUTH_OUT_RU,
+  VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_IF4P5_SOUTH_OUT_RU1,
+  VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_IF4P5_SOUTH_OUT_RU,
+  VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_IF4P5_SOUTH_OUT_RU1,
+  VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_IF4P5_SOUTH_IN_RU,
+  VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_IF4P5_SOUTH_IN_RU1,
+  VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_IF4P5_SOUTH_IN_RU,
+  VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_IF4P5_SOUTH_IN_RU1,
+  VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_WAKEUP_L1S_RU,
+  VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_WAKEUP_L1S_RU1,
+  VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_WAKEUP_L1S_RU,
+  VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_WAKEUP_L1S_RU1,
+  VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_WAKEUP_RXTX_RX_RU,
+  VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_WAKEUP_RXTX_RX_RU1,
+  VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_WAKEUP_RXTX_RX_RU,
+  VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_WAKEUP_RXTX_RX_RU1,
+  VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_WAKEUP_RXTX_TX_RU,
+  VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_WAKEUP_RXTX_TX_RU1,
+  VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_WAKEUP_RXTX_TX_RU,
+  VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_WAKEUP_RXTX_TX_RU1,
+  VCD_SIGNAL_DUMPER_VARIABLES_IC_ENB,
+  VCD_SIGNAL_DUMPER_VARIABLES_L1_PROC_IC,
+  VCD_SIGNAL_DUMPER_VARIABLES_L1_PROC_TX_IC,
   VCD_SIGNAL_DUMPER_VARIABLES_RUNTIME_TX_ENB,
   VCD_SIGNAL_DUMPER_VARIABLES_RUNTIME_RX_ENB,
   VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_TX0_UE,
@@ -404,9 +423,9 @@ typedef enum {
   VCD_SIGNAL_DUMPER_FUNCTIONS_TEST,
   
   /* IF4/IF5 signals */
-  VCD_SIGNAL_DUMPER_FUNCTIONS_SEND_IF4,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_SEND_IF4_RU,
   VCD_SIGNAL_DUMPER_FUNCTIONS_SEND_IF4_RU1,
-  VCD_SIGNAL_DUMPER_FUNCTIONS_RECV_IF4,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_RECV_IF4_RU,
   VCD_SIGNAL_DUMPER_FUNCTIONS_RECV_IF4_RU1,
   VCD_SIGNAL_DUMPER_FUNCTIONS_SEND_IF5,
   VCD_SIGNAL_DUMPER_FUNCTIONS_RECV_IF5,
diff --git a/common/utils/T/T_defs.h b/common/utils/T/T_defs.h
index 74400df6de..005a7e67a1 100644
--- a/common/utils/T/T_defs.h
+++ b/common/utils/T/T_defs.h
@@ -44,7 +44,7 @@ typedef struct {
 #define VCD_NUM_FUNCTIONS (218)
 
 /* number of VCD variables (to be kept up to date! see in T_messages.txt) */
-#define VCD_NUM_VARIABLES (136)/*(128)*/
+#define VCD_NUM_VARIABLES (155) 
 
 /* first VCD function (to be kept up to date! see in T_messages.txt) */
 #define VCD_FIRST_FUNCTION    ((uintptr_t)T_VCD_FUNCTION_RT_SLEEP)
diff --git a/common/utils/T/T_messages.txt b/common/utils/T/T_messages.txt
index e1846d90d6..c4af298ab5 100644
--- a/common/utils/T/T_messages.txt
+++ b/common/utils/T/T_messages.txt
@@ -1051,26 +1051,121 @@ ID = VCD_VARIABLE_FRAME_NUMBER_IF4P5_NORTH_ASYNCH_IN
     GROUP = ALL:VCD:ENB:VCD_VARIABLE
     FORMAT = ulong,value
     VCD_NAME = frame_number_if4p5_north_asynch_in
-ID = VCD_VARIABLE_SUBFRAME_NUMBER_IF4P5_SOUTH_OUT
-    DESC = VCD variable SUBFRAME_NUMBER_IF4P5_SOUTH_OUT
+ID = VCD_VARIABLE_SUBFRAME_NUMBER_IF4P5_SOUTH_OUT_RU
+    DESC = VCD variable SUBFRAME_NUMBER_IF4P5_SOUTH_OUT_RU
     GROUP = ALL:VCD:ENB:VCD_VARIABLE
     FORMAT = ulong,value
-    VCD_NAME = subframe_number_if4p5_south_out
-ID = VCD_VARIABLE_FRAME_NUMBER_IF4P5_SOUTH_OUT
-    DESC = VCD variable FRAME_NUMBER_IF4P5_SOUTH_OUT
+    VCD_NAME = subframe_number_if4p5_south_out_ru
+ID = VCD_VARIABLE_SUBFRAME_NUMBER_IF4P5_SOUTH_OUT_RU1
+    DESC = VCD variable SUBFRAME_NUMBER_IF4P5_SOUTH_OUT_RU1
     GROUP = ALL:VCD:ENB:VCD_VARIABLE
     FORMAT = ulong,value
-    VCD_NAME = frame_number_if4p5_south_out
-ID = VCD_VARIABLE_SUBFRAME_NUMBER_IF4P5_SOUTH_IN
-    DESC = VCD variable SUBFRAME_NUMBER_IF4P5_SOUTH_IN
+    VCD_NAME = subframe_number_if4p5_south_out_ru1
+ID = VCD_VARIABLE_FRAME_NUMBER_IF4P5_SOUTH_OUT_RU
+    DESC = VCD variable FRAME_NUMBER_IF4P5_SOUTH_OUT_RU
     GROUP = ALL:VCD:ENB:VCD_VARIABLE
     FORMAT = ulong,value
-    VCD_NAME = subframe_number_if4p5_south_in
-ID = VCD_VARIABLE_FRAME_NUMBER_IF4P5_SOUTH_IN
-    DESC = VCD variable FRAME_NUMBER_IF4P5_SOUTH_IN
+    VCD_NAME = frame_number_if4p5_south_out_ru
+ID = VCD_VARIABLE_FRAME_NUMBER_IF4P5_SOUTH_OUT_RU1
+    DESC = VCD variable FRAME_NUMBER_IF4P5_SOUTH_OUT_RU1
     GROUP = ALL:VCD:ENB:VCD_VARIABLE
     FORMAT = ulong,value
-    VCD_NAME = frame_number_if4p5_south_in
+    VCD_NAME = frame_number_if4p5_south_out_ru1
+ID = VCD_VARIABLE_SUBFRAME_NUMBER_IF4P5_SOUTH_IN_RU
+    DESC = VCD variable SUBFRAME_NUMBER_IF4P5_SOUTH_IN_RU
+    GROUP = ALL:VCD:ENB:VCD_VARIABLE
+    FORMAT = ulong,value
+    VCD_NAME = subframe_number_if4p5_south_in_ru
+ID = VCD_VARIABLE_SUBFRAME_NUMBER_IF4P5_SOUTH_IN_RU1
+    DESC = VCD variable SUBFRAME_NUMBER_IF4P5_SOUTH_IN_RU1
+    GROUP = ALL:VCD:ENB:VCD_VARIABLE
+    FORMAT = ulong,value
+    VCD_NAME = subframe_number_if4p5_south_in_ru1
+ID = VCD_VARIABLE_FRAME_NUMBER_IF4P5_SOUTH_IN_RU
+    DESC = VCD variable FRAME_NUMBER_IF4P5_SOUTH_IN_RU
+    GROUP = ALL:VCD:ENB:VCD_VARIABLE
+    FORMAT = ulong,value
+    VCD_NAME = frame_number_if4p5_south_in_ru
+ID = VCD_VARIABLE_FRAME_NUMBER_IF4P5_SOUTH_IN_RU1
+    DESC = VCD variable FRAME_NUMBER_IF4P5_SOUTH_IN_RU1
+    GROUP = ALL:VCD:ENB:VCD_VARIABLE
+    FORMAT = ulong,value
+    VCD_NAME = frame_number_if4p5_south_in_ru1
+ID = VCD_VARIABLE_SUBFRAME_NUMBER_WAKEUP_L1S_RU
+    DESC = VCD variable SUBFRAME_NUMBER_WAKEUP_L1S_RU
+    GROUP = ALL:VCD:ENB:VCD_VARIABLE
+    FORMAT = ulong,value
+    VCD_NAME = subframe_number_wakeup_l1s_ru
+ID = VCD_VARIABLE_SUBFRAME_NUMBER_WAKEUP_L1S_RU1
+    DESC = VCD variable SUBFRAME_NUMBER_WAKEUP_L1S_RU1
+    GROUP = ALL:VCD:ENB:VCD_VARIABLE
+    FORMAT = ulong,value
+    VCD_NAME = subframe_number_wakeup_l1s_ru1
+ID = VCD_VARIABLE_FRAME_NUMBER_WAKEUP_L1S_RU
+    DESC = VCD variable FRAME_NUMBER_WAKEUP_L1S_RU
+    GROUP = ALL:VCD:ENB:VCD_VARIABLE
+    FORMAT = ulong,value
+    VCD_NAME = frame_number_wakeup_l1s_ru
+ID = VCD_VARIABLE_FRAME_NUMBER_WAKEUP_L1S_RU1
+    DESC = VCD variable FRAME_NUMBER_WAKEUP_L1S_RU1
+    GROUP = ALL:VCD:ENB:VCD_VARIABLE
+    FORMAT = ulong,value
+    VCD_NAME = frame_number_wakeup_l1s_ru1
+ID = VCD_VARIABLE_SUBFRAME_NUMBER_WAKEUP_RXTX_RX_RU
+    DESC = VCD variable SUBFRAME_NUMBER_WAKEUP_RXTX_RX_RU
+    GROUP = ALL:VCD:ENB:VCD_VARIABLE
+    FORMAT = ulong,value
+    VCD_NAME = subframe_number_wakeup_rxtx_rx_ru
+ID = VCD_VARIABLE_SUBFRAME_NUMBER_WAKEUP_RXTX_RX_RU1
+    DESC = VCD variable SUBFRAME_NUMBER_WAKEUP_RXTX_RX_RU1
+    GROUP = ALL:VCD:ENB:VCD_VARIABLE
+    FORMAT = ulong,value
+    VCD_NAME = subframe_number_wakeup_rxtx_rx_ru1
+ID = VCD_VARIABLE_FRAME_NUMBER_WAKEUP_RXTX_RX_RU
+    DESC = VCD variable FRAME_NUMBER_WAKEUP_RXTX_RX_RU
+    GROUP = ALL:VCD:ENB:VCD_VARIABLE
+    FORMAT = ulong,value
+    VCD_NAME = frame_number_wakeup_rxtx_rx_ru
+ID = VCD_VARIABLE_FRAME_NUMBER_WAKEUP_RXTX_RX_RU1
+    DESC = VCD variable FRAME_NUMBER_WAKEUP_RXTX_RX_RU1
+    GROUP = ALL:VCD:ENB:VCD_VARIABLE
+    FORMAT = ulong,value
+    VCD_NAME = frame_number_wakeup_rxtx_rx_ru1
+ID = VCD_VARIABLE_SUBFRAME_NUMBER_WAKEUP_RXTX_TX_RU
+    DESC = VCD variable SUBFRAME_NUMBER_WAKEUP_RXTX_TX_RU
+    GROUP = ALL:VCD:ENB:VCD_VARIABLE
+    FORMAT = ulong,value
+    VCD_NAME = subframe_number_wakeup_rxtx_tx_ru
+ID = VCD_VARIABLE_SUBFRAME_NUMBER_WAKEUP_RXTX_TX_RU1
+    DESC = VCD variable SUBFRAME_NUMBER_WAKEUP_RXTX_TX_RU1
+    GROUP = ALL:VCD:ENB:VCD_VARIABLE
+    FORMAT = ulong,value
+    VCD_NAME = subframe_number_wakeup_rxtx_tx_ru1
+ID = VCD_VARIABLE_FRAME_NUMBER_WAKEUP_RXTX_TX_RU
+    DESC = VCD variable FRAME_NUMBER_WAKEUP_RXTX_TX_RU
+    GROUP = ALL:VCD:ENB:VCD_VARIABLE
+    FORMAT = ulong,value
+    VCD_NAME = frame_number_wakeup_rxtx_tx_ru
+ID = VCD_VARIABLE_FRAME_NUMBER_WAKEUP_RXTX_TX_RU1
+    DESC = VCD variable FRAME_NUMBER_WAKEUP_RXTX_TX_RU1
+    GROUP = ALL:VCD:ENB:VCD_VARIABLE
+    FORMAT = ulong,value
+    VCD_NAME = frame_number_wakeup_rxtx_tx_ru1
+ID = VCD_VARIABLE_IC_ENB
+    DESC = VCD variable IC_ENB
+    GROUP = ALL:VCD:ENB:VCD_VARIABLE
+    FORMAT = ulong,value
+    VCD_NAME = ic_enb
+ID = VCD_VARIABLE_L1_PROC_IC
+    DESC = VCD variable L1_PROC_IC
+    GROUP = ALL:VCD:ENB:VCD_VARIABLE
+    FORMAT = ulong,value
+    VCD_NAME = l1_proc_ic
+ID = VCD_VARIABLE_L1_PROC_TX_IC
+    DESC = VCD variable L1_PROC_TX_IC
+    GROUP = ALL:VCD:ENB:VCD_VARIABLE
+    FORMAT = ulong,value
+    VCD_NAME = l1_proc_tx_ic
 ID = VCD_VARIABLE_RUNTIME_TX_ENB
     DESC = VCD variable RUNTIME_TX_ENB
     GROUP = ALL:VCD:ENB:VCD_VARIABLE
@@ -2639,26 +2734,26 @@ ID = VCD_FUNCTION_TEST
     GROUP = ALL:VCD:ENB:VCD_FUNCTION
     FORMAT = int,value
     VCD_NAME = test
-ID = VCD_FUNCTION_SEND_IF4
-    DESC = VCD function SEND_IF4
+ID = VCD_FUNCTION_SEND_IF4_RU
+    DESC = VCD function SEND_IF4_RU
     GROUP = ALL:VCD:ENB:VCD_FUNCTION
     FORMAT = int,value
-    VCD_NAME = send_if4
+    VCD_NAME = send_if4_ru
 ID = VCD_FUNCTION_SEND_IF4_RU1
     DESC = VCD function SEND_IF4_RU1
     GROUP = ALL:VCD:ENB:VCD_FUNCTION
     FORMAT = int,value
-    VCD_NAME = send_if4_RU1
-ID = VCD_FUNCTION_RECV_IF4
-    DESC = VCD function RECV_IF4
+    VCD_NAME = send_if4_ru1
+ID = VCD_FUNCTION_RECV_IF4_RU
+    DESC = VCD function RECV_IF4_RU
     GROUP = ALL:VCD:ENB:VCD_FUNCTION
     FORMAT = int,value
-    VCD_NAME = recv_if4
+    VCD_NAME = recv_if4_ru
 ID = VCD_FUNCTION_RECV_IF4_RU1
     DESC = VCD function RECV_IF4_RU1
     GROUP = ALL:VCD:ENB:VCD_FUNCTION
     FORMAT = int,value
-    VCD_NAME = recv_if4_RU1
+    VCD_NAME = recv_if4_ru1
 ID = VCD_FUNCTION_SEND_IF5
     DESC = VCD function SEND_IF5
     GROUP = ALL:VCD:ENB:VCD_FUNCTION
diff --git a/openair1/PHY/INIT/lte_init_ru.c b/openair1/PHY/INIT/lte_init_ru.c
index b1c57e052f..8c5f412bbc 100644
--- a/openair1/PHY/INIT/lte_init_ru.c
+++ b/openair1/PHY/INIT/lte_init_ru.c
@@ -40,6 +40,8 @@ int phy_init_RU(RU_t *ru) {
   int i,j;
   int p;
   int re;
+  
+  init_dfts();  
 
   LOG_I(PHY,"Initializing RU signal buffers (if_south %s) nb_tx %d\n",ru_if_types[ru->if_south],ru->nb_tx);
 
diff --git a/openair1/PHY/LTE_TRANSPORT/if4_tools.c b/openair1/PHY/LTE_TRANSPORT/if4_tools.c
index 4037c51e43..494c3498c4 100644
--- a/openair1/PHY/LTE_TRANSPORT/if4_tools.c
+++ b/openair1/PHY/LTE_TRANSPORT/if4_tools.c
@@ -64,7 +64,7 @@ void send_IF4p5(RU_t *ru, int frame, int subframe, uint16_t packet_type) {
   eth_state_t *eth = (eth_state_t*) (ru->ifdevice.priv);
   int nsym = fp->symbols_per_tti;
   
-  if (ru->idx<=1) VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_SEND_IF4+ru->idx, 1 );   
+  if (ru->idx<=1) VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_SEND_IF4_RU+ru->idx,1);   
 
   if (packet_type == IF4p5_PDLFFT) {
     LOG_D(PHY,"send DL_IF4p5: RU %d frame %d, subframe %d\n",ru->idx,frame,subframe);
@@ -266,7 +266,7 @@ void send_IF4p5(RU_t *ru, int frame, int subframe, uint16_t packet_type) {
     AssertFatal(1==0, "send_IF4p5 - Unknown packet_type %x", packet_type);     
   }
 
-  if (ru->idx<=1) VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_SEND_IF4+ru->idx, 0 );  
+  if (ru->idx<=1) VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_SEND_IF4_RU+ru->idx,0);  
   return;  		    
 }
 
@@ -285,7 +285,7 @@ void recv_IF4p5(RU_t *ru, int *frame, int *subframe, uint16_t *packet_type, uint
   int slotoffsetF=0, blockoffsetF=0; 
   eth_state_t *eth = (eth_state_t*) (ru->ifdevice.priv);
   int idx;
-  if (ru->idx<=1) VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_RECV_IF4+ru->idx, 1 );   
+  if (ru->idx<=1) VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RECV_IF4_RU+ru->idx,1);   
   
   if (ru->function == NGFI_RRU_IF4p5) {
     db_fulllength = (12*fp->N_RB_DL)*ru->nb_tx; 
@@ -420,7 +420,7 @@ void recv_IF4p5(RU_t *ru, int *frame, int *subframe, uint16_t *packet_type, uint
     AssertFatal(1==0, "recv_IF4p5 - Unknown packet_type %x", *packet_type);            
   }
 
-  if (ru->idx<=1) VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_RECV_IF4+ru->idx, 0 );     
+  if (ru->idx<=1) VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RECV_IF4_RU+ru->idx,0);     
   return;   
 }
 
diff --git a/openair1/PHY/LTE_UE_TRANSPORT/drs_modulation.c b/openair1/PHY/LTE_UE_TRANSPORT/drs_modulation.c
index 7ec57e4699..73c1b8203f 100644
--- a/openair1/PHY/LTE_UE_TRANSPORT/drs_modulation.c
+++ b/openair1/PHY/LTE_UE_TRANSPORT/drs_modulation.c
@@ -112,7 +112,6 @@ int generate_drs_pusch(PHY_VARS_UE *ue,
     subframe_offset = subframe*fp->symbols_per_tti*fp->ofdm_symbol_size;
     symbol_offset = subframe_offset + fp->ofdm_symbol_size*l;
 
-
 #ifdef DEBUG_DRS
     printf("generate_drs_pusch: symbol_offset %d, subframe offset %d, cyclic shift %d\n",symbol_offset,subframe_offset,cyclic_shift);
 #endif
diff --git a/targets/RT/USER/lte-enb.c b/targets/RT/USER/lte-enb.c
index 14024018d8..17c497372c 100644
--- a/targets/RT/USER/lte-enb.c
+++ b/targets/RT/USER/lte-enb.c
@@ -174,7 +174,6 @@ extern void add_subframe(uint16_t *frameP, uint16_t *subframeP, int offset);
 
 static inline int rxtx(PHY_VARS_eNB *eNB,L1_rxtx_proc_t *proc, char *thread_name) {
   start_meas(&softmodem_stats_rxtx_sf);
-LOG_I(PHY,"ENTERED rxtx\n");
   if (nfapi_mode == 1) {
 
     // I am a PNF and I need to let nFAPI know that we have a (sub)frame tick
@@ -284,7 +283,7 @@ LOG_I(PHY,"ENTERED rxtx\n");
 
   stop_meas( &softmodem_stats_rxtx_sf );
 
-  LOG_I(PHY,"%s() Exit proc[rx:%d%d tx:%d%d]\n", __FUNCTION__, proc->frame_rx, proc->subframe_rx, proc->frame_tx, proc->subframe_tx);
+  LOG_D(PHY,"%s() Exit proc[rx:%d%d tx:%d%d]\n", __FUNCTION__, proc->frame_rx, proc->subframe_rx, proc->frame_tx, proc->subframe_tx);
 
   LOG_D(PHY, "rxtx:%lld nfapi:%lld phy:%lld tx:%lld rx:%lld prach:%lld ofdm:%lld ",
       softmodem_stats_rxtx_sf.p_time, nfapi_meas.p_time,
@@ -335,7 +334,6 @@ static void* L1_thread_tx(void* param) {
   L1_proc_t *eNB_proc  = (L1_proc_t*)param;
   L1_rxtx_proc_t *proc = &eNB_proc->L1_proc_tx;
   PHY_VARS_eNB *eNB = RC.eNB[0][proc->CC_id];
-  LOG_I(PHY,"ENTERED L1_thread_tx\n");
   char thread_name[100];
   sprintf(thread_name,"TXnp4_%d\n",&eNB->proc.L1_proc == proc ? 0 : 1);
   thread_top_init(thread_name,1,470000,500000,500000);
@@ -359,7 +357,9 @@ static void* L1_thread_tx(void* param) {
     phy_procedures_eNB_TX(eNB, proc, 1);
 
     pthread_mutex_lock( &proc->mutex );
+    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_L1_PROC_TX_IC,proc->instance_cnt);
     proc->instance_cnt = -1;
+    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_L1_PROC_TX_IC,proc->instance_cnt);
     // the thread can now be woken up
     if (pthread_cond_signal(&proc->cond) != 0) {
       LOG_E( PHY, "[eNB] ERROR pthread_cond_signal for eNB TXnp4 thread\n");
@@ -381,9 +381,7 @@ static void* L1_thread_tx(void* param) {
 static void* L1_thread( void* param ) {
 
   static int eNB_thread_rxtx_status;
-  //L1_proc_t *eNB_proc  = (L1_proc_t*)param;
   L1_rxtx_proc_t *proc;
-LOG_I(PHY,"ENTERED L1_thread\n");
   // Working
   if(nfapi_mode ==2){
 	  proc = (L1_rxtx_proc_t*)param;
@@ -437,8 +435,9 @@ LOG_I(PHY,"ENTERED L1_thread\n");
     {
       if (rxtx(eNB,proc,thread_name) < 0) break;
     }
-
+VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_L1_PROC_IC,proc->instance_cnt);
     if (release_thread(&proc->mutex,&proc->instance_cnt,thread_name)<0) break;
+VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_L1_PROC_IC,proc->instance_cnt);
     if (nfapi_mode!=2){
     	if(get_thread_parallel_conf() == PARALLEL_RU_L1_TRX_SPLIT)      wakeup_tx(eNB);
     	else if(get_thread_parallel_conf() == PARALLEL_RU_L1_SPLIT)
@@ -491,9 +490,8 @@ int wakeup_txfh(L1_rxtx_proc_t *proc,PHY_VARS_eNB *eNB) {
   wait.tv_sec=0;
   wait.tv_nsec=5000000L;
   LTE_DL_FRAME_PARMS *fp;
-  LOG_I(PHY,"ENTERED wakeup_txfh\n");
 
-  printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~inside wakeup_txfh %d.%d IC_RU = %d\n", proc->frame_tx, proc->subframe_tx, proc->instance_cnt_RUs);
+  LOG_D(PHY,"wakeup_txfh %d.%d IC_RU = %d\n", proc->frame_tx, proc->subframe_tx, proc->instance_cnt_RUs);
   if(wait_on_condition(&proc->mutex_RUs,&proc->cond_RUs,&proc->instance_cnt_RUs,"wakeup_txfh")<0) {
   	LOG_E(PHY,"Frame %d, subframe %d: TX FH not ready\n", proc->frame_tx, proc->subframe_tx);
     	return(-1);
@@ -506,11 +504,16 @@ int wakeup_txfh(L1_rxtx_proc_t *proc,PHY_VARS_eNB *eNB) {
   for(int ru_id=0; ru_id<eNB->num_RU; ru_id++){
   	ru_proc = &eNB->RU_list[ru_id]->proc;
     	fp = &eNB->RU_list[ru_id]->frame_parms;
-    	if ((fp->frame_type == TDD) && (subframe_select(fp,proc->subframe_tx)==SF_UL)) continue;
+    	if ((fp->frame_type == TDD) && (subframe_select(fp,proc->subframe_tx)==SF_UL)){
+           pthread_mutex_lock(&proc->mutex_RUs);
+           proc->instance_cnt_RUs = 0;
+           pthread_mutex_unlock(&proc->mutex_RUs);
+           continue;//hacking only works when all RU_tx works on the same subframe #TODO: adding mask stuff
+        }
     	// skip the RUs that are not synced
     	if (eNB->RU_list[ru_id]->state == RU_SYNC) { LOG_D(PHY,"wakeup_txfh: eNB %d : Skipping ru %d\n",eNB->Mod_id,ru_id); continue; }
 
-    	if(ru_proc == NULL) {return(0);}
+    	//if(ru_proc == NULL) {return(0);}
     
     	if (ru_proc->instance_cnt_eNBs == 0) {
         	LOG_E(PHY,"Frame %d, subframe %d: TX FH thread busy, dropping Frame %d, subframe %d\n", ru_proc->frame_tx, ru_proc->subframe_tx, proc->frame_rx, proc->subframe_rx);
@@ -521,13 +524,16 @@ int wakeup_txfh(L1_rxtx_proc_t *proc,PHY_VARS_eNB *eNB) {
       		exit_fun( "error locking mutex_eNB" );
       		return(-1);
     	}
-      	
+      	VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_IC_ENB,ru_proc->instance_cnt_eNBs);
 	ru_proc->instance_cnt_eNBs = 0;
+        VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_IC_ENB,ru_proc->instance_cnt_eNBs);
       	ru_proc->timestamp_tx = proc->timestamp_tx;
       	ru_proc->subframe_tx  = proc->subframe_tx;
       	ru_proc->frame_tx     = proc->frame_tx;
-
-    	// the thread can now be woken up
+        
+        LOG_D(PHY,"wakeup_txfh: ru_proc->subframe_tx %d\n",ru_proc->subframe_tx);
+    	
+        // the thread can now be woken up
     	if (pthread_cond_signal(&ru_proc->cond_eNBs) != 0) {
       		LOG_E( PHY, "[eNB] ERROR pthread_cond_signal for eNB TXnp4 thread\n");
       		exit_fun( "ERROR pthread_cond_signal" );
@@ -541,9 +547,9 @@ int wakeup_txfh(L1_rxtx_proc_t *proc,PHY_VARS_eNB *eNB) {
 int wakeup_tx(PHY_VARS_eNB *eNB) {
   L1_proc_t *proc=&eNB->proc;
 
- /* LTE_DL_FRAME_PARMS *fp;
+  /* LTE_DL_FRAME_PARMS *fp;
   fp = &eNB->frame_parms;
-if ((fp->frame_type == TDD) && (subframe_select(fp,proc_rxtx0->subframe_tx)==SF_UL)) return;
+  if ((fp->frame_type == TDD) && (subframe_select(fp,proc_rxtx0->subframe_tx)==SF_UL)) return;
   */
   L1_rxtx_proc_t *L1_proc_tx = &proc->L1_proc_tx;
   L1_rxtx_proc_t *L1_proc    = &proc->L1_proc;
@@ -552,7 +558,6 @@ if ((fp->frame_type == TDD) && (subframe_select(fp,proc_rxtx0->subframe_tx)==SF_
   struct timespec wait;
   wait.tv_sec=0;
   wait.tv_nsec=5000000L;
-  LOG_I(PHY,"ENTERED wakeup_tx\n");
   
   if (pthread_mutex_timedlock(&L1_proc_tx->mutex,&wait) != 0) {
     LOG_E(PHY, "[SCHED][eNB] ERROR locking mutex for eNB L1_thread_tx\n");
@@ -562,9 +567,9 @@ if ((fp->frame_type == TDD) && (subframe_select(fp,proc_rxtx0->subframe_tx)==SF_
   while(L1_proc_tx->instance_cnt == 0){ //check if the previous has finished
     pthread_cond_wait(&L1_proc_tx->cond,&L1_proc_tx->mutex);
   }
-
+VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_L1_PROC_TX_IC,L1_proc_tx->instance_cnt);
   L1_proc_tx->instance_cnt = 0; // set go for the current one
-
+VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_L1_PROC_TX_IC,L1_proc_tx->instance_cnt);
   
   L1_proc_tx->subframe_rx   = L1_proc->subframe_rx;
   L1_proc_tx->frame_rx      = L1_proc->frame_rx;
@@ -591,8 +596,6 @@ int wakeup_rxtx(PHY_VARS_eNB *eNB,RU_t *ru) {
   L1_rxtx_proc_t *L1_proc=&proc->L1_proc;
   LTE_DL_FRAME_PARMS *fp = &eNB->frame_parms;
   
-  LOG_I(PHY,"ENTERED wakeup_rxtx\n");
-  
   int i;
   struct timespec wait;
   
@@ -611,9 +614,10 @@ int wakeup_rxtx(PHY_VARS_eNB *eNB,RU_t *ru) {
     exit_fun( "error locking mutex_rxtx" );
     return(-1);
   }
-  
+  VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_L1_PROC_IC,L1_proc->instance_cnt);
   ++L1_proc->instance_cnt;
-  
+  VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_L1_PROC_IC,L1_proc->instance_cnt);
+
   // We have just received and processed the common part of a subframe, say n. 
   // TS_rx is the last received timestamp (start of 1st slot), TS_tx is the desired 
   // transmitted timestamp of the next TX slot (first).
@@ -626,6 +630,8 @@ int wakeup_rxtx(PHY_VARS_eNB *eNB,RU_t *ru) {
   L1_proc->frame_tx     = (L1_proc->subframe_rx > (9-sf_ahead)) ? (L1_proc->frame_rx+1)&1023 : L1_proc->frame_rx;
   L1_proc->subframe_tx  = (L1_proc->subframe_rx + sf_ahead)%10;
 
+  LOG_D(PHY,"wakeup_rxtx: L1_proc->subframe_rx %d, L1_proc->subframe_tx %d\n",L1_proc->subframe_rx,L1_proc->subframe_tx);
+
   // the thread can now be woken up
   if (pthread_cond_signal(&L1_proc->cond) != 0) {
     LOG_E( PHY, "[eNB] ERROR pthread_cond_signal for eNB RXn-TXnp4 thread\n");
@@ -635,6 +641,11 @@ int wakeup_rxtx(PHY_VARS_eNB *eNB,RU_t *ru) {
   
   pthread_mutex_unlock( &L1_proc->mutex);
 
+  VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_WAKEUP_RXTX_RX_RU+ru->idx, L1_proc->frame_rx);
+  VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_WAKEUP_RXTX_RX_RU+ru->idx, L1_proc->subframe_rx);
+  VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_WAKEUP_RXTX_TX_RU+ru->idx, L1_proc->frame_tx);
+  VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_WAKEUP_RXTX_TX_RU+ru->idx, L1_proc->subframe_tx);
+
   return(0);
 }
 
diff --git a/targets/RT/USER/lte-ru.c b/targets/RT/USER/lte-ru.c
index 9e55f4f9f5..87f9d3cb9e 100644
--- a/targets/RT/USER/lte-ru.c
+++ b/targets/RT/USER/lte-ru.c
@@ -155,18 +155,17 @@ static inline void fh_if5_south_out(RU_t *ru) {
 // southbound IF4p5 fronthaul
 static inline void fh_if4p5_south_out(RU_t *ru) {
   if (ru == RC.ru[0]) VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_TRX_TST, ru->proc.timestamp_tx&0xffffffff );
-  LOG_I(PHY,"ENTERED fh_if4p5_south_out   Sending IF4p5 for frame %d subframe %d ru %d\n",ru->proc.frame_tx,ru->proc.subframe_tx,ru->idx);
   if (subframe_select(&ru->frame_parms,ru->proc.subframe_tx)!=SF_UL) {
     send_IF4p5(ru,ru->proc.frame_tx, ru->proc.subframe_tx, IF4p5_PDLFFT);
     ru->south_out_cnt++;
-    LOG_I(PHY,"south_out_cnt %d\n",ru->south_out_cnt);
+    LOG_D(PHY,"south_out_cnt %d\n",ru->south_out_cnt);
   }
 /*if (ru == RC.ru[0] || ru == RC.ru[1]) {
     VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_TX0_RU+ru->idx, ru->proc.frame_tx );
     VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_TX0_RU+ru->idx, ru->proc.subframe_tx );
   }*/
-VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_IF4P5_SOUTH_OUT,ru->proc.frame_tx);
-VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_IF4P5_SOUTH_OUT,ru->proc.subframe_tx);
+VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_IF4P5_SOUTH_OUT_RU+ru->idx,ru->proc.frame_tx);
+VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_IF4P5_SOUTH_OUT_RU+ru->idx,ru->proc.subframe_tx);
 
 }
 
@@ -211,7 +210,6 @@ void fh_if4p5_south_in(RU_t *ru,int *frame,int *subframe) {
   RU_proc_t *proc = &ru->proc;
   int f,sf;
 
-LOG_I(PHY,"ENTERED fh_if4p5_south_in\n");
   uint16_t packet_type;
   uint32_t symbol_number=0;
   uint32_t symbol_mask_full;
@@ -220,7 +218,7 @@ LOG_I(PHY,"ENTERED fh_if4p5_south_in\n");
     symbol_mask_full = (1<<fp->ul_symbols_in_S_subframe)-1;   
   else     
     symbol_mask_full = (1<<fp->symbols_per_tti)-1; 
-  LOG_I(PHY,"fh_if4p5_south_in: RU %d, frame %d, subframe %d, ru %d\n",ru->idx,*frame,*subframe,ru->idx);
+  LOG_D(PHY,"fh_if4p5_south_in: RU %d, frame %d, subframe %d, ru %d\n",ru->idx,*frame,*subframe,ru->idx);
   AssertFatal(proc->symbol_mask[*subframe]==0,"rx_fh_if4p5: proc->symbol_mask[%d] = %x\n",*subframe,proc->symbol_mask[*subframe]);
   do {
     recv_IF4p5(ru, &f, &sf, &packet_type, &symbol_number);
@@ -271,8 +269,8 @@ LOG_I(PHY,"ENTERED fh_if4p5_south_in\n");
     
   }*/
 
-  VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_IF4P5_SOUTH_IN,f);
-  VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_IF4P5_SOUTH_IN,sf);
+  VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_IF4P5_SOUTH_IN_RU+ru->idx,f);
+  VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_IF4P5_SOUTH_IN_RU+ru->idx,sf);
 
   proc->symbol_mask[sf] = 0;  
   VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_TRX_TS, proc->timestamp_rx&0xffffffff );
@@ -424,7 +422,7 @@ void fh_if4p5_north_asynch_in(RU_t *ru,int *frame,int *subframe) {
   LOG_D(PHY,"fh_if4p5_north_asynch_in: RU %d, frame %d, subframe %d\n",ru->idx,*frame,*subframe);
   do {   
     recv_IF4p5(ru, &frame_tx, &subframe_tx, &packet_type, &symbol_number);
-    LOG_D(PHY,"income frame.subframe %d.%d, our frame.subframe %d.%d.%d (symbol mask %x)\n",frame_tx,subframe_tx,*frame,*subframe,symbol_number,symbol_mask);
+    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);
     if (ru->cmd == STOP_RU){
       LOG_E(PHY,"Got STOP_RU\n");
       pthread_mutex_lock(&proc->mutex_ru);
@@ -713,7 +711,6 @@ void tx_rf(RU_t *ru) {
   lte_subframe_t nextSF_type = subframe_select(fp,(proc->subframe_tx+1)%10);
   int sf_extension = 0;
   
-  LOG_D(PHY,"south_out/tx_rf: frame %d, subframe %d\n",proc->frame_tx,proc->subframe_tx);
 
   if ((SF_type == SF_DL) ||
       (SF_type == SF_S)) {
@@ -802,7 +799,7 @@ void tx_rf(RU_t *ru) {
 				      ru->nb_tx,
 				      flags);
     ru->south_out_cnt++;
-    LOG_I(PHY,"south_out_cnt %d\n",ru->south_out_cnt);
+    LOG_D(PHY,"south_out_cnt %d, frame %d, subframe %d\n",ru->south_out_cnt,proc->frame_tx,proc->subframe_tx);
     int se = dB_fixed(signal_energy(txp[0],siglen+sf_extension));
 
     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,
@@ -1162,10 +1159,8 @@ void wakeup_L1s(RU_t *ru) {
   L1_proc_t *proc      = &eNB->proc;
   RU_proc_t  *ruproc    = &ru->proc;
   struct timespec t;
-  LOG_D(PHY,"wakeup_eNBs (num %d) for RU %d (state %s)ru->eNB_top:%p\n",ru->num_eNB,ru->idx, ru_states[ru->state],ru->eNB_top);
-
-  LOG_I(PHY,"wakeup_L1s (num %d) for RU %d ru->eNB_top:%p\n",ru->num_eNB,ru->idx, ru->eNB_top);
 
+  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
   
@@ -1173,9 +1168,10 @@ void wakeup_L1s(RU_t *ru) {
     sprintf(string,"Incoming RU %d",ru->idx);
     
     AssertFatal(0==pthread_mutex_lock(&proc->mutex_RU),"");
-    LOG_D(PHY,"Frame %d, Subframe %d: RU %d done (wait_cnt %d),RU_mask[%d] %x\n",
+    LOG_D(PHY,"wakeup_L1s: Frame %d, Subframe %d: RU %d done (wait_cnt %d),RU_mask[%d] %x\n",
           ru->proc.frame_rx,ru->proc.subframe_rx,ru->idx,ru->wait_cnt,ru->proc.subframe_rx,proc->RU_mask[ru->proc.subframe_rx]);
-    
+    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_WAKEUP_L1S_RU+ru->idx, ru->proc.frame_rx);
+      VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_WAKEUP_L1S_RU+ru->idx, ru->proc.subframe_rx);
     clock_gettime(CLOCK_MONOTONIC,&ru->proc.t[ru->proc.subframe_rx]);
     
     if (proc->RU_mask[ru->proc.subframe_rx] == 0){
@@ -1189,7 +1185,8 @@ void wakeup_L1s(RU_t *ru) {
       if (ru == eNB->RU_list[i]) {
 //	AssertFatal((proc->RU_mask&(1<<i)) == 0, "eNB %d frame %d, subframe %d : previous information from RU %d (num_RU %d,mask %x) has not been served yet!\n",eNB->Mod_id,ru->proc.frame_rx,ru->proc.subframe_rx,ru->idx,eNB->num_RU,proc->RU_mask);
         proc->RU_mask[ru->proc.subframe_rx] |= (1<<i);
-      }else if (eNB->RU_list[i]->state == RU_SYNC){
+      }else if (eNB->RU_list[i]->state == RU_SYNC || 
+                (eNB->RU_list[i]->is_slave==1 && eNB->RU_list[i]->wait_cnt>0)){
       	proc->RU_mask[ru->proc.subframe_rx] |= (1<<i);
       }
 
@@ -1205,7 +1202,7 @@ void wakeup_L1s(RU_t *ru) {
     //clock_gettime(CLOCK_MONOTONIC,&t);
     //LOG_I(PHY,"RU mask is now %x, time is %lu\n",proc->RU_mask[ru->proc.subframe_rx], t.tv_nsec - proc->t[ru->proc.subframe_rx].tv_nsec);
 
-    if (proc->RU_mask[ru->proc.subframe_rx] == (1<<eNB->num_RU)-1) {
+    if (proc->RU_mask[ru->proc.subframe_rx] == (1<<eNB->num_RU)-1) { // all RUs have provided their information so continue on and wakeup eNB top
       LOG_D(PHY, "ru_mask is %d \n ", proc->RU_mask[ru->proc.subframe_rx]);
       LOG_D(PHY, "the number of RU is %d, the current ru is RU %d \n ", (1<<eNB->num_RU)-1, ru->idx);
       LOG_D(PHY, "ru->proc.subframe_rx is %d \n", ru->proc.subframe_rx);
@@ -1215,13 +1212,14 @@ void wakeup_L1s(RU_t *ru) {
       //stop_meas(&proc->ru_arrival_time);
       AssertFatal(t.tv_nsec < proc->t[ru->proc.subframe_rx].tv_nsec+5000000,
                   "Time difference for subframe %d (Frame %d) => %lu > 5ms, this is RU %d\n",
-                  ru->proc.subframe_rx, ru->proc.frame_rx,t.tv_nsec - proc->t[ru->proc.subframe_rx].tv_nsec, ru->idx);
+                  ru->proc.subframe_rx, ru->proc.frame_rx, t.tv_nsec - proc->t[ru->proc.subframe_rx].tv_nsec, ru->idx);
     
-
+     // VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_WAKEUP_L1S_RU+ru->idx, ru->proc.frame_rx);
+      //VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_WAKEUP_L1S_RU+ru->idx, ru->proc.subframe_rx);
       AssertFatal(0==pthread_mutex_unlock(&proc->mutex_RU),"");
 
       // unlock RUs that are waiting for eNB processing to be completed
-      LOG_D(PHY,"RU %d wakeup eNB top for for subframe %d\n", ru->idx,ru->proc.subframe_rx);
+      LOG_D(PHY,"RU %d wakeup eNB top for subframe %d\n", ru->idx,ru->proc.subframe_rx);
       if (ru->wait_cnt == 0) {
          if (ru->num_eNB==1 && ru->eNB_top!=0 && get_thread_parallel_conf() == PARALLEL_SINGLE_THREAD)
             ru->eNB_top(eNB_list[0],proc->frame_rx,proc->subframe_rx,string,ru);
@@ -1235,16 +1233,17 @@ void wakeup_L1s(RU_t *ru) {
             }
          }
       }
-      AssertFatal(0==pthread_mutex_lock(&ruproc->mutex_eNBs),"");
+    /*  AssertFatal(0==pthread_mutex_lock(&ruproc->mutex_eNBs),"");
       LOG_D(PHY,"RU %d sending signal to unlock waiting ru_threads\n", ru->idx);
       AssertFatal(0==pthread_cond_broadcast(&ruproc->cond_eNBs),"");
       if (ruproc->instance_cnt_eNBs==-1) ruproc->instance_cnt_eNBs++;
       AssertFatal(0==pthread_mutex_unlock(&ruproc->mutex_eNBs),"");
- 
+ */
 
     }
-    else 
-      AssertFatal(0==pthread_mutex_unlock(&proc->mutex_RU),"");
+    else{ // not all RUs have provided their information  
+    	AssertFatal(0==pthread_mutex_unlock(&proc->mutex_RU),"");
+    }
 //      pthread_mutex_unlock(&proc->mutex_RU);
 //      LOG_D(PHY,"wakeup eNB top for for subframe %d\n", ru->proc.subframe_rx);
 //      ru->eNB_top(eNB_list[0],ru->proc.frame_rx,ru->proc.subframe_rx,string);
@@ -1520,17 +1519,17 @@ static void* ru_thread_tx( void* param ) {
   //wait_sync("ru_thread_tx");
   wait_on_condition(&proc->mutex_FH1,&proc->cond_FH1,&proc->instance_cnt_FH1,"ru_thread_tx");
 
-  printf( "ru_thread_tx ready\n");
+  //printf( "ru_thread_tx ready\n");
   while (!oai_exit) { 
 
     VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_CPUID_RU_THREAD_TX,sched_getcpu());   
     if (oai_exit) break;   
 
 
-    LOG_I(PHY,"ru_thread_tx (ru %d): Waiting for TX processing\n",ru->idx);
+    LOG_D(PHY,"ru_thread_tx (ru %d): Waiting for TX processing\n",ru->idx);
     // wait until eNBs are finished subframe RX n and TX n+4
     wait_on_condition(&proc->mutex_eNBs,&proc->cond_eNBs,&proc->instance_cnt_eNBs,"ru_thread_tx");
-    LOG_I(PHY,"ru_thread_tx (ru %d): Woken from condition\n",ru->idx);
+    LOG_D(PHY,"ru_thread_tx (ru %d): Woken from condition\n",ru->idx);
     if (oai_exit) break;
     //printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~ru_thread_tx is waken up %d.%d having L1 %d\n", proc->frame_tx, proc->subframe_tx, ru->num_eNB);
   	       
@@ -1545,8 +1544,10 @@ static void* ru_thread_tx( void* param ) {
   	      
       if (ru->fh_north_out) ru->fh_north_out(ru);
 	}
+    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_IC_ENB,proc->instance_cnt_eNBs);
     release_thread(&proc->mutex_eNBs,&proc->instance_cnt_eNBs,"ru_thread_tx");
-    
+    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_IC_ENB,proc->instance_cnt_eNBs);
+
     for(int i = 0; i<ru->num_eNB; i++)
     {
       eNB       = ru->eNB_list[i];
@@ -1561,19 +1562,22 @@ static void* ru_thread_tx( void* param ) {
 	      eNB->Mod_id,eNB_proc->frame_rx,eNB_proc->subframe_rx,ru->idx,eNB->num_RU,eNB_proc->RU_mask_tx);
           eNB_proc->RU_mask_tx |= (1<<j);
         }
+        else if (eNB->RU_list[j]->state == RU_SYNC){
+      		eNB_proc->RU_mask_tx |= (1<<j);
+        }
       }
       if (eNB_proc->RU_mask_tx != (1<<eNB->num_RU)-1) {  // not all RUs have provided their information so return
-printf("~~~~~~~~~~~~~~~~~~~~~~(mask = %d)\n", eNB_proc->RU_mask_tx);
+      	LOG_I(PHY,"Not all RUs have provided their info (mask = %d)\n", eNB_proc->RU_mask_tx);
         pthread_mutex_unlock(&eNB_proc->mutex_RU_tx);
       }
       else { // all RUs TX are finished so send the ready signal to eNB processing
-printf("~~~~~~~~~~~~~~~~~~~~~~ready to send wakeup signal\n");
+      	LOG_I(PHY,"All RUs TX are finished. Ready to send wakeup signal to eNB processing\n");
         eNB_proc->RU_mask_tx = 0;
         pthread_mutex_unlock(&eNB_proc->mutex_RU_tx);
 
         pthread_mutex_lock( &L1_proc->mutex_RUs);
         L1_proc->instance_cnt_RUs = 0;
-printf("~~~~~~~~~~~~~~~~~~~~~~ru_thread_tx send signal to L1_thread_tx with (mask = %d)\n", eNB_proc->RU_mask_tx);
+        LOG_I(PHY,"ru_thread_tx send signal to L1_thread_tx with (mask = %d)\n", eNB_proc->RU_mask_tx);
         // the thread can now be woken up
         if (pthread_cond_signal(&L1_proc->cond_RUs) != 0) {
           LOG_E( PHY, "[eNB] ERROR pthread_cond_signal for eNB TXnp4 thread\n");
@@ -1685,7 +1689,7 @@ static void* ru_thread( void* param ) {
       if (wait_on_condition(&ru->proc.mutex_ru,&ru->proc.cond_ru_thread,&ru->proc.instance_cnt_ru,"ru_thread")<0) break;
     }
     else wait_sync("ru_thread");
-
+if(!emulate_rf){
     if (ru->is_slave == 0) AssertFatal(ru->state == RU_RUN,"ru-%d state = %s != RU_RUN\n",ru->idx,ru_states[ru->state]);
     else if (ru->is_slave == 1) AssertFatal(ru->state == RU_SYNC || ru->state == RU_RUN || ru->state == RU_CHECK_SYNC,"ru %d state = %s != RU_SYNC or RU_RUN or RU_CHECK_SYNC\n",ru->idx,ru_states[ru->state]); 
     // Start RF device if any
@@ -1695,7 +1699,7 @@ static void* ru_thread( void* param ) {
       else LOG_I(PHY,"RU %d rf device ready\n",ru->idx);
     }
     else LOG_D(PHY,"RU %d no rf device\n",ru->idx);
-
+}
 
     // if an asnych_rxtx thread exists
     // wakeup the thread because the devices are ready at this point
@@ -1776,7 +1780,7 @@ static void* ru_thread( void* param ) {
 
         ru->wait_cnt--;
 
-        LOG_D(PHY,"RU thread %d, frame %d, subframe %d, wait_cnt %d \n",ru->idx, frame, subframe, ru->wait_cnt);
+        LOG_I(PHY,"RU thread %d, frame %d, subframe %d, wait_cnt %d \n",ru->idx, frame, subframe, ru->wait_cnt);
 
         if (ru->if_south!=LOCAL_RF && ru->wait_cnt <=20 && subframe == 5 && frame != RC.ru[0]->proc.frame_rx && resynch_done == 0) {
         // Send RRU_frame adjust
@@ -1789,7 +1793,6 @@ static void* ru_thread( void* param ) {
           AssertFatal((ru->ifdevice.trx_ctlsend_func(&ru->ifdevice,&rru_config_msg,rru_config_msg.len)!=-1),"Failed to send msg to RAU\n");
           resynch_done=1;
         }
-      
         wakeup_L1s(ru);
       }
       else {
@@ -1850,7 +1853,6 @@ static void* ru_thread( void* param ) {
 	  exit_fun("error unlocking mutex_pre_scd");
 	}
 #endif
-
     // wakeup all eNB processes waiting for this RU
     if (ru->num_eNB>0) wakeup_L1s(ru);
     
diff --git a/targets/RT/USER/ru_control.c b/targets/RT/USER/ru_control.c
index af837c9dff..ca2526cbf1 100644
--- a/targets/RT/USER/ru_control.c
+++ b/targets/RT/USER/ru_control.c
@@ -705,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){
-                  LOG_I(PHY,"Received RRU_sync_ok from RRU %d\n",ru->idx);
+                  printf(PHY,"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 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");