Merge branch 'develop' into enhancement-16-tm_rrc_reconfig

cmake_targets/CMakeLists.txt

@@ -556,7 +556,7 @@ elseif (${RF_BOARD} STREQUAL "OAI_USRP")
   set(HW_SOURCE ${HW_SOURCE}
     ${OPENAIR_TARGETS}/ARCH/USRP/USERSPACE/LIB/usrp_lib.cpp)
   LINK_DIRECTORIES("/opt/lib")
-  set(option_HW_lib "-luhd -rdynamic -ldl")
+  set(option_HW_lib "-luhd -rdynamic -ldl -lboost_system")
 
 elseif (${RF_BOARD} STREQUAL "OAI_BLADERF")
   include_directories("${OPENAIR_TARGETS}/ARCH/BLADERF/USERSPACE/LIB/")
@@ -1641,7 +1641,6 @@ target_link_libraries (lte-softmodem -ldl
 
 target_link_libraries (lte-softmodem ${LIBXML2_LIBRARIES})
 target_link_libraries (lte-softmodem pthread m ${CONFIG_LIBRARIES} rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} ${NETTLE_LIBRARIES} sctp ${option_HW_lib} ${option_TP_lib} ${XFORMS_LIBRARIES} ) 
-target_link_libraries (lte-softmodem ${LIBBOOST_LIBRARIES} -lboost_system) #Added manually as it is not found for some reason for USRP
 target_link_libraries (lte-softmodem ${LIB_LMS_LIBRARIES})
 target_link_libraries (lte-softmodem ${T_LIB})
 
@@ -1677,7 +1676,6 @@ target_link_libraries (lte-softmodem-nos1
 
 target_link_libraries (lte-softmodem-nos1 ${LIBXML2_LIBRARIES})
 target_link_libraries (lte-softmodem-nos1 pthread m ${CONFIG_LIBRARIES} rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} ${NETTLE_LIBRARIES}  ${option_HW_lib}  ${option_TP_lib} ${XFORMS_LIBRARIES} )
-target_link_libraries (lte-softmodem-nos1 ${LIBBOOST_LIBRARIES} -lboost_system) #Added manually as it is not found for some reason for USRP
 target_link_libraries (lte-softmodem-nos1  ${LIB_LMS_LIBRARIES})
 target_link_libraries (lte-softmodem-nos1 ${T_LIB})
 
@@ -1700,7 +1698,7 @@ target_link_libraries(rrh_gw
   UTIL LFDS  
   -Wl,--end-group )
 target_link_libraries (rrh_gw rt pthread m )
-target_link_libraries (rrh_gw  ${option_HW_lib} ${option_TP_lib} ${LIBBOOST_LIBRARIES} -lboost_system ) #Added manually as it is not found for some reason for USRP
+target_link_libraries (rrh_gw  ${option_HW_lib} ${option_TP_lib})
 target_link_libraries (rrh_gw ${LIB_LMS_LIBRARIES})
 target_link_libraries (rrh_gw ${T_LIB})
 

cmake_targets/build_oai

@@ -333,7 +333,7 @@ function main() {
   #By default: EXMIMO: enable
   if [ "$FORCE_DEADLINE_SCHEDULER_FLAG_USER" = "" ]; then
      if [ "$HW" = "EXMIMO" ] ; then 
-        DEADLINE_SCHEDULER_FLAG_USER="False"
+        DEADLINE_SCHEDULER_FLAG_USER="True"
      elif [ "$HW" = "ETHERNET" ] ; then 
         DEADLINE_SCHEDULER_FLAG_USER="True"
      elif [ "$HW" = "OAI_USRP" ] ; then 

openair1/PHY/LTE_TRANSPORT/pucch.c

@@ -1052,12 +1052,11 @@ uint32_t rx_pucch(PHY_VARS_eNB *phy_vars_eNB,
       if (fmt==pucch_format1b)
         *(1+payload) = (stat_im<0) ? 1 : 0;
     } else { // insufficient energy on PUCCH so NAK
-      *payload = 0;
       ((int16_t*)&phy_vars_eNB->pucch1ab_stats[UE_id][(subframe<<10) + (phy_vars_eNB->pucch1ab_stats_cnt[UE_id][subframe])])[0] = (int16_t)(stat_re);
       ((int16_t*)&phy_vars_eNB->pucch1ab_stats[UE_id][(subframe<<10) + (phy_vars_eNB->pucch1ab_stats_cnt[UE_id][subframe])])[1] = (int16_t)(stat_im);
       phy_vars_eNB->pucch1ab_stats_cnt[UE_id][subframe] = (phy_vars_eNB->pucch1ab_stats_cnt[UE_id][subframe]+1)&1023;
 
-      *payload = (stat_re<0) ? 1 : 0;
+      *payload = 0;
 
       if (fmt==pucch_format1b)
         *(1+payload) = 0;

openair1/PHY/MODULATION/slot_fep_ul.c

@@ -50,6 +50,10 @@ int slot_fep_ul(LTE_DL_FRAME_PARMS *frame_parms,
 
   void (*dft)(int16_t *,int16_t *, int);
 
+  int tmp_dft_in[2048] __attribute__ ((aligned (32)));  // This is for misalignment issues for 6 and 15 PRBs
+  unsigned int frame_length_samples = frame_parms->samples_per_tti * 10;
+  unsigned int rx_offset;
+
   switch (frame_parms->ofdm_symbol_size) {
   case 128:
     dft = dft128;
@@ -103,28 +107,37 @@ int slot_fep_ul(LTE_DL_FRAME_PARMS *frame_parms,
 #endif
 
   for (aa=0; aa<frame_parms->nb_antennas_rx; aa++) {
-
+    rx_offset = slot_offset +nb_prefix_samples0;
     if (l==0) {
 
-      dft(
-#ifndef OFDMA_ULSCH
-        (int16_t *)&eNB_common_vars->rxdata_7_5kHz[eNB_id][aa][slot_offset +
-            nb_prefix_samples0],
-#else
-        (int16_t *)&eNB_common_vars->rxdata[eNB_id][aa][((frame_parms->samples_per_tti>>1)*Ns) +
-            nb_prefix_samples0],
-#endif
-        (int16_t *)&eNB_common_vars->rxdataF[eNB_id][aa][frame_parms->ofdm_symbol_size*symbol],1);
+      dft( (int16_t *)&eNB_common_vars->rxdata_7_5kHz[eNB_id][aa][rx_offset],
+           (int16_t *)&eNB_common_vars->rxdataF[eNB_id][aa][frame_parms->ofdm_symbol_size*symbol],
+           1
+         );
     } else {
-      dft(
-#ifndef OFDMA_ULSCH
-        (short *)&eNB_common_vars->rxdata_7_5kHz[eNB_id][aa][slot_offset +
-#else
-        (short *)&eNB_common_vars->rxdata[eNB_id][aa][((frame_parms->samples_per_tti>>1)*Ns) +
-#endif
-            (frame_parms->ofdm_symbol_size+nb_prefix_samples0+nb_prefix_samples) +
-            (frame_parms->ofdm_symbol_size+nb_prefix_samples)*(l-1)],
-        (short*)&eNB_common_vars->rxdataF[eNB_id][aa][frame_parms->ofdm_symbol_size*symbol],1);
+      rx_offset += (frame_parms->ofdm_symbol_size+nb_prefix_samples)*l;
+      if(rx_offset > (frame_length_samples - frame_parms->ofdm_symbol_size))
+      {
+        memcpy((void *)&eNB_common_vars->rxdata_7_5kHz[eNB_id][aa][frame_length_samples],
+               (void *)&eNB_common_vars->rxdata_7_5kHz[eNB_id][aa][0],
+               frame_parms->ofdm_symbol_size*sizeof(int));
+      }
+
+      if( (rx_offset & 7) != 0){
+        memcpy((void *)&tmp_dft_in,
+        		(void *)&eNB_common_vars->rxdata_7_5kHz[eNB_id][aa][(rx_offset % frame_length_samples)],
+				frame_parms->ofdm_symbol_size*sizeof(int));
+        dft( (short *) tmp_dft_in,
+             (short*)  &eNB_common_vars->rxdataF[eNB_id][aa][frame_parms->ofdm_symbol_size*symbol],
+             1
+           );
+      }
+      else{
+      dft( (short *)&eNB_common_vars->rxdata_7_5kHz[eNB_id][aa][rx_offset],
+           (short*)&eNB_common_vars->rxdataF[eNB_id][aa][frame_parms->ofdm_symbol_size*symbol],
+           1
+         );
+      }
     }
   }
 

openair2/ENB_APP/enb_config.c

@@ -60,6 +60,27 @@
 #include "SystemInformationBlockType2.h"
 #include "LAYER2/MAC/extern.h"
 
+/* those macros are here to help diagnose problems in configuration files
+ * if the lookup fails, a warning is printed
+ * (yes we can use the function name for the macro itself, the C preprocessor
+ * won't die in an infinite loop)
+ */
+#define config_setting_lookup_int(setting, name, value) \
+    (config_setting_lookup_int(setting, name, value) || \
+    (printf("WARNING: setting '%s' not found in configuration file\n", name), 0))
+#define config_setting_lookup_int64(setting, name, value) \
+    (config_setting_lookup_int64(setting, name, value) || \
+    (printf("WARNING: setting '%s' not found in configuration file\n", name), 0))
+#define config_setting_lookup_float(setting, name, value) \
+    (config_setting_lookup_float(setting, name, value) || \
+    (printf("WARNING: setting '%s' not found in configuration file\n", name), 0))
+#define config_setting_lookup_bool(setting, name, value) \
+    (config_setting_lookup_bool(setting, name, value) || \
+    (printf("WARNING: setting '%s' not found in configuration file\n", name), 0))
+#define config_setting_lookup_string(setting, name, value) \
+    (config_setting_lookup_string(setting, name, value) || \
+    (printf("WARNING: setting '%s' not found in configuration file\n", name), 0))
+
 #define ENB_CONFIG_STRING_ACTIVE_ENBS                   "Active_eNBs"
 
 #define ENB_CONFIG_STRING_ENB_LIST                      "eNBs"
@@ -514,7 +535,6 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
   int               num_component_carriers        = 0;
   int               i                             = 0;
   int               j                             = 0;
-  int               parse_errors                  = 0;
   libconfig_int     enb_id                        = 0;
   const char*       cell_type                     = NULL;
   const char*       tac                           = 0;
@@ -716,7 +736,6 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
 
   if (setting != NULL) {
     enb_properties_index = 0;
-    parse_errors      = 0;
     num_enbs = config_setting_length(setting);
 
     for (i = 0; i < num_enbs; i++) {
@@ -743,7 +762,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
 
             )
         ) {
-        AssertError (0, parse_errors ++,
+        AssertFatal (0,
                      "Failed to parse eNB configuration file %s, %u th enb\n",
                      lib_config_file_name_pP, i);
         continue; // FIXME this prevents segfaults below, not sure what happens after function exit
@@ -761,7 +780,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
           } else  if (strcmp(cell_type, "CELL_HOME_ENB") == 0) {
             enb_properties.properties[enb_properties_index]->cell_type = CELL_HOME_ENB;
           } else {
-            AssertError (0, parse_errors ++,
+            AssertFatal (0,
                          "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for cell_type choice: CELL_MACRO_ENB or CELL_HOME_ENB !\n",
                          lib_config_file_name_pP, i, cell_type);
           }
@@ -865,7 +884,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
 
 #endif
                   )) {
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, Component Carrier %d!\n",
                              lib_config_file_name_pP, enb_properties.properties[enb_properties_index]->nb_cc++);
                 continue; // FIXME this prevents segfaults below, not sure what happens after function exit
@@ -874,17 +893,17 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               enb_properties.properties[enb_properties_index]->nb_cc++;
 
               enb_properties.properties[enb_properties_index]->tdd_config[j] = tdd_config;
-              AssertError (tdd_config <= TDD_Config__subframeAssignment_sa6, parse_errors ++,
+              AssertFatal (tdd_config <= TDD_Config__subframeAssignment_sa6,
                            "Failed to parse eNB configuration file %s, enb %d illegal tdd_config %d (should be 0-%d)!",
                            lib_config_file_name_pP, i, tdd_config, TDD_Config__subframeAssignment_sa6);
 
               enb_properties.properties[enb_properties_index]->tdd_config_s[j] = tdd_config_s;
-              AssertError (tdd_config_s <= TDD_Config__specialSubframePatterns_ssp8, parse_errors ++,
+              AssertFatal (tdd_config_s <= TDD_Config__specialSubframePatterns_ssp8,
                            "Failed to parse eNB configuration file %s, enb %d illegal tdd_config_s %d (should be 0-%d)!",
                            lib_config_file_name_pP, i, tdd_config_s, TDD_Config__specialSubframePatterns_ssp8);
 
               if (!prefix_type)
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d define %s: NORMAL,EXTENDED!\n",
                              lib_config_file_name_pP, i, ENB_CONFIG_STRING_PREFIX_TYPE);
               else if (strcmp(prefix_type, "NORMAL") == 0) {
@@ -892,7 +911,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               } else  if (strcmp(prefix_type, "EXTENDED") == 0) {
                 enb_properties.properties[enb_properties_index]->prefix_type[j] = EXTENDED;
               } else {
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for prefix_type choice: NORMAL or EXTENDED !\n",
                              lib_config_file_name_pP, i, prefix_type);
               }
@@ -903,7 +922,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               enb_properties.properties[enb_properties_index]->Nid_cell[j]= Nid_cell;
 
               if (Nid_cell>503) {
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for Nid_cell choice: 0...503 !\n",
                              lib_config_file_name_pP, i, Nid_cell);
               }
@@ -911,7 +930,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               enb_properties.properties[enb_properties_index]->N_RB_DL[j]= N_RB_DL;
 
               if ((N_RB_DL!=6) && (N_RB_DL!=15) && (N_RB_DL!=25) && (N_RB_DL!=50) && (N_RB_DL!=75) && (N_RB_DL!=100)) {
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for N_RB_DL choice: 6,15,25,50,75,100 !\n",
                              lib_config_file_name_pP, i, N_RB_DL);
               }
@@ -921,27 +940,27 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               } else  if (strcmp(frame_type, "TDD") == 0) {
                 enb_properties.properties[enb_properties_index]->frame_type[j] = TDD;
               } else {
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for frame_type choice: FDD or TDD !\n",
                              lib_config_file_name_pP, i, frame_type);
               }
 
 
               enb_properties.properties[enb_properties_index]->tdd_config[j] = tdd_config;
-              AssertError (tdd_config <= TDD_Config__subframeAssignment_sa6, parse_errors ++,
+              AssertFatal (tdd_config <= TDD_Config__subframeAssignment_sa6,
                            "Failed to parse eNB configuration file %s, enb %d illegal tdd_config %d (should be 0-%d)!",
                            lib_config_file_name_pP, i, tdd_config, TDD_Config__subframeAssignment_sa6);
 
 
               enb_properties.properties[enb_properties_index]->tdd_config_s[j] = tdd_config_s;
-              AssertError (tdd_config_s <= TDD_Config__specialSubframePatterns_ssp8, parse_errors ++,
+              AssertFatal (tdd_config_s <= TDD_Config__specialSubframePatterns_ssp8,
                            "Failed to parse eNB configuration file %s, enb %d illegal tdd_config_s %d (should be 0-%d)!",
                            lib_config_file_name_pP, i, tdd_config_s, TDD_Config__specialSubframePatterns_ssp8);
 
 
 
               if (!prefix_type)
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d define %s: NORMAL,EXTENDED!\n",
                              lib_config_file_name_pP, i, ENB_CONFIG_STRING_PREFIX_TYPE);
               else if (strcmp(prefix_type, "NORMAL") == 0) {
@@ -949,7 +968,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               } else  if (strcmp(prefix_type, "EXTENDED") == 0) {
                 enb_properties.properties[enb_properties_index]->prefix_type[j] = EXTENDED;
               } else {
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for prefix_type choice: NORMAL or EXTENDED !\n",
                              lib_config_file_name_pP, i, prefix_type);
               }
@@ -967,64 +986,66 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
 
               enb_properties.properties[enb_properties_index]->uplink_frequency_offset[j] = (unsigned int) uplink_frequency_offset;
 
-              parse_errors += enb_check_band_frequencies(lib_config_file_name_pP,
+              if (enb_check_band_frequencies(lib_config_file_name_pP,
                               enb_properties_index,
                               enb_properties.properties[enb_properties_index]->eutra_band[j],
                               enb_properties.properties[enb_properties_index]->downlink_frequency[j],
                               enb_properties.properties[enb_properties_index]->uplink_frequency_offset[j],
-                              enb_properties.properties[enb_properties_index]->frame_type[j]);
+                              enb_properties.properties[enb_properties_index]->frame_type[j])) {
+                AssertFatal(0, "error calling enb_check_band_frequencies\n");
+              }
 
               enb_properties.properties[enb_properties_index]->nb_antennas_tx[j] = nb_antennas_tx;
 
               if ((nb_antenna_ports <1) || (nb_antenna_ports > 2))
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for nb_antenna_ports choice: 1..2 !\n",
                              lib_config_file_name_pP, i, nb_antenna_ports);
 
               enb_properties.properties[enb_properties_index]->nb_antenna_ports[j] = nb_antenna_ports;
 
               if ((nb_antennas_tx <1) || (nb_antennas_tx > 64))
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for nb_antennas_tx choice: 1..4 !\n",
                              lib_config_file_name_pP, i, nb_antennas_tx);
 
               enb_properties.properties[enb_properties_index]->nb_antennas_rx[j] = nb_antennas_rx;
 
               if ((nb_antennas_rx <1) || (nb_antennas_rx > 4))
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for nb_antennas_rx choice: 1..4 !\n",
                              lib_config_file_name_pP, i, nb_antennas_rx);
 
               enb_properties.properties[enb_properties_index]->tx_gain[j] = tx_gain;
 
               if ((tx_gain <0) || (tx_gain > 127))
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for tx_gain choice: 0..127 !\n",
                              lib_config_file_name_pP, i, tx_gain);
 
               enb_properties.properties[enb_properties_index]->rx_gain[j] = rx_gain;
 
               if ((rx_gain <0) || (rx_gain > 160))
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for rx_gain choice: 0..160 !\n",
                              lib_config_file_name_pP, i, rx_gain);
 
               enb_properties.properties[enb_properties_index]->prach_root[j] =  prach_root;
 
               if ((prach_root <0) || (prach_root > 1023))
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for prach_root choice: 0..1023 !\n",
                              lib_config_file_name_pP, i, prach_root);
 
               enb_properties.properties[enb_properties_index]->prach_config_index[j] = prach_config_index;
 
               if ((prach_config_index <0) || (prach_config_index > 63))
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for prach_config_index choice: 0..1023 !\n",
                              lib_config_file_name_pP, i, prach_config_index);
 
               if (!prach_high_speed)
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d define %s: ENABLE,DISABLE!\n",
                              lib_config_file_name_pP, i, ENB_CONFIG_STRING_PRACH_HIGH_SPEED);
               else if (strcmp(prach_high_speed, "ENABLE") == 0) {
@@ -1032,21 +1053,21 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               } else if (strcmp(prach_high_speed, "DISABLE") == 0) {
                 enb_properties.properties[enb_properties_index]->prach_high_speed[j] = FALSE;
               } else
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for prach_config choice: ENABLE,DISABLE !\n",
                              lib_config_file_name_pP, i, prach_high_speed);
 
               enb_properties.properties[enb_properties_index]->prach_zero_correlation[j] =prach_zero_correlation;
 
               if ((prach_zero_correlation <0) || (prach_zero_correlation > 15))
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for prach_zero_correlation choice: 0..15!\n",
                              lib_config_file_name_pP, i, prach_zero_correlation);
 
               enb_properties.properties[enb_properties_index]->prach_freq_offset[j] = prach_freq_offset;
 
               if ((prach_freq_offset <0) || (prach_freq_offset > 94))
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for prach_freq_offset choice: 0..94!\n",
                              lib_config_file_name_pP, i, prach_freq_offset);
 
@@ -1054,21 +1075,21 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               enb_properties.properties[enb_properties_index]->pucch_delta_shift[j] = pucch_delta_shift-1;
 
               if ((pucch_delta_shift <1) || (pucch_delta_shift > 3))
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for pucch_delta_shift choice: 1..3!\n",
                              lib_config_file_name_pP, i, pucch_delta_shift);
 
               enb_properties.properties[enb_properties_index]->pucch_nRB_CQI[j] = pucch_nRB_CQI;
 
               if ((pucch_nRB_CQI <0) || (pucch_nRB_CQI > 98))
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for pucch_nRB_CQI choice: 0..98!\n",
                              lib_config_file_name_pP, i, pucch_nRB_CQI);
 
               enb_properties.properties[enb_properties_index]->pucch_nCS_AN[j] = pucch_nCS_AN;
 
               if ((pucch_nCS_AN <0) || (pucch_nCS_AN > 7))
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for pucch_nCS_AN choice: 0..7!\n",
                              lib_config_file_name_pP, i, pucch_nCS_AN);
 
@@ -1076,7 +1097,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               enb_properties.properties[enb_properties_index]->pucch_n1_AN[j] = pucch_n1_AN;
 
               if ((pucch_n1_AN <0) || (pucch_n1_AN > 2047))
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for pucch_n1_AN choice: 0..2047!\n",
                              lib_config_file_name_pP, i, pucch_n1_AN);
 
@@ -1084,26 +1105,26 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               enb_properties.properties[enb_properties_index]->pdsch_referenceSignalPower[j] = pdsch_referenceSignalPower;
 
               if ((pdsch_referenceSignalPower <-60) || (pdsch_referenceSignalPower > 50))
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for pdsch_referenceSignalPower choice:-60..50!\n",
                              lib_config_file_name_pP, i, pdsch_referenceSignalPower);
 
               enb_properties.properties[enb_properties_index]->pdsch_p_b[j] = pdsch_p_b;
 
               if ((pdsch_p_b <0) || (pdsch_p_b > 3))
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for pdsch_p_b choice: 0..3!\n",
                              lib_config_file_name_pP, i, pdsch_p_b);
 
               enb_properties.properties[enb_properties_index]->pusch_n_SB[j] = pusch_n_SB;
 
               if ((pusch_n_SB <1) || (pusch_n_SB > 4))
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for pusch_n_SB choice: 1..4!\n",
                              lib_config_file_name_pP, i, pusch_n_SB);
 
               if (!pusch_hoppingMode)
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d define %s: interSubframe,intraAndInterSubframe!\n",
                              lib_config_file_name_pP, i, ENB_CONFIG_STRING_PUSCH_HOPPINGMODE);
               else if (strcmp(pusch_hoppingMode,"interSubFrame")==0) {
@@ -1111,19 +1132,19 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               }  else if (strcmp(pusch_hoppingMode,"intraAndInterSubFrame")==0) {
                 enb_properties.properties[enb_properties_index]->pusch_hoppingMode[j] = PUSCH_ConfigCommon__pusch_ConfigBasic__hoppingMode_intraAndInterSubFrame;
               } else
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for pusch_hoppingMode choice: interSubframe,intraAndInterSubframe!\n",
                              lib_config_file_name_pP, i, pusch_hoppingMode);
 
               enb_properties.properties[enb_properties_index]->pusch_hoppingOffset[j] = pusch_hoppingOffset;
 
               if ((pusch_hoppingOffset<0) || (pusch_hoppingOffset>98))
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for pusch_hoppingOffset choice: 0..98!\n",
                              lib_config_file_name_pP, i, pusch_hoppingMode);
 
               if (!pusch_enable64QAM)
-                AssertError (0, parse_errors ++,
+                AssertFatal (0, 
                              "Failed to parse eNB configuration file %s, enb %d define %s: ENABLE,DISABLE!\n",
                              lib_config_file_name_pP, i, ENB_CONFIG_STRING_PUSCH_ENABLE64QAM);
               else if (strcmp(pusch_enable64QAM, "ENABLE") == 0) {
@@ -1131,12 +1152,12 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               }  else if (strcmp(pusch_enable64QAM, "DISABLE") == 0) {
                 enb_properties.properties[enb_properties_index]->pusch_enable64QAM[j] = FALSE;
               } else
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for pusch_enable64QAM choice: ENABLE,DISABLE!\n",
                              lib_config_file_name_pP, i, pusch_enable64QAM);
 
               if (!pusch_groupHoppingEnabled)
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d define %s: ENABLE,DISABLE!\n",
                              lib_config_file_name_pP, i, ENB_CONFIG_STRING_PUSCH_GROUP_HOPPING_EN);
               else if (strcmp(pusch_groupHoppingEnabled, "ENABLE") == 0) {
@@ -1144,7 +1165,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               }  else if (strcmp(pusch_groupHoppingEnabled, "DISABLE") == 0) {
                 enb_properties.properties[enb_properties_index]->pusch_groupHoppingEnabled[j] = FALSE;
               } else
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for pusch_groupHoppingEnabled choice: ENABLE,DISABLE!\n",
                              lib_config_file_name_pP, i, pusch_groupHoppingEnabled);
 
@@ -1152,12 +1173,12 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               enb_properties.properties[enb_properties_index]->pusch_groupAssignment[j] = pusch_groupAssignment;
 
               if ((pusch_groupAssignment<0)||(pusch_groupAssignment>29))
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for pusch_groupAssignment choice: 0..29!\n",
                              lib_config_file_name_pP, i, pusch_groupAssignment);
 
               if (!pusch_sequenceHoppingEnabled)
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d define %s: ENABLE,DISABLE!\n",
                              lib_config_file_name_pP, i, ENB_CONFIG_STRING_PUSCH_SEQUENCE_HOPPING_EN);
               else if (strcmp(pusch_sequenceHoppingEnabled, "ENABLE") == 0) {
@@ -1165,14 +1186,14 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               }  else if (strcmp(pusch_sequenceHoppingEnabled, "DISABLE") == 0) {
                 enb_properties.properties[enb_properties_index]->pusch_sequenceHoppingEnabled[j] = FALSE;
               } else
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for pusch_sequenceHoppingEnabled choice: ENABLE,DISABLE!\n",
                              lib_config_file_name_pP, i, pusch_sequenceHoppingEnabled);
 
               enb_properties.properties[enb_properties_index]->pusch_nDMRS1[j] = pusch_nDMRS1;  //cyclic_shift in RRC!
 
               if ((pusch_nDMRS1 <0) || (pusch_nDMRS1>7))
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for pusch_nDMRS1 choice: 0..7!\n",
                              lib_config_file_name_pP, i, pusch_nDMRS1);
 
@@ -1181,7 +1202,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               } else if (strcmp(phich_duration,"EXTENDED")==0) {
                 enb_properties.properties[enb_properties_index]->phich_duration[j] = extended;
               } else
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for phich_duration choice: NORMAL,EXTENDED!\n",
                              lib_config_file_name_pP, i, phich_duration);
 
@@ -1194,7 +1215,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               } else if (strcmp(phich_resource,"TWO")==0) {
                 enb_properties.properties[enb_properties_index]->phich_resource[j] = two;
               } else
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for phich_resource choice: ONESIXTH,HALF,ONE,TWO!\n",
                              lib_config_file_name_pP, i, phich_resource);
 
@@ -1203,7 +1224,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               } else if (strcmp(srs_enable, "DISABLE") == 0) {
                 enb_properties.properties[enb_properties_index]->srs_enable[j] = FALSE;
               } else
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for srs_BandwidthConfig choice: ENABLE,DISABLE !\n",
                              lib_config_file_name_pP, i, srs_enable);
 
@@ -1213,21 +1234,20 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
                       && config_setting_lookup_string(component_carrier, ENB_CONFIG_STRING_SRS_ACKNACKST_CONFIG, &srs_ackNackST)
                       && config_setting_lookup_string(component_carrier, ENB_CONFIG_STRING_SRS_MAXUPPTS, &srs_MaxUpPts)
                      ))
-                  AssertError(0,
-                              parse_errors++,
+                  AssertFatal(0,
                               "Failed to parse eNB configuration file %s, enb %d unknown values for srs_BandwidthConfig, srs_SubframeConfig, srs_ackNackST, srs_MaxUpPts\n",
                               lib_config_file_name_pP, i);
 
                 enb_properties.properties[enb_properties_index]->srs_BandwidthConfig[j] = srs_BandwidthConfig;
 
                 if ((srs_BandwidthConfig < 0) || (srs_BandwidthConfig >7))
-                  AssertError (0, parse_errors ++, "Failed to parse eNB configuration file %s, enb %d unknown value %d for srs_BandwidthConfig choice: 0...7\n",
+                  AssertFatal (0, "Failed to parse eNB configuration file %s, enb %d unknown value %d for srs_BandwidthConfig choice: 0...7\n",
                                lib_config_file_name_pP, i, srs_BandwidthConfig);
 
                 enb_properties.properties[enb_properties_index]->srs_SubframeConfig[j] = srs_SubframeConfig;
 
                 if ((srs_SubframeConfig<0) || (srs_SubframeConfig>15))
-                  AssertError (0, parse_errors ++,
+                  AssertFatal (0,
                                "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for srs_SubframeConfig choice: 0..15 !\n",
                                lib_config_file_name_pP, i, srs_SubframeConfig);
 
@@ -1236,7 +1256,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
                 } else if (strcmp(srs_ackNackST, "DISABLE") == 0) {
                   enb_properties.properties[enb_properties_index]->srs_ackNackST[j] = FALSE;
                 } else
-                  AssertError (0, parse_errors ++,
+                  AssertFatal (0,
                                "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for srs_BandwidthConfig choice: ENABLE,DISABLE !\n",
                                lib_config_file_name_pP, i, srs_ackNackST);
 
@@ -1245,7 +1265,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
                 } else if (strcmp(srs_MaxUpPts, "DISABLE") == 0) {
                   enb_properties.properties[enb_properties_index]->srs_MaxUpPts[j] = FALSE;
                 } else
-                  AssertError (0, parse_errors ++,
+                  AssertFatal (0,
                                "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for srs_MaxUpPts choice: ENABLE,DISABLE !\n",
                                lib_config_file_name_pP, i, srs_MaxUpPts);
               }
@@ -1253,7 +1273,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               enb_properties.properties[enb_properties_index]->pusch_p0_Nominal[j] = pusch_p0_Nominal;
 
               if ((pusch_p0_Nominal<-126) || (pusch_p0_Nominal>24))
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for pusch_p0_Nominal choice: -126..24 !\n",
                              lib_config_file_name_pP, i, pusch_p0_Nominal);
 
@@ -1274,21 +1294,21 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               } else if (strcmp(pusch_alpha,"AL1")==0) {
                 enb_properties.properties[enb_properties_index]->pusch_alpha[j] = UplinkPowerControlCommon__alpha_al1;
               } else
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for pucch_Alpha choice: AL0,AL04,AL05,AL06,AL07,AL08,AL09,AL1!\n",
                              lib_config_file_name_pP, i, pusch_alpha);
 
               enb_properties.properties[enb_properties_index]->pucch_p0_Nominal[j] = pucch_p0_Nominal;
 
               if ((pucch_p0_Nominal<-127) || (pucch_p0_Nominal>-96))
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for pucch_p0_Nominal choice: -127..-96 !\n",
                              lib_config_file_name_pP, i, pucch_p0_Nominal);
 
               enb_properties.properties[enb_properties_index]->msg3_delta_Preamble[j] = msg3_delta_Preamble;
 
               if ((msg3_delta_Preamble<-1) || (msg3_delta_Preamble>6))
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for msg3_delta_Preamble choice: -1..6 !\n",
                              lib_config_file_name_pP, i, msg3_delta_Preamble);
 
@@ -1300,7 +1320,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               } else if (strcmp(pucch_deltaF_Format1,"deltaF2")==0) {
                 enb_properties.properties[enb_properties_index]->pucch_deltaF_Format1[j] = DeltaFList_PUCCH__deltaF_PUCCH_Format1_deltaF2;
               } else
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for pucch_deltaF_Format1 choice: deltaF_2,dltaF0,deltaF2!\n",
                              lib_config_file_name_pP, i, pucch_deltaF_Format1);
 
@@ -1311,7 +1331,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               } else if (strcmp(pucch_deltaF_Format1b,"deltaF5")==0) {
                 enb_properties.properties[enb_properties_index]->pucch_deltaF_Format1b[j] = DeltaFList_PUCCH__deltaF_PUCCH_Format1b_deltaF5;
               } else
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for pucch_deltaF_Format1b choice: deltaF1,dltaF3,deltaF5!\n",
                              lib_config_file_name_pP, i, pucch_deltaF_Format1b);
 
@@ -1325,7 +1345,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               } else if (strcmp(pucch_deltaF_Format2,"deltaF2")==0) {
                 enb_properties.properties[enb_properties_index]->pucch_deltaF_Format2[j] = DeltaFList_PUCCH__deltaF_PUCCH_Format2_deltaF2;
               } else
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for pucch_deltaF_Format2 choice: deltaF_2,dltaF0,deltaF1,deltaF2!\n",
                              lib_config_file_name_pP, i, pucch_deltaF_Format2);
 
@@ -1336,7 +1356,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               } else if (strcmp(pucch_deltaF_Format2a,"deltaF2")==0) {
                 enb_properties.properties[enb_properties_index]->pucch_deltaF_Format2a[j] = DeltaFList_PUCCH__deltaF_PUCCH_Format2a_deltaF2;
               } else
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for pucch_deltaF_Format2a choice: deltaF_2,dltaF0,deltaF2!\n",
                              lib_config_file_name_pP, i, pucch_deltaF_Format2a);
 
@@ -1347,7 +1367,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               } else if (strcmp(pucch_deltaF_Format2b,"deltaF2")==0) {
                 enb_properties.properties[enb_properties_index]->pucch_deltaF_Format2b[j] = DeltaFList_PUCCH__deltaF_PUCCH_Format2b_deltaF2;
               } else
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for pucch_deltaF_Format2b choice: deltaF_2,dltaF0,deltaF2!\n",
                              lib_config_file_name_pP, i, pucch_deltaF_Format2b);
 
@@ -1357,7 +1377,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               enb_properties.properties[enb_properties_index]->rach_numberOfRA_Preambles[j] = (rach_numberOfRA_Preambles/4)-1;
 
               if ((rach_numberOfRA_Preambles <4) || (rach_numberOfRA_Preambles>64) || ((rach_numberOfRA_Preambles&3)!=0))
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for rach_numberOfRA_Preambles choice: 4,8,12,...,64!\n",
                              lib_config_file_name_pP, i, rach_numberOfRA_Preambles);
 
@@ -1367,14 +1387,14 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
                 if (!(config_setting_lookup_int(component_carrier, ENB_CONFIG_STRING_RACH_SIZEOFRA_PREAMBLESGROUPA, &rach_sizeOfRA_PreamblesGroupA)
                       && config_setting_lookup_int(component_carrier, ENB_CONFIG_STRING_RACH_MESSAGESIZEGROUPA, &rach_messageSizeGroupA)
                       && config_setting_lookup_string(component_carrier, ENB_CONFIG_STRING_RACH_MESSAGEPOWEROFFSETGROUPB, &rach_messagePowerOffsetGroupB)))
-                  AssertError (0, parse_errors ++,
+                  AssertFatal (0,
                                "Failed to parse eNB configuration file %s, enb %d  rach_sizeOfRA_PreamblesGroupA, messageSizeGroupA,messagePowerOffsetGroupB!\n",
                                lib_config_file_name_pP, i);
 
                 enb_properties.properties[enb_properties_index]->rach_sizeOfRA_PreamblesGroupA[j] = (rach_sizeOfRA_PreamblesGroupA/4)-1;
 
                 if ((rach_numberOfRA_Preambles <4) || (rach_numberOfRA_Preambles>60) || ((rach_numberOfRA_Preambles&3)!=0))
-                  AssertError (0, parse_errors ++,
+                  AssertFatal (0,
                                "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for rach_sizeOfRA_PreamblesGroupA choice: 4,8,12,...,60!\n",
                                lib_config_file_name_pP, i, rach_sizeOfRA_PreamblesGroupA);
 
@@ -1397,7 +1417,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
                   break;
 
                 default:
-                  AssertError (0, parse_errors ++,
+                  AssertFatal (0,
                                "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for rach_messageSizeGroupA choice: 56,144,208,256!\n",
                                lib_config_file_name_pP, i, rach_messageSizeGroupA);
                   break;
@@ -1434,21 +1454,21 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
                 else if (strcmp(rach_messagePowerOffsetGroupB,"dB18")==0) {
                   enb_properties.properties[enb_properties_index]->rach_messagePowerOffsetGroupB[j] = RACH_ConfigCommon__preambleInfo__preamblesGroupAConfig__messagePowerOffsetGroupB_dB18;
                 } else
-                  AssertError (0, parse_errors ++,
+                  AssertFatal (0,
                                "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for rach_messagePowerOffsetGroupB choice: minusinfinity,dB0,dB5,dB8,dB10,dB12,dB15,dB18!\n",
                                lib_config_file_name_pP, i, rach_messagePowerOffsetGroupB);
 
               } else if (strcmp(rach_preamblesGroupAConfig, "DISABLE") == 0) {
                 enb_properties.properties[enb_properties_index]->rach_preamblesGroupAConfig[j] = FALSE;
               } else
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for rach_preamblesGroupAConfig choice: ENABLE,DISABLE !\n",
                              lib_config_file_name_pP, i, rach_preamblesGroupAConfig);
 
               enb_properties.properties[enb_properties_index]->rach_preambleInitialReceivedTargetPower[j] = (rach_preambleInitialReceivedTargetPower+120)/2;
 
               if ((rach_preambleInitialReceivedTargetPower<-120) || (rach_preambleInitialReceivedTargetPower>-90) || ((rach_preambleInitialReceivedTargetPower&1)!=0))
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for rach_preambleInitialReceivedTargetPower choice: -120,-118,...,-90 !\n",
                              lib_config_file_name_pP, i, rach_preambleInitialReceivedTargetPower);
 
@@ -1456,7 +1476,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               enb_properties.properties[enb_properties_index]->rach_powerRampingStep[j] = rach_powerRampingStep/2;
 
               if ((rach_powerRampingStep<0) || (rach_powerRampingStep>6) || ((rach_powerRampingStep&1)!=0))
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for rach_powerRampingStep choice: 0,2,4,6 !\n",
                              lib_config_file_name_pP, i, rach_powerRampingStep);
 
@@ -1508,7 +1528,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
                 break;
 
               default:
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for rach_preambleTransMax choice: 3,4,5,6,7,8,10,20,50,100,200!\n",
                              lib_config_file_name_pP, i, rach_preambleTransMax);
                 break;
@@ -1517,7 +1537,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               enb_properties.properties[enb_properties_index]->rach_raResponseWindowSize[j] =  (rach_raResponseWindowSize==10)?7:rach_raResponseWindowSize-2;
 
               if ((rach_raResponseWindowSize<0)||(rach_raResponseWindowSize==9)||(rach_raResponseWindowSize>10))
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for rach_raResponseWindowSize choice: 2,3,4,5,6,7,8,10!\n",
                              lib_config_file_name_pP, i, rach_preambleTransMax);
 
@@ -1525,14 +1545,14 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               enb_properties.properties[enb_properties_index]->rach_macContentionResolutionTimer[j] = (rach_macContentionResolutionTimer/8)-1;
 
               if ((rach_macContentionResolutionTimer<8) || (rach_macContentionResolutionTimer>64) || ((rach_macContentionResolutionTimer&7)!=0))
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for rach_macContentionResolutionTimer choice: 8,16,...,56,64!\n",
                              lib_config_file_name_pP, i, rach_preambleTransMax);
 
               enb_properties.properties[enb_properties_index]->rach_maxHARQ_Msg3Tx[j] = rach_maxHARQ_Msg3Tx;
 
               if ((rach_maxHARQ_Msg3Tx<0) || (rach_maxHARQ_Msg3Tx>8))
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for rach_maxHARQ_Msg3Tx choice: 1..8!\n",
                              lib_config_file_name_pP, i, rach_preambleTransMax);
 
@@ -1555,7 +1575,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
                 break;
 
               default:
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for pcch_defaultPagingCycle choice: 32,64,128,256!\n",
                              lib_config_file_name_pP, i, pcch_defaultPagingCycle);
                 break;
@@ -1578,7 +1598,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               } else if (strcmp(pcch_nB, "oneThirtySecondT") == 0) {
                 enb_properties.properties[enb_properties_index]->pcch_nB[j] = PCCH_Config__nB_oneThirtySecondT;
               } else
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for pcch_nB choice: fourT,twoT,oneT,halfT,quarterT,oneighthT,oneSixteenthT,oneThirtySecondT !\n",
                              lib_config_file_name_pP, i, pcch_defaultPagingCycle);
 
@@ -1602,7 +1622,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
                 break;
 
               default:
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for bcch_modificationPeriodCoeff choice: 2,4,8,16",
                              lib_config_file_name_pP, i, bcch_modificationPeriodCoeff);
 
@@ -1644,7 +1664,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
                 break;
 
               default:
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for ue_TimersAndConstants_t300 choice: 100,200,300,400,600,1000,1500,2000 ",
                              lib_config_file_name_pP, i, ue_TimersAndConstants_t300);
                 break;
@@ -1685,7 +1705,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
                 break;
 
               default:
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for ue_TimersAndConstants_t301 choice: 100,200,300,400,600,1000,1500,2000 ",
                              lib_config_file_name_pP, i, ue_TimersAndConstants_t301);
                 break;
@@ -1722,7 +1742,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
                 break;
 
               default:
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for ue_TimersAndConstants_t310 choice: 0,50,100,200,500,1000,1500,2000 ",
                              lib_config_file_name_pP, i, ue_TimersAndConstants_t310);
                 break;
@@ -1759,7 +1779,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
                 break;
 
               default:
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for ue_TimersAndConstants_t311 choice: 1000,3000,5000,10000,150000,20000,30000",
                              lib_config_file_name_pP, i, ue_TimersAndConstants_t311);
                 break;
@@ -1800,7 +1820,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
                 break;
 
               default:
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for ue_TimersAndConstants_n310 choice: 1,2,3,4,6,6,8,10,20",
                              lib_config_file_name_pP, i, ue_TimersAndConstants_n311);
                 break;
@@ -1841,7 +1861,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
                 break;
 
               default:
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for ue_TimersAndConstants_t311 choice: 1,2,3,4,5,6,8,10",
                              lib_config_file_name_pP, i, ue_TimersAndConstants_t311);
                 break;
@@ -1871,7 +1891,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
 		enb_properties.properties[enb_properties_index]->ue_TransmissionMode[j] = AntennaInfoDedicated__transmissionMode_tm7;
 		break;
 	      default:
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%d\" for ue_TransmissionMode choice: 1,2,3,4,5,6,7",
                              lib_config_file_name_pP, i, ue_TransmissionMode);
 		break;
@@ -1888,7 +1908,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
                   && config_setting_lookup_int(setting_srb1, ENB_CONFIG_STRING_SRB1_MAX_RETX_THRESHOLD,    &srb1_max_retx_threshold)
                   && config_setting_lookup_int(setting_srb1, ENB_CONFIG_STRING_SRB1_POLL_PDU,              &srb1_poll_pdu)
                   && config_setting_lookup_int(setting_srb1, ENB_CONFIG_STRING_SRB1_POLL_BYTE,             &srb1_poll_byte)))
-              AssertError (0, parse_errors ++,
+              AssertFatal (0,
                            "Failed to parse eNB configuration file %s, enb %d  timer_poll_retransmit, timer_reordering, "
                            "timer_status_prohibit, poll_pdu, poll_byte, max_retx_threshold !\n",
                            lib_config_file_name_pP, i);
@@ -1927,7 +1947,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               break;
 
             default:
-              AssertError (0, parse_errors ++,
+              AssertFatal (0,
                            "Bad config value when parsing eNB configuration file %s, enb %d  srb1_max_retx_threshold %u!\n",
                            lib_config_file_name_pP, i, srb1_max_retx_threshold);
             }
@@ -1965,7 +1985,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               if (srb1_poll_pdu >= 10000)
                 enb_properties.properties[enb_properties_index]->srb1_poll_pdu = PollPDU_pInfinity;
               else
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Bad config value when parsing eNB configuration file %s, enb %d  srb1_poll_pdu %u!\n",
                              lib_config_file_name_pP, i, srb1_poll_pdu);
             }
@@ -2033,7 +2053,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               if (srb1_poll_byte >= 10000)
                 enb_properties.properties[enb_properties_index]->srb1_poll_byte = PollByte_kBinfinity;
               else
-                AssertError (0, parse_errors ++,
+                AssertFatal (0,
                              "Bad config value when parsing eNB configuration file %s, enb %d  srb1_poll_byte %u!\n",
                              lib_config_file_name_pP, i, srb1_poll_byte);
             }
@@ -2043,7 +2063,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
             } else if (srb1_timer_poll_retransmit <= 500) {
               enb_properties.properties[enb_properties_index]->srb1_timer_poll_retransmit = (srb1_timer_poll_retransmit - 300)/50 + 50;
             } else {
-              AssertError (0, parse_errors ++,
+              AssertFatal (0,
                            "Bad config value when parsing eNB configuration file %s, enb %d  srb1_timer_poll_retransmit %u!\n",
                            lib_config_file_name_pP, i, srb1_timer_poll_retransmit);
             }
@@ -2053,7 +2073,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
             } else if ((srb1_timer_poll_retransmit >= 300) && (srb1_timer_poll_retransmit <= 500)) {
               enb_properties.properties[enb_properties_index]->srb1_timer_status_prohibit = (srb1_timer_status_prohibit - 300)/50 + 51;
             } else {
-              AssertError (0, parse_errors ++,
+              AssertFatal (0,
                            "Bad config value when parsing eNB configuration file %s, enb %d  srb1_timer_status_prohibit %u!\n",
                            lib_config_file_name_pP, i, srb1_timer_status_prohibit);
             }
@@ -2184,7 +2204,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
               break;
 
             default:
-              AssertError (0, parse_errors ++,
+              AssertFatal (0,
                            "Bad config value when parsing eNB configuration file %s, enb %d  srb1_timer_reordering %u!\n",
                            lib_config_file_name_pP, i, srb1_timer_reordering);
             }
@@ -2211,7 +2231,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
                    && config_setting_lookup_string(setting_mme_address, ENB_CONFIG_STRING_MME_IP_ADDRESS_PREFERENCE, (const char **)&preference)
                  )
               ) {
-              AssertError (0, parse_errors ++,
+              AssertFatal (0,
                            "Failed to parse eNB configuration file %s, %u th enb %u th mme address !\n",
                            lib_config_file_name_pP, i, j);
               continue; // FIXME will prevent segfaults below, not sure what happens at function exit...
@@ -2261,7 +2281,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
 		   && config_setting_lookup_int(setting_rrh_gw, ENB_CONFIG_STRING_RRH_GW_TX_SCHEDULING_ADVANCE, &tx_scheduling_advance)
                  )
               ) {
-              AssertError (0, parse_errors ++,
+              AssertFatal (0,
                            "Failed to parse eNB configuration file %s, %u th enb %u the RRH GW address !\n",
                            lib_config_file_name_pP, i, j);
               continue; // FIXME will prevent segfaults below, not sure what happens at function exit...
@@ -2664,13 +2684,10 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
 
   enb_properties.number = num_enb_properties;
 
-  AssertError (enb_properties_index == num_enb_properties, parse_errors ++,
+  AssertFatal (enb_properties_index == num_enb_properties,
                "Failed to parse eNB configuration file %s, mismatch between %u active eNBs and %u corresponding defined eNBs !\n",
                lib_config_file_name_pP, num_enb_properties, enb_properties_index);
 
-  AssertFatal (parse_errors == 0,
-               "Failed to parse eNB configuration file %s, found %d error%s !\n",
-               lib_config_file_name_pP, parse_errors, parse_errors > 1 ? "s" : "");
   enb_config_display();
   return &enb_properties;
 

openair2/LAYER2/MAC/eNB_scheduler_primitives.c

@@ -75,7 +75,7 @@ void init_ue_sched_info(void)
   module_id_t i,j,k;
 
   for (i=0; i<NUMBER_OF_eNB_MAX; i++) {
-    for (k=0; i<MAX_NUM_CCs; i++) {
+    for (k=0; k<MAX_NUM_CCs; k++) {
       for (j=0; j<NUMBER_OF_UE_MAX; j++) {
         // init DL
         eNB_dlsch_info[i][k][j].weight           = 0;