Merge remote-tracking branch 'origin/develop' into NR_RRC_PDCP

Conflicts: openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_phytest.c
2020-07-15 12:06:41 +02:00
parent 4761cbdc3d 2bf5758418
commit 0b8d5a8fd2
72 changed files with 42185 additions and 292 deletions
@@ -2,13 +2,12 @@

 We want to make contributing to this project as easy and transparent as possible.

-Please refer to the steps described on our website: [How to contribute to OAI](https://www.openairinterface.org/?page_id=112)
-
 1. Sign and return a Contributor License Agreement to OAI team.
-2. Create an account on [Eurecom GitLab Server](https://gitlab.eurecom.fr).
-3. Provide the identifiant of this account to the OAI team (mailto:contact@openairinterface.org) so you have developer rights on this repository.
+2. We recommend that you provide us with a professional or student email address 
+2. Register on [Eurecom GitLab Server](https://gitlab.eurecom.fr/users/sign_in)
+3. Provide the OAI team with the **username** of this account to (mailto:contact@openairinterface.org) ; we will give you the developer rights on this repository.
 4. The policies are described in these wiki pages: [OAI Policies](https://gitlab.eurecom.fr/oai/openairinterface5g/wikis/oai-policies-home)
-   -  PLEASE DO NOT FORK the OAI repository on your own Eurecom GitLab account. It just eats up space on our servers.
+   - PLEASE DO NOT FORK the OAI repository on your own Eurecom GitLab account. It just eats up space on our servers.
   - You can fork onto another hosting system. But we will NOT accept a merge request from a forked repository.
      * This decision was made for the license reasons.
      * The Continuous Integration will reject your merge request.
@@ -1,3 +1,4 @@
+r*.raw
 enb_*.log
 ue_*.log
 ping_*.*
@@ -349,7 +349,7 @@ class OaiCiTest():
 				SSH.command('echo ' + self.UEPassword + ' | sudo -S ../../../targets/bin/conf2uedata -c ../../../openair3/NAS/TOOLS/ci-ue_eurecom_test_sfr.conf -o .', '\$', 5)
 		else:
 			SSH.command('if [ -e rbconfig.raw ]; then echo ' + self.UEPassword + ' | sudo -S rm rbconfig.raw; fi', '\$', 5)
-			SSH.command('if [ -e rbconfig.raw ]; then echo ' + self.UEPassword + ' | sudo -S rm reconfig.raw; fi', '\$', 5)
+			SSH.command('if [ -e reconfig.raw ]; then echo ' + self.UEPassword + ' | sudo -S rm reconfig.raw; fi', '\$', 5)
 			# Copy the RAW files from gNB running directory (maybe on another machine)
 			copyin_res = SSH.copyin(RAN.GeteNBIPAddress(), RAN.GeteNBUserName(), RAN.GeteNBPassword(), RAN.GeteNBSourceCodePath() + '/cmake_targets/rbconfig.raw', '.')
 			if (copyin_res == 0):
@@ -2560,14 +2560,14 @@ class OaiCiTest():
 					logging.debug('\033[94m' + mibMsg + '\033[0m')
 				except Exception as e:
 					logging.error('\033[91m' + "SIB5 InterFreqCarrierFreq element not found" + '\033[0m')
-			result = re.search("DL Carrier Frequency/ARFCN : (?P<carrier_frequency>\d{1,15}/\d{1,4})", str(line))
+			result = re.search("DL Carrier Frequency/ARFCN : \-*(?P<carrier_frequency>\d{1,15}/\d{1,4})", str(line))
 			if result is not None:
 				try:
 					freq = result.group('carrier_frequency')
 					new_freq = re.sub('/[0-9]+','',freq)
 					float_freq = float(new_freq) / 1000000
-					HTMLSethtmlUEFailureMsg(HTMLGethtmlUEFailureMsg() + 'DL Freq: ' + ('%.1f' % float_freq) + ' MHz')
-					logging.debug('\033[94m' + "    DL Carrier Frequency is: " + freq + '\033[0m')
+					HTML.SethtmlUEFailureMsg(HTML.GethtmlUEFailureMsg() + 'DL Freq: ' + ('%.1f' % float_freq) + ' MHz')
+					logging.debug('\033[94m' + "    DL Carrier Frequency is: " + str(freq) + '\033[0m')
 				except Exception as e:
 					logging.error('\033[91m' + "    DL Carrier Frequency not found" + '\033[0m')
 			result = re.search("AllowedMeasBandwidth : (?P<allowed_bandwidth>\d{1,7})", str(line))
@@ -548,7 +548,7 @@ class RANManagement():
 		mySSH.command('cd cmake_targets', '\$', 5)
 		if self.air_interface == 'nr':
 			mySSH.command('if [ -e rbconfig.raw ]; then echo ' + lPassWord + ' | sudo -S rm rbconfig.raw; fi', '\$', 5)
-			mySSH.command('if [ -e rbconfig.raw ]; then echo ' + lPassWord + ' | sudo -S rm reconfig.raw; fi', '\$', 5)
+			mySSH.command('if [ -e reconfig.raw ]; then echo ' + lPassWord + ' | sudo -S rm reconfig.raw; fi', '\$', 5)
 		mySSH.command('echo "ulimit -c unlimited && ./ran_build/build/' + self.air_interface + '-softmodem -O ' + lSourcePath + '/' + ci_full_config_file + extra_options + '" > ./my-lte-softmodem-run' + str(self.eNB_instance) + '.sh', '\$', 5)
 		mySSH.command('chmod 775 ./my-lte-softmodem-run' + str(self.eNB_instance) + '.sh', '\$', 5)
 		mySSH.command('echo ' + lPassWord + ' | sudo -S rm -Rf enb_' + self.testCase_id + '.log', '\$', 5)
@@ -811,6 +811,7 @@ class RANManagement():
 		uplinkSegmentsAborted = 0
 		ulschReceiveOK = 0
 		gnbRxTxWakeUpFailure = 0
+		gnbTxWriteThreadEnabled = False
 		cdrxActivationMessageCount = 0
 		dropNotEnoughRBs = 0
 		mbmsRequestMsg = 0
@@ -924,6 +925,9 @@ class RANManagement():
 			result = re.search('could not wakeup gNB rxtx process', str(line))
 			if result is not None:
 				gnbRxTxWakeUpFailure += 1
+			result = re.search('tx write thread ready', str(line))
+			if result is not None:
+				gnbTxWriteThreadEnabled = True
 			result = re.search('ULSCH in error in round|ULSCH 0 in error', str(line))
 			if result is not None:
 				ulschFailure += 1
@@ -964,6 +968,10 @@ class RANManagement():
 				statMsg = nodeB_prefix + 'NB showed ' + str(gnbRxTxWakeUpFailure) + ' "could not wakeup gNB rxtx process" message(s)'
 				logging.debug('\u001B[1;30;43m ' + statMsg + ' \u001B[0m')
 				htmleNBFailureMsg += statMsg + '\n'
+			if gnbTxWriteThreadEnabled:
+				statMsg = nodeB_prefix + 'NB ran with TX Write thread enabled'
+				logging.debug('\u001B[1;30;43m ' + statMsg + ' \u001B[0m')
+				htmleNBFailureMsg += statMsg + '\n'
 		if uciStatMsgCount > 0:
 			statMsg = nodeB_prefix + 'NB showed ' + str(uciStatMsgCount) + ' "uci->stat" message(s)'
 			logging.debug('\u001B[1;30;43m ' + statMsg + ' \u001B[0m')
@@ -25,23 +25,10 @@
 	<htmlTabName>EPC-Start</htmlTabName>
 	<htmlTabIcon>log-in</htmlTabIcon>
 	<TestCaseRequestedList>
- 010101 090101
 050101 060101 070101
 	</TestCaseRequestedList>
 	<TestCaseExclusionList></TestCaseExclusionList>

-        <testCase id="010101">
-                <class>Build_eNB</class>
-                <desc>Build eNB (USRP)</desc>
-                <Build_eNB_args>-w USRP -c --eNB</Build_eNB_args>
-        </testCase>
-
-        <testCase id="090101">
-                <class>Build_OAI_UE</class>
-                <desc>Build OAI UE</desc>
-                <Build_OAI_UE_args>-w USRP --UE</Build_OAI_UE_args>
-        </testCase>
-
 	<testCase id="050101">
 		<class>Initialize_HSS</class>
 		<desc>Initialize HSS</desc>
@@ -0,0 +1,71 @@
+<!--
+
+ Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ contributor license agreements.  See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The OpenAirInterface Software Alliance licenses this file to You under
+ the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ except in compliance with the License.
+ You may obtain a copy of the License at
+
+      http://www.openairinterface.org/?page_id=698
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+ For more information about the OpenAirInterface (OAI) Software Alliance:
+      contact@openairinterface.org
+
+-->
+<testCaseList>
+        <htmlTabRef>run-oai-gnb-nr-ue-tx-write-thread</htmlTabRef>
+        <htmlTabName>Run-gNB-and-NR-UE-TX-Write-Thread</htmlTabName>
+        <htmlTabIcon>tasks</htmlTabIcon>	
+	<repeatCount>2</repeatCount>
+	<TestCaseRequestedList>
+090103 000001 090104 000002 090108 090109
+	</TestCaseRequestedList>
+	<TestCaseExclusionList></TestCaseExclusionList>
+	
+        <testCase id="090103">
+                <class>Initialize_eNB</class>
+                <desc>Initialize gNB USRP (Tx-Write-Threading enabled)</desc>
+		<Initialize_eNB_args>-O ci-scripts/conf_files/gnb.band78.tm1.106PRB.usrpn300.conf --phy-test --usrp-tx-thread-config 1</Initialize_eNB_args>
+		<air_interface>NR</air_interface>
+        </testCase>
+
+	<testCase id="000001">
+		<class>IdleSleep</class>
+		<desc>Sleep</desc>
+		<idle_sleep_time_in_sec>5</idle_sleep_time_in_sec>
+	</testCase>
+
+	<testCase id="000002">
+		<class>IdleSleep</class>
+		<desc>Waiting for NR UE to synchronize w/ gNB</desc>
+		<idle_sleep_time_in_sec>180</idle_sleep_time_in_sec>
+	</testCase>
+
+        <testCase id="090104">
+                <class>Initialize_OAI_UE</class>
+                <desc>Initialize NR UE USRP</desc>
+		<Initialize_OAI_UE_args>--phy-test --usrp-args "addr=192.168.30.2,second_addr=192.168.50.2,clock_source=external,time_source=external" --threadoffset 16 --rrc_config_path .</Initialize_OAI_UE_args>
+		<air_interface>NR</air_interface>
+        </testCase>
+
+        <testCase id="090108">
+                <class>Terminate_OAI_UE</class>
+                <desc>Terminate NR UE</desc>
+		<air_interface>NR</air_interface>
+        </testCase>
+
+        <testCase id="090109">
+                <class>Terminate_eNB</class>
+                <desc>Terminate gNB</desc>
+		<air_interface>NR</air_interface>
+        </testCase>
+
+</testCaseList>
@@ -24,6 +24,7 @@
 	<htmlTabRef>gnb-build-tab</htmlTabRef>
 	<htmlTabName>Build-gNB</htmlTabName>
 	<htmlTabIcon>wrench</htmlTabIcon>
+	<repeatCount>4</repeatCount>
 	<TestCaseRequestedList>
 010101
 	</TestCaseRequestedList>
@@ -24,6 +24,7 @@
 	<htmlTabRef>nr-ue-build-tab</htmlTabRef>
 	<htmlTabName>Build-NR-UE</htmlTabName>
 	<htmlTabIcon>wrench</htmlTabIcon>
+	<repeatCount>2</repeatCount>
 	<TestCaseRequestedList>
 010102
 	</TestCaseRequestedList>
@@ -3118,7 +3118,7 @@ if (${T_TRACER})
        NFAPI_COMMON_LIB NFAPI_LIB NFAPI_PNF_LIB NFAPI_VNF_LIB NFAPI_USER_LIB
        PHY_COMMON PHY PHY_UE PHY_NR PHY_NR_COMMON PHY_NR_UE PHY_RU PHY_MEX
        L2 L2_LTE L2_NR L2_UE NR_L2_UE MAC_NR_COMMON MAC_NR MAC_UE_NR
-        CN_UTILS GTPV1U SCTP_CLIENT MME_APP UDP LIB_NAS_UE NB_IoT LFDS LFDS7 SIMU_COMMON SIMU SIMU_ETH OPENAIR0_LIB
+        CN_UTILS GTPV1U NR_GTPV1U SCTP_CLIENT MME_APP UDP LIB_NAS_UE NB_IoT LFDS LFDS7 SIMU_COMMON SIMU SIMU_ETH OPENAIR0_LIB
        ldpc_orig ldpc_optim ldpc_optim8seg ldpc PROTO_AGENT dfts)
    if (TARGET ${i})
      add_dependencies(${i} generate_T)
@@ -1071,9 +1071,9 @@
      <main_exec> $OPENAIR_DIR/targets/bin/nr_pbchsim.Rel15</main_exec>
      <main_exec_args>-s0 -S1 -n1000 -R106
                      -s0 -S1 -n10 -I -R106
-		              -s0 -S1 -n1000 -R217
+		      -s0 -S1 -n1000 -R217
                      -s0 -S1 -n10 -I -R217
-		              -s0 -S1 -n1000 -R273
+		      -s0 -S1 -n1000 -R273
                      -s0 -S1 -n10 -I -R273</main_exec_args>
      <tags>nr_pbchsim.test1 nr_pbchsim.test2 nr_pbchsim.test3 nr_pbchsim.test4 nr_pbchsim.test5 nr_pbchsim.test6</tags>
      <search_expr_true>PBCH test OK</search_expr_true>
@@ -1114,8 +1114,7 @@
                  -n100 -e16 -s10 
                  -n100 -s1 -t25
                  -n100 -s1 -t33
-                  -n100 -s1 -t50
-      </main_exec_args>
+                  -n100 -s1 -t50</main_exec_args>
      <tags>nr_dlsim.test1 nr_dlsim.test2 nr_dlsim.test3 nr_dlsim.test4 nr_dlsim.test5 nr_dlsim.test6 nr_dlsim.test7 nr_dlsim.test8 nr_dlsim.test9 nr_dlsim.test10 nr_dlsim.test11 nr_dlsim.test12 nr_dlsim.test13</tags>
      <search_expr_true>PDSCH test OK</search_expr_true>
      <search_expr_false>segmentation fault|assertion|exiting|fatal</search_expr_false>
@@ -1224,7 +1223,6 @@
 		      -R 106 -i 1 -P 2 -b 11 -s6 -n1000
 		      -R 106 -i 1 -P 2 -q8 -b 12 -s-3 -n1000
 		      -R 106 -i 1 -P 2 -q8 -b 19 -s-3 -n1000
-		      -R 106 -i 1 -P 2 -q8 -b 19 -s-3 -n1000
 		      -R 106 -i 1 -P 2 -q8 -b 32 -s-3 -n1000
 		      -R 106 -i 1 -P 2 -q16 -b 32 -s-3 -n1000
 		      -R 106 -i 1 -P 2 -q16 -b 64 -s-3 -n1000</main_exec_args>
@@ -1298,19 +1296,21 @@

    <testCase id="015112">
      <class>execution</class>
-      <desc>nr_prachsim Test cases. (Test1: 106 PRBs),
-                                    (Test2: 217 PRBs),
-                                    (Test3: 273 PRBs)</desc>
+      <desc>nr_prachsim Test cases. (Test1: 106 PRBs - Prach format A2),
+                                    (Test2: 217 PRBs - Prach format A2),
+                                    (Test3: 273 PRBs - Prach format A2),
+				    (Test4: 106 PRBs - Prach format 0)</desc>
      <pre_compile_prog></pre_compile_prog>
      <compile_prog>$OPENAIR_DIR/cmake_targets/build_oai</compile_prog>
      <compile_prog_args> --phy_simulators -c </compile_prog_args>
      <pre_exec>$OPENAIR_DIR/cmake_targets/autotests/tools/free_mem.bash</pre_exec>
      <pre_exec_args></pre_exec_args>
      <main_exec> $OPENAIR_DIR/targets/bin/nr_prachsim.Rel15</main_exec>
-      <main_exec_args>-a -s -30 -n 100 -p 16 -R 106
-                      -a -s -30 -n 100 -p 16 -R 217
-                      -a -s -30 -n 100 -p 16 -R 273</main_exec_args>
-      <tags>nr_prachsim.test1 nr_prachsim.test2 nr_prachsim.test3</tags>
+      <main_exec_args>-a -s -30 -n 100 -p 63 -R 106
+                      -a -s -30 -n 100 -p 63 -R 217
+                      -a -s -30 -n 100 -p 63 -R 273
+		      -a -s -30 -n 100 -p 63 -R 106 -c 4</main_exec_args>
+      <tags>nr_prachsim.test1 nr_prachsim.test2 nr_prachsim.test3 nr_prachsim.test4</tags>
      <search_expr_true>PRACH test OK</search_expr_true>
      <search_expr_false>segmentation fault|assertion|exiting|fatal</search_expr_false>
      <nruns>3</nruns>
@@ -518,7 +518,29 @@ const char* eurecomFunctionsNames[] = {
  "wakeup_txfh",
  "gNB_thread_rxtx0",
  "gNB_thread_rxtx1",
-  "ru_thread_tx_wait"
+  "ru_thread_tx_wait",
+  "gNB_ulsch_decoding",
+  "gNB_pdsch_codeword_scrambling",
+  "gNB_dlsch_encoding",
+  "gNB_pdsch_modulation",
+  "gNB_pdcch_tx",
+  "phy_procedures_gNB_tx",
+  "phy_procedures_gNB_common_tx",
+  "phy_procedures_gNB_uespec_rx",
+  "nr_rx_pusch",
+  "nr_ulsch_procedures_rx",
+  "macxface_gNB_dlsch_ulsch_scheduler",
+
+  /*NR ue-softmodem signal*/
+  "nr_ue_ulsch_encoding",
+  "nr_segmentation",
+  "ldpc_encoder_optim",
+  "nr_rate_matching_ldpc",
+  "nr_interleaving_ldpc",
+  "pss_synchro_nr",
+  "pss_search_time_nr",
+  "nr_initial_ue_sync",
+  "beam_switching_gpio"
 };

 struct vcd_module_s vcd_modules[] = {
@@ -511,6 +511,29 @@ typedef enum {
  VCD_SIGNAL_DUMPER_FUNCTIONS_gNB_PROC_RXTX0,
  VCD_SIGNAL_DUMPER_FUNCTIONS_gNB_PROC_RXTX1,
  VCD_SIGNAL_DUMPER_FUNCTIONS_RU_TX_WAIT,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_gNB_ULSCH_DECODING,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_gNB_PDSCH_CODEWORD_SCRAMBLING,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_gNB_DLSCH_ENCODING,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_gNB_PDSCH_MODULATION,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_gNB_PDCCH_TX,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_gNB_TX,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_gNB_COMMON_TX,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_gNB_UESPEC_RX,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_NR_RX_PUSCH,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_NR_ULSCH_PROCEDURES_RX,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_gNB_DLSCH_ULSCH_SCHEDULER,
+
+/* NR ue-softmodem signal*/
+  VCD_SIGNAL_DUMPER_FUNCTIONS_NR_UE_ULSCH_ENCODING,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_NR_SEGMENTATION,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_LDPC_ENCODER_OPTIM,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_NR_RATE_MATCHING_LDPC,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_NR_INTERLEAVING_LDPC,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PSS_SYNCHRO_NR,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PSS_SEARCH_TIME_NR,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_NR_INITIAL_UE_SYNC,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_BEAM_SWITCHING_GPIO,
+

  VCD_SIGNAL_DUMPER_FUNCTIONS_END
 } vcd_signal_dump_functions;
@@ -73,7 +73,7 @@ typedef struct {
 } T_cache_t;

 /* number of VCD functions (to be kept up to date! see in T_messages.txt) */
-#define VCD_NUM_FUNCTIONS (249)
+#define VCD_NUM_FUNCTIONS (269)

 /* number of VCD variables (to be kept up to date! see in T_messages.txt) */
 #define VCD_NUM_VARIABLES (187)
@@ -3393,3 +3393,106 @@ ID = VCD_FUNCTION_RU_TX_WAIT
    GROUP = ALL:VCD:ENB:VCD_FUNCTION
    FORMAT = int,value
    VCD_NAME = ru_thread_tx_wait
+ID = VCD_FUNCTION_PHY_gNB_ULSCH_DECODING
+    DESC = VCD function PHY_gNB_ULSCH_DECODING
+    GROUP = ALL:VCD:ENB:VCD_FUNCTION
+    FORMAT = int,value
+    VCD_NAME = gNB_ulsch_decoding
+ID = VCD_FUNCTION_gNB_PDSCH_CODEWORD_SCRAMBLING
+    DESC = VCD function gNB_PDSCH_CODEWORD_SCRAMBLING
+    GROUP = ALL:VCD:ENB:VCD_FUNCTION
+    FORMAT = int,value
+    VCD_NAME = gNB_pdsch_codeword_scrambling
+ID = VCD_FUNCTION_gNB_DLSCH_ENCODING
+    DESC = VCD function gNB_DLSCH_ENCODING
+    GROUP = ALL:VCD:ENB:VCD_FUNCTION
+    FORMAT = int,value
+    VCD_NAME = gNB_dlsch_encoding
+ID = VCD_FUNCTION_gNB_PDSCH_MODULATION
+    DESC = VCD function gNB_PDSCH_MODULATION
+    GROUP = ALL:VCD:ENB:VCD_FUNCTION
+    FORMAT = int,value
+    VCD_NAME = gNB_pdsch_modulation
+ID = VCD_FUNCTION_PHY_gNB_PDCCH_TX
+    DESC = VCD function PHY_gNB_PDCCH_TX
+    GROUP = ALL:VCD:ENB:VCD_FUNCTION
+    FORMAT = int,value
+    VCD_NAME = gNB_pdcch_tx
+ID = VCD_FUNCTION_PHY_PROCEDURES_gNB_TX
+    DESC = VCD function PHY_PROCEDURES_gNB_TX
+    GROUP = ALL:VCD:ENB:VCD_FUNCTION
+    FORMAT = int,value
+    VCD_NAME = phy_procedures_gNB_tx
+ID = VCD_FUNCTION_PHY_PROCEDURES_gNB_COMMON_TX
+    DESC = VCD function PHY_PROCEDURES_gNB_COMMON_TX
+    GROUP = ALL:VCD:ENB:VCD_FUNCTION
+    FORMAT = int,value
+    VCD_NAME = phy_procedures_gNB_common_tx
+ID = VCD_FUNCTION_PHY_PROCEDURES_gNB_UESPEC_RX
+    DESC = VCD function PHY_PROCEDURES_gNB_UESPEC_RX
+    GROUP = ALL:VCD:ENB:VCD_FUNCTION
+    FORMAT = int,value
+    VCD_NAME = phy_procedures_gNB_uespec_rx
+ID = VCD_FUNCTION_NR_RX_PUSCH
+    DESC = VCD function NR_RX_PUSCH
+    GROUP = ALL:VCD:ENB:VCD_FUNCTION
+    FORMAT = int,value
+    VCD_NAME = nr_rx_pusch
+ID = VCD_FUNCTION_NR_ULSCH_PROCEDURES_RX
+    DESC = VCD function NR_ULSCH_PROCEDURES_RX
+    GROUP = ALL:VCD:ENB:VCD_FUNCTION
+    FORMAT = int,value
+    VCD_NAME = nr_ulsch_procedures_rx
+ID = VCD_FUNCTION_gNB_DLSCH_ULSCH_SCHEDULER
+    DESC = VCD function gNB_DLSCH_ULSCH_SCHEDULER
+    GROUP = ALL:VCD:ENB:VCD_FUNCTION
+    FORMAT = int,value
+    VCD_NAME = macxface_gNB_dlsch_ulsch_scheduler
+
+  #function for nrUE
+ID = VCD_FUNCTION_NR_UE_ULSCH_ENCODING
+    DESC = VCD function NR_UE_ULSCH_ENCODING
+    GROUP = ALL:VCD:UE:VCD_FUNCTION
+    FORMAT = int,value
+    VCD_NAME = nr_ue_ulsch_encoding
+ID = VCD_FUNCTION_NR_SEGMENTATION
+    DESC = VCD function NR_SEGMENTATION
+    GROUP = ALL:VCD:UE:VCD_FUNCTION
+    FORMAT = int,value
+    VCD_NAME = nr_segmentation
+ID = VCD_FUNCTION_LDPC_ENCODER_OPTIM
+    DESC = VCD function LDPC_ENCODER_OPTIM
+    GROUP = ALL:VCD:UE:VCD_FUNCTION
+    FORMAT = int,value
+    VCD_NAME = ldpc_encoder_optim
+ID = VCD_FUNCTION_NR_RATE_MATCHING_LDPC
+    DESC = VCD function NR_RATE_MATCHING_LDPC
+    GROUP = ALL:VCD:UE:VCD_FUNCTION
+    FORMAT = int,value
+    VCD_NAME = nr_rate_matching_ldpc
+ID = VCD_FUNCTION_NR_INTERLEAVING_LDPC
+    DESC = VCD function NR_INTERLEAVING_LDPC
+    GROUP = ALL:VCD:UE:VCD_FUNCTION
+    FORMAT = int,value
+    VCD_NAME = nr_interleaving_ldpc
+ID = VCD_FUNCTION_PSS_SYNCHRO_NR
+    DESC = VCD function PSS_SYNCHRO_NR
+    GROUP = ALL:VCD:UE:VCD_FUNCTION
+    FORMAT = int,value
+    VCD_NAME = pss_synchro_nr
+ID = VCD_FUNCTION_PSS_SEARCH_TIME_NR
+    DESC = VCD function PSS_SEARCH_TIME_NR
+    GROUP = ALL:VCD:UE:VCD_FUNCTION
+    FORMAT = int,value
+    VCD_NAME = pss_search_time_nr
+ID = VCD_FUNCTION_NR_INITIAL_UE_SYNC
+    DESC = VCD function NR_INITIAL_UE_SYNC
+    GROUP = ALL:VCD:UE:VCD_FUNCTION
+    FORMAT = int,value
+    VCD_NAME = nr_initial_ue_sync
+ID = VCD_FUNCTION_BEAM_SWITCHING_GPIO
+    DESC = VCD function BEAM_SWITCHING_GPIO
+    GROUP = ALL:VCD:ENB:VCD_FUNCTION
+    FORMAT = int,value
+    VCD_NAME = beam_switching_gpio
+
@@ -91,8 +91,16 @@ task_list_t tasks[TASK_MAX];
    return (EXIT_SUCCESS);
  }

+  // in the two following functions, the +32 in malloc is there to deal with gcc memory alignment
+  // because a struct size can be larger than sum(sizeof(struct components))
+  // We should remove the itti principle of a huge union for all types of messages in paramter "msg_t ittiMsg"
+  // to use a more C classical pointer casting "void * ittiMsg", later casted in the right struct
+  // but we would have to change all legacy macros, as per this example
+  // #define S1AP_REGISTER_ENB_REQ(mSGpTR)           (mSGpTR)->ittiMsg.s1ap_register_enb_req
+  // would become
+  // #define S1AP_REGISTER_ENB_REQ(mSGpTR)           (s1ap_register_enb_req) mSGpTR)->ittiMsg
  MessageDef *itti_alloc_new_message_sized(task_id_t origin_task_id, MessagesIds message_id, MessageHeaderSize size) {
-    MessageDef *temp = (MessageDef *)itti_malloc (origin_task_id, TASK_UNKNOWN, sizeof(MessageHeader) + size);
+    MessageDef *temp = (MessageDef *)itti_malloc (origin_task_id, TASK_UNKNOWN, sizeof(MessageHeader) +32 + size);
    temp->ittiMsgHeader.messageId = message_id;
    temp->ittiMsgHeader.originTaskId = origin_task_id;
    temp->ittiMsgHeader.ittiMsgSize = size;
@@ -100,7 +108,7 @@ task_list_t tasks[TASK_MAX];
  }

  MessageDef *itti_alloc_new_message(task_id_t origin_task_id, MessagesIds message_id) {
-    int size=sizeof(MessageHeader) + messages_info[message_id].size;
+    int size=sizeof(MessageHeader) + 32 + messages_info[message_id].size;
    MessageDef *temp = (MessageDef *)itti_malloc (origin_task_id, TASK_UNKNOWN, size);
    temp->ittiMsgHeader.messageId = message_id;
    temp->ittiMsgHeader.originTaskId = origin_task_id;
@@ -415,7 +415,7 @@ static const message_info_t messages_info[] = {
 #undef MESSAGE_DEF
 };

-typedef struct __attribute__ ((__packed__)) MessageDef_s {
+typedef struct MessageDef_s {
  MessageHeader ittiMsgHeader; /**< Message header */
  msg_t         ittiMsg;
 } MessageDef;
@@ -16,7 +16,6 @@ This page is valid on tags starting from **`2019.w09`**.

 # Soft Modem Build Script

-oai EPC is developed in a distinct project with it's own [documentation](https://github.com/OPENAIRINTERFACE/openair-cn/wiki) , it is not described here.

 OAI softmodem sources, which aim to implement 3GPP compliant UEs, eNodeB and gNodeB can be downloaded from the Eurecom [gitlab repository](./GET_SOURCES.md).

@@ -0,0 +1,394 @@
+STATUS 2020/06/26 : information is up to date, but under continuous improvement
+
+## Table of Contents ##
+
+1.   [Configuration Overview](#configuration-overview)
+2.   [SW Repository / Branch](#repository)
+3.   [Architecture Setup](#architecture-setup)
+4.   [Build / Install](#build-and-install)
+5.   [Run / Test](#run-and-test)
+6.   [Test case](#test-case)
+7.   [Log file monitoring](#log-file-monitoring)
+6.   [Required tools for debug](#required-tools-for-debug)
+7.   [Status of interoperability](#status-of-interoperability) 
+
+## Configuration Overview
+
+* Non Standalone (NSA) configuration  : initial Control Plane established between UE and RAN eNB, then User Plane established between UE and gNB, Core network is 4G based supporting rel 15
+
+* Commercial UE: Oppo Reno 5G
+* OAI Software Defined gNB and eNB
+* eNB RF front end: USRP (ETTUS) B200 Mini or B210
+* gNB RF front end: USRP (ETTUS) B200 Mini or B210 (N310 will be needed for MIMO and wider BW's)
+* 5G TDD duplexing mode
+* 5G FR1 Band n78 (3.5 GHz)
+* BW: 40MHz
+* Antenna scheme: SISO
+
+## Repository
+
+https://gitlab.eurecom.fr/oai/openairinterface5g/tree/develop
+
+## Architecture Setup
+
+The scheme below depicts our typical setup:
+
+![image info](./testing_gnb_w_cots_ue_resources/oai_fr1_setup.jpg)
+
+The photo depicts the FR1 setup part of the scheme above:  
+
+
+![image info](./testing_gnb_w_cots_ue_resources/oai_fr1_lab.jpg)
+
+## Build and Install
+
+General guidelines to build eNB and gNB :
+See https://gitlab.eurecom.fr/oai/openairinterface5g/blob/develop/doc/BUILD.md#building-ues-enodeb-and-gnodeb-executables
+
+
+- **eNB**
+
+```
+cd <your oai installation directory>/openairinterface5g/
+source oaienv
+cd cmake_targets/
+./build_oai -I -w USRP --eNB
+
+```
+
+- **gNB**
+
+```
+cd <your oai installation directory>/openairinterface5g/
+source oaienv
+cd cmake_targets/
+./build_oai -I -w USRP --gNB
+```
+
+
+- **EPC**
+
+for reference:
+https://github.com/OPENAIRINTERFACE/openair-epc-fed/blob/master-documentation/docs/DEPLOY_HOME.md
+
+
+
+## Configuration Files
+
+Each component (EPC, eNB, gNB) has its own configuration file.  
+These config files are passed as arguments of the run command line, using the option -O \<conf file\>
+
+Some config examples can be found in the following folder:  
+https://gitlab.eurecom.fr/oai/openairinterface5g/-/tree/develop/targets/PROJECTS/GENERIC-LTE-EPC/CONF
+
+Also base config files can be found here:  
+[enb conf file](https://gitlab.eurecom.fr/oai/openairinterface5g/-/blob/rh_doc_update_3/doc/testing_gnb_w_cots_ue_resources/enb.conf)  
+[gnb conf file](https://gitlab.eurecom.fr/oai/openairinterface5g/-/blob/rh_doc_update_3/doc/testing_gnb_w_cots_ue_resources/gnb.conf)
+
+TO DO : attach base confif files
+
+These files have to be updated manually to set the IP addresses and frequency.  
+
+1- In the **eNB configuration file** :
+- look for MME IP address, and update the **ipv4 field** with the IP address of the **EPC** server
+```
+    ////////// MME parameters:
+    mme_ip_address      = ( { ipv4       = "**YOUR_EPC_IP_ADDR**";
+                              ipv6       = "192:168:30::17";
+                              active     = "yes";
+                              preference = "ipv4";
+                            }
+                          );
+
+```
+
+- look for S1 IP address, and update the **3 fields below** with the IP address of the **eNB** server  
+```
+    NETWORK_INTERFACES :
+    {
+        ENB_INTERFACE_NAME_FOR_S1_MME            = "eth0";
+        ENB_IPV4_ADDRESS_FOR_S1_MME              = "**YOUR_ENB_IP_ADDR**";
+        ENB_INTERFACE_NAME_FOR_S1U               = "eth0";
+        ENB_IPV4_ADDRESS_FOR_S1U                 = "**YOUR_ENB_IP_ADDR**";
+        ENB_PORT_FOR_S1U                         = 2152; # Spec 2152
+        ENB_IPV4_ADDRESS_FOR_X2C                 = "**YOUR_ENB_IP_ADDR**";
+        ENB_PORT_FOR_X2C                         = 36422; # Spec 36422
+    };
+
+```
+
+2- In the **gNB configuration file** :
+- look for MME IP address, and update the **ipv4 field** with the IP address of the **EPC** server
+```
+    ////////// MME parameters:
+    mme_ip_address      = ( { ipv4       = "**YOUR_EPC_IP_ADDR**";
+                              ipv6       = "192:168:30::17";
+                              active     = "yes";
+                              preference = "ipv4";
+                            }
+                          );
+```
+- look for X2 IP address, and update the **4 fields** with the IP address of the **eNB** server (notice : even if -in principle- S1 MME is not required for gNB setting)
+```
+
+    ///X2
+    enable_x2 = "yes";
+    t_reloc_prep      = 1000;      /* unit: millisecond */
+    tx2_reloc_overall = 2000;      /* unit: millisecond */
+    target_enb_x2_ip_address      = (
+                                     { ipv4       = "**YOUR_ENB_IP_ADDR**";
+                                       ipv6       = "192:168:30::17";
+                                       preference = "ipv4";
+                                     }
+                                    );
+
+    NETWORK_INTERFACES :
+    {
+
+        GNB_INTERFACE_NAME_FOR_S1_MME            = "eth0";
+        GNB_IPV4_ADDRESS_FOR_S1_MME              = "**YOUR_ENB_IP_ADDR**";
+        GNB_INTERFACE_NAME_FOR_S1U               = "eth0";
+        GNB_IPV4_ADDRESS_FOR_S1U                 = "**YOUR_ENB_IP_ADDR**";
+        GNB_PORT_FOR_S1U                         = 2152; # Spec 2152
+        GNB_IPV4_ADDRESS_FOR_X2C                 = "**YOUR_ENB_IP_ADDR**";
+        GNB_PORT_FOR_X2C                         = 36422; # Spec 36422
+    };
+
+    
+```
+
+
+
+3- The frequency setting requires a manual update in the .C and in the gNB conf file:
+
+
+In the C file **openair2/RRC/LTE/rrc_eNB.c:3217**  
+set the nrarfcn to the same value as absoluteFrequencySSB in the **gNB config file**, that is **641272** in the example below 
+
+C file :
+```
+MeasObj2->measObject.choice.measObjectNR_r15.carrierFreq_r15 =641272;
+```
+
+gNB config file :
+
+```
+    # absoluteFrequencySSB is the central frequency of SSB 
+    absoluteFrequencySSB                                          = 641272; 
+    dl_frequencyBand                                                 = 78;
+    # the carrier frequency is assumed to be in the middle of the carrier, i.e. dl_absoluteFrequencyPointA_kHz + dl_carrierBandwidth*12*SCS_kHz/2
+    dl_absoluteFrequencyPointA                                       = 640000;
+    #scs-SpecificCarrierList
+    dl_offstToCarrier                                              = 0;
+    # subcarrierSpacing
+    # 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120  
+    dl_subcarrierSpacing                                           = 1;
+    dl_carrierBandwidth                                            = 106;
+```
+
+
+## Run and Test
+
+The order to run the different components is important:  
+1- first, CN  
+2- then, eNB  
+3- then, gNB  
+4- finally, switch UE from airplane mode OFF to ON  
+
+It is recommended to redirect the run commands to the same log file (fur further analysis and debug), using ```| tee **YOUR_LOG_FILE**``` especially for eNB and gNB.  
+It is not very useful for the CN.  
+
+The test takes typically a few seconds, max 10-15 seconds. If it takes more than 30 seconds, there is a problem. 
+
+- **EPC** (on EPC host):
+
+for reference:
+https://github.com/OPENAIRINTERFACE/openair-epc-fed/blob/master-documentation/docs/DEPLOY_HOME.md
+
+
+
+- **eNB** (on the eNB host):
+
+Execute: 
+```
+~/openairinterface5g/cmake_targets/ran_build/build$ sudo ./lte-softmodem -O **YOUR_ENB_CONF_FILE** | tee **YOUR_LOG_FILE**
+
+```
+
+For example:
+```
+~/openairinterface5g/cmake_targets/ran_build/build$ sudo ./lte-softmodem -O ../../../targets/PROJECTS/GENERIC-LTE-EPC/CONF/enb.band7.tm1.50PRB.usrpb210.conf | tee mylogfile.log
+```
+
+
+
+- **gNB** (on the gNB host)
+
+
+Execute: 
+```
+~/openairinterface5g/cmake_targets/ran_build/build$ sudo ./nr-softmodem -O **YOUR_GNB_CONF_FILE** | tee **YOUR_LOG_FILE**
+
+```
+
+For example:
+```
+~/openairinterface5g/cmake_targets/ran_build/build$ sudo ./nr-softmodem -O ../../../targets/PROJECTS/GENERIC-LTE-EPC/CONF/gnb.band78.tm1.106PRB.usrpn300.conf | tee mylogfile.log
+```
+
+
+## Test Case
+
+The test case corresponds to the UE attachement, that is the UE connection and its initial access in 5G, as depicted below:
+
+**Source** : https://www.sharetechnote.com/html/5G/5G_LTE_Interworking.html  
+
+![image info](./testing_gnb_w_cots_ue_resources/attach_signaling_scheme.jpg)
+
+The test reaches step **12. E-RAB modifcation confirmation** , eventhough not all the messages will appear in the log file. 
+
+## Log file monitoring
+
+From the log file that is generated, we can monitor several important steps, to assess that the test was successful.  
+Log files examples can be found here:  
+[enb log file](https://gitlab.eurecom.fr/oai/openairinterface5g/-/blob/rh_doc_update_3/doc/testing_gnb_w_cots_ue_resources/oai_enb.log)  
+[gnb log file](https://gitlab.eurecom.fr/oai/openairinterface5g/-/blob/rh_doc_update_3/doc/testing_gnb_w_cots_ue_resources/oai_gnb.log)
+
+
+- eNB receives UE capabilities information, including its NR capabilites, and triggers sGNB Addition Request message:
+
+***eNBlog.1315 :***
+```
+[RRC]   [FRAME 00000][eNB][MOD 00][RNTI 43eb] received ueCapabilityInformation on UL-DCCH 1 from UE
+...
+[RRC]   [eNB 0] frame 0 subframe 0: UE rnti 43eb switching to NSA mode
+...
+<X2AP-PDU>
+     <initiatingMessage>
+         <procedureCode>27</procedureCode>
+         <criticality><reject/></criticality>
+         <value>
+             <SgNBAdditionRequest>
+                 <protocolIEs>
+                     <SgNBAdditionRequest-IEs>
+                         <id>111</id>
+<criticality><reject/></criticality>
+                         <value>
+                             <UE-X2AP-ID>0</UE-X2AP-ID>
+                         </value>
+                     </SgNBAdditionRequest-IEs>
+```
+
+- gNB receives sGNB Addition request, processes UE capabilities for the corresponding UE and triggers sGNB Addition Request ACK, carrying NR RRC Reconfiguration message:
+
+
+***gNBlog.2291 :***
+```
+<X2AP-PDU>
+     <successfulOutcome>
+         <procedureCode>27</procedureCode>
+         <criticality><reject/></criticality>
+         <value>
+             <SgNBAdditionRequestAcknowledge>
+                 <protocolIEs>
+                     <SgNBAdditionRequestAcknowledge-IEs>
+                         <id>111</id>
+<criticality><reject/></criticality>
+                         <value>
+                             <UE-X2AP-ID>0</UE-X2AP-ID>
+                         </value>
+                     </SgNBAdditionRequestAcknowledge-IEs>
+```
+
+
+- Upon reception of the sGNB Addition Request ACK, the eNB sends a new RRCConnectionReconfiguration message containing the NR Reconfiguration. 
+The UE replies with a Reconfiguration Complete message:
+
+***eNBlog.1686 :***
+```
+[RRC]   [FRAME 00000][eNB][MOD 00][RNTI 43eb] UE State = RRC_RECONFIGURED (default DRB, xid 1)
+```
+
+- The Random Access procedure of the UE to the gNB takes place:
+
+***gNBlog.2382 :***
+```
+[PHY]   [gNB 0][RAPROC] Frame 751, slot 19 Initiating RA procedure with 
+preamble 63, energy 35.7 dB, delay 6
+ [0m [0m[MAC]   [gNB 0][RAPROC] CC_id 0 Frame 751, Slot 19 Initiating RA 
+procedure for preamble index 63
+ [0m [0m[MAC]   [gNB 0][RAPROC] CC_id 0 Frame 751 Activating Msg2 
+generation in frame 752, slot 7 using RA rnti 10b
+ [0m [0m[MAC]   [gNB 0] [RAPROC] CC_id 0 Frame 752, slotP 7: Generating 
+RAR DCI, state 1
+ [0m [0m[MAC]   [RAPROC] DCI type 1 payload: freq_alloc 120 (0,6,24), 
+time_alloc 3, vrb to prb 0, mcs 0 tb_scaling 0
+ [0m [0m[MAC]   Frame 752: Subframe 7 : Adding common DL DCI for RA_RNTI 10b
+ [0m [0m[MAC]   Frame 752, Subframe 7: Setting Msg3 reception for Frame 
+752 Subframe 17
+ [0m [0m[PHY]   ULSCH received ok
+```
+
+- The eNB triggers the path switch procedure towards the MME, so that 
+the traffic can be routed now from the SGW towards the gNB on the S1-U 
+plane.
+
+***eNBlog.1691 :***
+```
+<S1AP-PDU>
+     <initiatingMessage>
+         <procedureCode>50</procedureCode>
+         <criticality><reject/></criticality>
+         <value>
+             <E-RABModificationIndication>
+                 <protocolIEs>
+                     <E-RABModificationIndicationIEs>
+                         <id>0</id>
+<criticality><reject/></criticality>
+                         <value>
+<MME-UE-S1AP-ID>553648130</MME-UE-S1AP-ID>
+                         </value>
+                     </E-RABModificationIndicationIEs>
+```
+
+
+Eventually, step **12. E-RAB Modification Confirmation** is successfully reached
+
+
+
+## Required tools for debug
+
+- **Wireshark** to trace X2AP and S1AP protocols  
+- **Ttracer** for 5G messages  
+- **GDB debugger** to check function calls  
+
+
+## Status of interoperability
+
+The following parts have been validated with FR1 COTS UE:
+
+- Phone accepts the configurtion provided by OAI eNB:  
+    this validates RRC and X2AP  
+
+- Successful Random Access Procedure:  
+    PRACH is correctly decoded at gNB  
+    Phone correctly receives and decodes msg2 (NR PDCCH Format 1_0 and NR PDSCH)  
+    msg3  is transmitted to gNB according to the configuration sent in msg2, and received correctly at gNB    
+
+- Successful path switch of user plane traffic from 4G to 5G cell (E-RAB modification message):  
+   this validates S1AP  
+
+- Downlink traffic:  
+    PDCCH DCI format 1_1 and correponding PDSCH are decoded correctlyby the phone  
+    ACK/NACK (PUCCH format 0) are successfully received at gNB  
+
+- On going:  
+    validation of HARQ procedures  
+    Integration with higher layers to replace dummy data with real traffic  
+    
+- Known limitations as of May 2020:  
+    only dummy DL traffic  
+    no UL traffic  
+    no end-to-end traffic possible  
+
+
@@ -0,0 +1,281 @@
+Active_eNBs = ( "eNB-Eurecom-LTEBox");
+# Asn1_verbosity, choice in: none, info, annoying
+Asn1_verbosity = "none";
+
+eNBs =
+(
+ {
+    # real_time choice in {hard, rt-preempt, no}
+    real_time       =  "no";
+    ////////// Identification parameters:
+    eNB_ID    =  0xe01;
+    
+    cell_type =  "CELL_MACRO_ENB";
+    
+    eNB_name  =  "eNB-Eurecom-LTEBox";
+    
+    // Tracking area code, 0x0000 and 0xfffe are reserved values
+    tracking_area_code  =  1;
+    plmn_list = (
+      { mcc = 222; mnc = 01; mnc_length = 2; }
+    );
+    
+    tr_s_preference     = "local_mac"
+
+       ////////// Physical parameters:
+  
+    component_carriers = (
+    		       	 {
+                           node_function = "eNodeB_3GPP";
+                           node_timing = "synch_to_ext_device";
+                           node_synch_ref = 0;
+                           nb_antenna_ports = 1;
+                           ue_TransmissionMode = 1;
+  			   frame_type					      = "FDD";	
+                           tdd_config 					      = 3;
+                           tdd_config_s            			      = 0;
+ 			   prefix_type             			      = "NORMAL";
+  			   eutra_band              			      = 7;
+                           downlink_frequency      			      = 2680000000L; //2655000000L;
+                           uplink_frequency_offset 			      = -120000000;
+  
+  			   Nid_cell					      = 0;
+                           N_RB_DL                 			      = 25; //100;
+                           Nid_cell_mbsfn          			      = 0;
+                           nb_antennas_tx          			      = 1;
+                           nb_antennas_rx          			      = 1; 
+                           prach_root              			      = 0;
+			   tx_gain                                            = 90;
+			   rx_gain                                            = 115;
+                           pbch_repetition                                    = "FALSE";
+                           prach_config_index      			      = 0;
+                           prach_high_speed        			      = "DISABLE";
+  	                   prach_zero_correlation  			      = 1;
+                           prach_freq_offset       			      = 2;
+			   pucch_delta_shift       			      = 1;
+                           pucch_nRB_CQI           			      = 0;
+                           pucch_nCS_AN            			      = 0;
+                           pucch_n1_AN             			      = 0;
+                           pdsch_referenceSignalPower 			      = -29;
+                           pdsch_p_b                  			      = 0;
+                           pusch_n_SB                 			      = 1; 
+                           pusch_enable64QAM          			      = "DISABLE";
+			   pusch_hoppingMode                                  = "interSubFrame";
+			   pusch_hoppingOffset                                = 0;
+     	                   pusch_groupHoppingEnabled  			      = "ENABLE";
+	                   pusch_groupAssignment      			      = 0;
+	                   pusch_sequenceHoppingEnabled		   	      = "DISABLE";
+	                   pusch_nDMRS1                                       = 1;
+	                   phich_duration                                     = "NORMAL";
+	                   phich_resource                                     = "ONESIXTH";
+	                   srs_enable                                         = "DISABLE";
+	               /*  srs_BandwidthConfig                                =;
+	                   srs_SubframeConfig                                 =;
+	                   srs_ackNackST                                      =;
+	                   srs_MaxUpPts                                       =;*/  
+
+	                   pusch_p0_Nominal                                   = -96;
+	                   pusch_alpha                                        = "AL1";
+	                   pucch_p0_Nominal                                   = -96;
+	                   msg3_delta_Preamble                                = 6;
+	                   pucch_deltaF_Format1                               = "deltaF2";
+	                   pucch_deltaF_Format1b                              = "deltaF3";
+	                   pucch_deltaF_Format2                               = "deltaF0";
+	                   pucch_deltaF_Format2a                              = "deltaF0";
+  	                   pucch_deltaF_Format2b		    	      = "deltaF0";
+	
+                           rach_numberOfRA_Preambles                          = 64;
+                           rach_preamblesGroupAConfig                         = "DISABLE";
+/*
+                           rach_sizeOfRA_PreamblesGroupA                      = ;
+                           rach_messageSizeGroupA                             = ;
+                           rach_messagePowerOffsetGroupB                      = ; 
+*/
+                           rach_powerRampingStep                              = 4;
+	                   rach_preambleInitialReceivedTargetPower            = -108;
+                           rach_preambleTransMax                              = 10;
+	                   rach_raResponseWindowSize                          = 10;
+	                   rach_macContentionResolutionTimer                  = 48;
+	                   rach_maxHARQ_Msg3Tx                                = 4;
+
+			   pcch_default_PagingCycle                           = 128;
+			   pcch_nB                                            = "oneT";
+			   bcch_modificationPeriodCoeff			      = 2;
+			   ue_TimersAndConstants_t300			      = 1000;
+			   ue_TimersAndConstants_t301			      = 1000;
+			   ue_TimersAndConstants_t310			      = 1000;
+			   ue_TimersAndConstants_t311			      = 10000;
+			   ue_TimersAndConstants_n310			      = 20;
+			   ue_TimersAndConstants_n311			      = 1;
+
+      //Parameters for SIB18
+      rxPool_sc_CP_Len                                       = "normal"; 
+      rxPool_sc_Period                                       = "sf40";  
+      rxPool_data_CP_Len                                     = "normal";  
+      rxPool_ResourceConfig_prb_Num                          = 20;
+      rxPool_ResourceConfig_prb_Start                        = 5;
+      rxPool_ResourceConfig_prb_End                          = 44;
+      rxPool_ResourceConfig_offsetIndicator_present          = "prSmall";
+      rxPool_ResourceConfig_offsetIndicator_choice           = 0;      
+      rxPool_ResourceConfig_subframeBitmap_present           = "prBs40";
+      rxPool_ResourceConfig_subframeBitmap_choice_bs_buf              = "00000000000000000000";
+      rxPool_ResourceConfig_subframeBitmap_choice_bs_size             = 5;
+      rxPool_ResourceConfig_subframeBitmap_choice_bs_bits_unused      = 0;
+/*    rxPool_dataHoppingConfig_hoppingParameter                       = 0;
+      rxPool_dataHoppingConfig_numSubbands                            = "ns1";
+      rxPool_dataHoppingConfig_rbOffset                               = 0;
+      rxPool_commTxResourceUC-ReqAllowed                              = "TRUE";
+*/    
+      // Parameters for SIB19
+      discRxPool_cp_Len                                               = "normal"
+      discRxPool_discPeriod                                           = "rf32"
+      discRxPool_numRetx                                              = 1;   
+      discRxPool_numRepetition                                        = 2;
+      discRxPool_ResourceConfig_prb_Num                               = 5;  
+      discRxPool_ResourceConfig_prb_Start                             = 3;
+      discRxPool_ResourceConfig_prb_End                               = 21;
+      discRxPool_ResourceConfig_offsetIndicator_present               = "prSmall";
+      discRxPool_ResourceConfig_offsetIndicator_choice                = 0;      
+      discRxPool_ResourceConfig_subframeBitmap_present                = "prBs40";
+      discRxPool_ResourceConfig_subframeBitmap_choice_bs_buf          = "f0ffffffff";
+      discRxPool_ResourceConfig_subframeBitmap_choice_bs_size         = 5;
+      discRxPool_ResourceConfig_subframeBitmap_choice_bs_bits_unused  = 0;
+
+			 }
+			 );
+
+    srb1_parameters :
+    {
+        # timer_poll_retransmit = (ms) [5, 10, 15, 20,... 250, 300, 350, ... 500]
+        timer_poll_retransmit    = 80;
+
+        # timer_reordering = (ms) [0,5, ... 100, 110, 120, ... ,200]
+        timer_reordering         = 35;
+
+        # timer_reordering = (ms) [0,5, ... 250, 300, 350, ... ,500]
+        timer_status_prohibit    = 0;
+
+        # poll_pdu = [4, 8, 16, 32 , 64, 128, 256, infinity(>10000)]
+        poll_pdu                 =  4;
+
+        # poll_byte = (kB) [25,50,75,100,125,250,375,500,750,1000,1250,1500,2000,3000,infinity(>10000)]
+        poll_byte                =  99999;
+
+        # max_retx_threshold = [1, 2, 3, 4 , 6, 8, 16, 32]
+        max_retx_threshold       =  4;
+    }
+
+    # ------- SCTP definitions
+    SCTP :
+    {
+        # Number of streams to use in input/output
+        SCTP_INSTREAMS  = 2;
+        SCTP_OUTSTREAMS = 2;
+    };
+
+    enable_measurement_reports = "yes";
+
+    ////////// MME parameters:
+    mme_ip_address      = ( { ipv4       = "192.168.18.99";
+                              ipv6       = "192:168:30::17";
+                              active     = "yes";
+                              preference = "ipv4";
+                            }
+                          );
+
+    ///X2
+    enable_x2 = "yes";
+    t_reloc_prep      = 1000;      /* unit: millisecond */
+    tx2_reloc_overall = 2000;      /* unit: millisecond */
+
+    NETWORK_INTERFACES : 
+    {
+        ENB_INTERFACE_NAME_FOR_S1_MME            = "eth1";
+        ENB_IPV4_ADDRESS_FOR_S1_MME              = "192.168.18.199/24";
+
+        ENB_INTERFACE_NAME_FOR_S1U               = "eth1";
+        ENB_IPV4_ADDRESS_FOR_S1U                 = "192.168.18.199/24";
+        ENB_PORT_FOR_S1U                         = 2152; # Spec 2152
+
+        ENB_IPV4_ADDRESS_FOR_X2C                 = "192.168.18.199/24";
+        ENB_PORT_FOR_X2C                         = 36422; # Spec 36422
+    };
+    
+    log_config : 
+    {
+	global_log_level                      ="info"; 
+    	global_log_verbosity                  ="high";
+	hw_log_level                          ="info"; 
+    	hw_log_verbosity                      ="medium";
+	phy_log_level                         ="info"; 
+    	phy_log_verbosity                     ="medium";
+	mac_log_level                         ="info"; 
+    	mac_log_verbosity                     ="high";
+	rlc_log_level                         ="debug"; 
+    	rlc_log_verbosity                     ="high";
+	pdcp_log_level                        ="info"; 
+    	pdcp_log_verbosity                    ="high";
+	rrc_log_level                         ="info"; 
+    	rrc_log_verbosity                     ="medium";
+   };	
+   
+  }
+);
+
+MACRLCs = (
+        {
+        num_cc = 1;
+        tr_s_preference = "local_L1";
+        tr_n_preference = "local_RRC";
+        phy_test_mode = 0;
+        puSch10xSnr     =  160;
+        puCch10xSnr     =  160;
+        }  
+);
+
+THREAD_STRUCT = (
+  {
+    parallel_config = "PARALLEL_RU_L1_TRX_SPLITaaaaaa";
+    worker_config = "ENABLE";
+  }
+);
+
+L1s = (
+        {
+        num_cc = 1;
+        tr_n_preference = "local_mac";
+        }  
+);
+
+RUs = (
+    {             
+       local_rf       = "yes"
+         nb_tx          = 1
+         nb_rx          = 1
+         att_tx         = 0
+         att_rx         = 0;
+         bands          = [7];
+         max_pdschReferenceSignalPower = -27;
+         max_rxgain                    = 118;
+         eNB_instances  = [0];
+
+    }
+);  
+
+    log_config : 
+    {
+	global_log_level                      ="info"; 
+    	global_log_verbosity                  ="high";
+	hw_log_level                          ="info"; 
+    	hw_log_verbosity                      ="medium";
+	phy_log_level                         ="info"; 
+    	phy_log_verbosity                     ="medium";
+	mac_log_level                         ="info"; 
+    	mac_log_verbosity                     ="high";
+	rlc_log_level                         ="info"; 
+    	rlc_log_verbosity                     ="high";
+	pdcp_log_level                        ="info"; 
+    	pdcp_log_verbosity                    ="high";
+	rrc_log_level                         ="info"; 
+    	rrc_log_verbosity                     ="medium";
+   };	
@@ -0,0 +1,293 @@
+Active_gNBs = ( "gNB-Eurecom-5GNRBox");
+# Asn1_verbosity, choice in: none, info, annoying
+Asn1_verbosity = "none";
+
+gNBs =
+(
+ {
+    ////////// Identification parameters:
+    gNB_ID    =  0xe00;
+
+    cell_type =  "CELL_MACRO_GNB";
+
+    gNB_name  =  "gNB-Eurecom-5GNRBox";
+
+    // Tracking area code, 0x0000 and 0xfffe are reserved values
+    tracking_area_code  =  1;
+
+    plmn_list = ({mcc = 222; mnc = 01; mnc_length = 2;});	 
+
+    tr_s_preference     = "local_mac"
+
+    ////////// Physical parameters:
+
+    ssb_SubcarrierOffset                                      = 31; //0;
+    pdsch_AntennaPorts                                        = 1;
+	
+    servingCellConfigCommon = (
+    {
+ #spCellConfigCommon
+
+      physCellId                                                    = 0;
+
+#  downlinkConfigCommon
+    #frequencyInfoDL
+      # this is 3600 MHz + 84 PRBs@30kHz SCS (same as initial BWP)
+      absoluteFrequencySSB                                          = 641272; //641032;      #641968; 641968=start of ssb at 3600MHz + 82 RBs    641032=center of SSB at center of cell
+      dl_frequencyBand                                                 = 78;
+      # this is 3600 MHz
+      dl_absoluteFrequencyPointA                                       = 640000;
+      #scs-SpecificCarrierList
+        dl_offstToCarrier                                              = 0;
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120  
+        dl_subcarrierSpacing                                           = 1;
+        dl_carrierBandwidth                                            = 106;
+     #initialDownlinkBWP
+      #genericParameters
+        # this is RBstart=84,L=13 (275*(L-1))+RBstart
+        initialDLBWPlocationAndBandwidth                                        = 6366; //28875; //6366; #6407; #3384;
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120  
+        initialDLBWPsubcarrierSpacing                                           = 1;
+      #pdcch-ConfigCommon
+        initialDLBWPcontrolResourceSetZero                                      = 0;
+        initialDLBWPsearchSpaceZero                                             = 0;
+      #pdsch-ConfigCommon
+        #pdschTimeDomainAllocationList (up to 16 entries)
+             initialDLBWPk0_0                    = 0;
+             #initialULBWPmappingType
+	     #0=typeA,1=typeB
+             initialDLBWPmappingType_0           = 0;
+             #this is SS=1,L=13
+             initialDLBWPstartSymbolAndLength_0  = 40;
+
+             initialDLBWPk0_1                    = 0;
+             initialDLBWPmappingType_1           = 0;
+             #this is SS=2,L=12 
+             initialDLBWPstartSymbolAndLength_1  = 53;
+
+             initialDLBWPk0_2                    = 0;
+             initialDLBWPmappingType_2           = 0;
+             #this is SS=1,L=12 
+             initialDLBWPstartSymbolAndLength_2  = 54;
+
+             initialDLBWPk0_3                    = 0;
+             initialDLBWPmappingType_3           = 0;
+             #this is SS=1,L=4 //5 (4 is for 43, 5 is for 57)
+             initialDLBWPstartSymbolAndLength_3  = 57; //43; //57;
+  #uplinkConfigCommon 
+     #frequencyInfoUL
+      ul_frequencyBand                                                 = 78;
+      #scs-SpecificCarrierList
+      ul_offstToCarrier                                              = 0;
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120  
+      ul_subcarrierSpacing                                           = 1;
+      ul_carrierBandwidth                                            = 106;
+      pMax                                                          = 20;
+     #initialUplinkBWP
+      #genericParameters
+        initialULBWPlocationAndBandwidth                                        = 6366; //28875; //6366; #6407; #3384;
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120  
+        initialULBWPsubcarrierSpacing                                           = 1;
+      #rach-ConfigCommon
+        #rach-ConfigGeneric
+          prach_ConfigurationIndex                                  = 98;
+#prach_msg1_FDM
+#0 = one, 1=two, 2=four, 3=eight
+          prach_msg1_FDM                                            = 0;
+          prach_msg1_FrequencyStart                                 = 0;
+          zeroCorrelationZoneConfig                                 = 13;
+          preambleReceivedTargetPower                               = -118;
+#preamblTransMax (0...10) = (3,4,5,6,7,8,10,20,50,100,200)
+          preambleTransMax                                          = 6;
+#powerRampingStep
+# 0=dB0,1=dB2,2=dB4,3=dB6
+        powerRampingStep                                            = 1;
+#ra_ReponseWindow
+#1,2,4,8,10,20,40,80
+        ra_ResponseWindow                                           = 5;
+#ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR
+#1=oneeighth,2=onefourth,3=half,4=one,5=two,6=four,7=eight,8=sixteen
+        ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR                = 4;
+#oneHalf (0..15) 4,8,12,16,...60,64
+        ssb_perRACH_OccasionAndCB_PreamblesPerSSB                   = 14; //15;
+#ra_ContentionResolutionTimer
+#(0..7) 8,16,24,32,40,48,56,64
+        ra_ContentionResolutionTimer                                = 7;
+        rsrp_ThresholdSSB                                           = 19;
+#prach-RootSequenceIndex_PR
+#1 = 839, 2 = 139
+        prach_RootSequenceIndex_PR                                  = 2;
+        prach_RootSequenceIndex                                     = 1;
+        # SCS for msg1, can only be 15 for 30 kHz < 6 GHz, takes precendence over the one derived from prach-ConfigIndex
+        #  
+        msg1_SubcarrierSpacing                                      = 1,
+
+# restrictedSetConfig
+# 0=unrestricted, 1=restricted type A, 2=restricted type B
+        restrictedSetConfig                                         = 0,
+      # pusch-ConfigCommon (up to 16 elements)
+        initialULBWPk2_0                      = 2;
+        initialULBWPmappingType_0             = 1
+        # this is SS=0 L=11
+        initialULBWPstartSymbolAndLength_0    = 55;
+ 	
+	initialULBWPk2_1                      = 2;
+        initialULBWPmappingType_1             = 1;
+        # this is SS=0 L=12
+        initialULBWPstartSymbolAndLength_1    = 69;
+
+        initialULBWPk2_2                      = 7;
+        initialULBWPmappingType_2             = 1;
+        # this is SS=10 L=4
+        initialULBWPstartSymbolAndLength_2    = 52;
+
+        msg3_DeltaPreamble                                          = 1;
+        p0_NominalWithGrant                                         =-90;
+
+# pucch-ConfigCommon setup :
+# pucchGroupHopping
+# 0 = neither, 1= group hopping, 2=sequence hopping
+        pucchGroupHopping                                           = 0;
+        hoppingId                                                   = 40;
+        p0_nominal                                                  = -90;
+# ssb_PositionsInBurs_BitmapPR
+# 1=short, 2=medium, 3=long
+      ssb_PositionsInBurst_PR                                       = 2;
+      ssb_PositionsInBurst_Bitmap                                   = 1; #0x80;
+
+# ssb_periodicityServingCell
+# 0 = ms5, 1=ms10, 2=ms20, 3=ms40, 4=ms80, 5=ms160, 6=spare2, 7=spare1 
+      ssb_periodicityServingCell                                    = 2;
+
+# dmrs_TypeA_position
+# 0 = pos2, 1 = pos3
+      dmrs_TypeA_Position                                           = 0;
+
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120  
+      subcarrierSpacing                                             = 1;
+
+
+  #tdd-UL-DL-ConfigurationCommon
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120  
+      referenceSubcarrierSpacing                                    = 1;
+      # pattern1 
+      # dl_UL_TransmissionPeriodicity
+      # 0=ms0p5, 1=ms0p625, 2=ms1, 3=ms1p25, 4=ms2, 5=ms2p5, 6=ms5, 7=ms10
+      dl_UL_TransmissionPeriodicity                                 = 6;
+      nrofDownlinkSlots                                             = 7; //8; //7;
+      nrofDownlinkSymbols                                           = 6; //0; //6;
+      nrofUplinkSlots                                               = 2;
+      nrofUplinkSymbols                                             = 4; //0; //4;
+
+  ssPBCH_BlockPower                                             = 10;
+  }
+
+  );
+
+
+    # ------- SCTP definitions
+    SCTP :
+    {
+        # Number of streams to use in input/output
+        SCTP_INSTREAMS  = 2;
+        SCTP_OUTSTREAMS = 2;
+    };
+
+
+    ////////// MME parameters:
+    mme_ip_address      = ( { ipv4       = "192.168.18.99";
+                              ipv6       = "192:168:30::17";
+                              active     = "yes";
+                              preference = "ipv4";
+                            }
+                          );
+
+    ///X2
+    enable_x2 = "yes";
+    t_reloc_prep      = 1000;      /* unit: millisecond */
+    tx2_reloc_overall = 2000;      /* unit: millisecond */
+    target_enb_x2_ip_address      = (
+                                     { ipv4       = "192.168.18.199";
+                                       ipv6       = "192:168:30::17";
+                                       preference = "ipv4";
+                                     }
+                                    );
+
+    NETWORK_INTERFACES :
+    {
+
+        GNB_INTERFACE_NAME_FOR_S1_MME            = "eth0";
+        GNB_IPV4_ADDRESS_FOR_S1_MME              = "192.168.18.198/24";
+        GNB_INTERFACE_NAME_FOR_S1U               = "eth0";
+        GNB_IPV4_ADDRESS_FOR_S1U                 = "192.168.18.198/24";
+        GNB_PORT_FOR_S1U                         = 2152; # Spec 2152
+        GNB_IPV4_ADDRESS_FOR_X2C                 = "192.168.18.198/24";
+        GNB_PORT_FOR_X2C                         = 36422; # Spec 36422
+    };
+  }
+);
+
+MACRLCs = (
+	{
+	num_cc = 1;
+	tr_s_preference = "local_L1";
+	tr_n_preference = "local_RRC";
+        }  
+);
+
+L1s = (
+    	{
+	num_cc = 1;
+	tr_n_preference = "local_mac";
+        }  
+);
+
+RUs = (
+    {		  
+       local_rf       = "yes"
+         nb_tx          = 1
+         nb_rx          = 1
+         att_tx         = 0
+         att_rx         = 0;
+         bands          = [7];
+         max_pdschReferenceSignalPower = -27;
+         max_rxgain                    = 114;
+         eNB_instances  = [0];
+         clock_src = "internal";
+    }
+);  
+
+THREAD_STRUCT = (
+  {
+    #three config for level of parallelism "PARALLEL_SINGLE_THREAD", "PARALLEL_RU_L1_SPLIT", or "PARALLEL_RU_L1_TRX_SPLIT"
+    //parallel_config    = "PARALLEL_RU_L1_TRX_SPLIT";
+    parallel_config    = "PARALLEL_SINGLE_THREAD";
+    #two option for worker "WORKER_DISABLE" or "WORKER_ENABLE"
+    worker_config      = "WORKER_ENABLE";
+  }
+);
+
+     log_config :
+     {
+       global_log_level                      ="info";
+       global_log_verbosity                  ="medium";
+       hw_log_level                          ="info";
+       hw_log_verbosity                      ="medium";
+       phy_log_level                         ="info";
+       phy_log_verbosity                     ="medium";
+       mac_log_level                         ="info";
+       mac_log_verbosity                     ="high";
+       rlc_log_level                         ="info";
+       rlc_log_verbosity                     ="medium";
+       pdcp_log_level                        ="info";
+       pdcp_log_verbosity                    ="medium";
+       rrc_log_level                         ="info";
+       rrc_log_verbosity                     ="medium";
+    };
+
@@ -80,6 +80,7 @@ int32_t   uplink_frequency_offset[MAX_NUM_CCs][4];
 int split73;
 char * split73_config;
 int split73;
+int usrp_tx_thread = 0;

 static void *ru_thread( void *param );
 void kill_RU_proc(RU_t *ru) {
@@ -1152,6 +1153,7 @@ int restart_L1L2(module_id_t enb_id) {
 }

 int main ( int argc, char **argv ) {
+  //mtrace();
  int i;
  int CC_id = 0;
  int node_type = ngran_eNB;
@@ -772,8 +772,8 @@ void tx_rf(RU_t *ru,int frame,int slot, uint64_t timestamp) {
 					siglen+sf_extension,
 					ru->nb_tx,
 					flags);
-      LOG_D(PHY,"[TXPATH] RU %d tx_rf, writing to TS %llu, frame %d, unwrapped_frame %d, slot %d\n",ru->idx,
-	    (long long unsigned int)timestamp,frame,proc->frame_tx_unwrap,slot);
+      LOG_D(PHY,"[TXPATH] RU %d tx_rf, writing to TS %llu, frame %d, unwrapped_frame %d, slot %di, returned %d\n",ru->idx,
+	    (long long unsigned int)timestamp,frame,proc->frame_tx_unwrap,slot, txs);
      VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE, 0 );
      //AssertFatal(txs == 0,"trx write function error %d\n", txs);
  }
@@ -71,8 +71,8 @@ unsigned short config_frames[4] = {2,9,11,13};
 #include "PHY/INIT/phy_init.h"
 #include "system.h"
 #include <openair2/RRC/NR_UE/rrc_proto.h>
-#include "NR_MAC_UE/mac_defs.h"
-#include "NR_MAC_UE/mac_proto.h"
+#include <openair2/LAYER2/NR_MAC_UE/mac_defs.h>
+#include <openair2/LAYER2/NR_MAC_UE/mac_proto.h>
 #include <openair2/NR_UE_PHY_INTERFACE/NR_IF_Module.h>
 #include <openair1/SCHED_NR_UE/fapi_nr_ue_l1.h>

@@ -324,6 +324,7 @@ int check_crc(uint8_t* decoded_bytes, uint32_t n, uint32_t F, uint8_t crc_type)
      AssertFatal(1,"Invalid crc_type \n");
    }

+
    if (crc == oldcrc)
      return(1);
    else
@@ -146,7 +146,7 @@ void polar_encoder_dci(uint32_t *in,
                       uint16_t n_RNTI);

 void polar_encoder_fast(uint64_t *A,
-                        uint32_t *out,
+                        void *out,
                        int32_t crcmask,
                        uint8_t ones_flag,
                        t_nrPolar_params *polarParams);
@@ -408,7 +408,7 @@ void build_polar_tables(t_nrPolar_params *polarParams) {
 }

 void polar_encoder_fast(uint64_t *A,
-                        uint32_t *out,
+                        void *out,
                        int32_t crcmask,
                        uint8_t ones_flag,
                        t_nrPolar_params *polarParams) {
@@ -676,5 +676,5 @@ void polar_encoder_fast(uint64_t *A,
    }
  }
  memset((void*)out,0,polarParams->encoderLength>>3);
-  polar_rate_matching(polarParams,(void *)D,(void *)out);
+  polar_rate_matching(polarParams,(void *)D, out);
 }
@@ -40,9 +40,6 @@ int nr_phy_init_RU(RU_t *ru) {
  int p;
  int re;

-  // For memory allocation of ru->prach_rxsigF
-  int mu = fp->numerology_index;
-
  LOG_I(PHY,"Initializing RU signal buffers (if_south %s) nb_tx %d\n",ru_if_types[ru->if_south],ru->nb_tx);

  nfapi_nr_config_request_scf_t *cfg;
@@ -34,6 +34,8 @@ void nr_modulation(uint32_t *in,
  offset = (mod_order==2)? NR_MOD_TABLE_QPSK_OFFSET : (mod_order==4)? NR_MOD_TABLE_QAM16_OFFSET : \
                    (mod_order==6)? NR_MOD_TABLE_QAM64_OFFSET: (mod_order==8)? NR_MOD_TABLE_QAM256_OFFSET : 0;

+  LOG_D(PHY,"nr_modulation: length %d, mod_order %d\n",length,mod_order);
+
  for (int i=0; i<length/mod_order; i++)
  {
    idx = 0;
@@ -204,8 +204,8 @@ int nr_pusch_channel_estimation(PHY_VARS_gNB *gNB,
        ch[1] = (int16_t)(((int32_t)pil[0]*rxF[1] + (int32_t)pil[1]*rxF[0])>>15);

  #ifdef DEBUG_PUSCH
-        printf("pilot %d : rxF - > (%d,%d) ch -> (%d,%d), pil -> (%d,%d) \n",pilot_cnt,rxF[0],rxF[1],ch[0],ch[1],pil[0],pil[1]);
-	printf("data %d : rxF - > (%d,%d)\n",pilot_cnt,rxF[2],rxF[3]);
+        printf("pilot %u : rxF - > (%d,%d) ch -> (%d,%d), pil -> (%d,%d) \n",pilot_cnt,rxF[0],rxF[1],ch[0],ch[1],pil[0],pil[1]);
+	printf("data %u : rxF - > (%d,%d)\n",pilot_cnt,rxF[2],rxF[3]);
  #endif
        multadd_real_vector_complex_scalar(fml,
                                           ch,
@@ -221,7 +221,7 @@ int nr_pusch_channel_estimation(PHY_VARS_gNB *gNB,

  #ifdef DEBUG_PUSCH
        printf("pilot %u : rxF - > (%d,%d) ch -> (%d,%d), pil -> (%d,%d) \n",pilot_cnt+1,rxF[0],rxF[1],ch[0],ch[1],pil[0],pil[1]);
-	printf("data %d : rxF - > (%d,%d)\n",pilot_cnt+1,rxF[2],rxF[3]);
+	printf("data %u : rxF - > (%d,%d)\n",pilot_cnt+1,rxF[2],rxF[3]);
  #endif
        multadd_real_vector_complex_scalar(fmm,
                                           ch,
@@ -243,7 +243,7 @@ int nr_pusch_channel_estimation(PHY_VARS_gNB *gNB,
      ch[1] = (int16_t)(((int32_t)pil[0]*rxF[1] + (int32_t)pil[1]*rxF[0])>>15);
 #ifdef DEBUG_PUSCH
      printf("pilot %u : rxF - > (%d,%d) ch -> (%d,%d), pil -> (%d,%d) \n",pilot_cnt,rxF[0],rxF[1],ch[0],ch[1],pil[0],pil[1]);
-      printf("data %d : rxF - > (%d,%d)\n",pilot_cnt,rxF[2],rxF[3]);
+      printf("data %u : rxF - > (%d,%d)\n",pilot_cnt,rxF[2],rxF[3]);
 #endif
      multadd_real_vector_complex_scalar(fm,
                                         ch,
@@ -262,7 +262,7 @@ int nr_pusch_channel_estimation(PHY_VARS_gNB *gNB,
 #ifdef DEBUG_PUSCH
      printf("ch 0 %d\n",((int32_t)pil[0]*rxF[0] - (int32_t)pil[1]*rxF[1]));
      printf("pilot %u: rxF - > (%d,%d) addr %p  ch -> (%d,%d), pil -> (%d,%d) \n",pilot_cnt+1,rxF[0],rxF[1],&rxF[0],ch[0],ch[1],pil[0],pil[1]);
-      printf("data %d : rxF - > (%d,%d)\n",pilot_cnt+1,rxF[2],rxF[3]);
+      printf("data %u : rxF - > (%d,%d)\n",pilot_cnt+1,rxF[2],rxF[3]);
 #endif
      multadd_real_vector_complex_scalar(fmr,
                                         ch,
@@ -278,7 +278,7 @@ int nr_pusch_channel_estimation(PHY_VARS_gNB *gNB,
      ch[1] = (int16_t)(((int32_t)pil[0]*rxF[1] + (int32_t)pil[1]*rxF[0])>>15);
 #ifdef DEBUG_PUSCH
      printf("pilot %u: rxF - > (%d,%d) ch -> (%d,%d), pil -> (%d,%d) \n",pilot_cnt+2,rxF[0],rxF[1],ch[0],ch[1],pil[0],pil[1]);
-      printf("data %d : rxF - > (%d,%d)\n",pilot_cnt+2,rxF[2],rxF[3]);
+      printf("data %u : rxF - > (%d,%d)\n",pilot_cnt+2,rxF[2],rxF[3]);
 #endif
      multadd_real_vector_complex_scalar(fr,
                                         ch,
@@ -238,7 +238,7 @@ uint8_t nr_generate_dci_top(nfapi_nr_dl_tti_pdcch_pdu *pdcch_pdu,
 						   pdcch_pdu_rel15->dci_pdu.PayloadSizeBits[d], 
 						   pdcch_pdu_rel15->dci_pdu.AggregationLevel[d],
 						   0,NULL);
-    polar_encoder_fast((uint64_t*)pdcch_pdu_rel15->dci_pdu.Payload[d], encoder_output, n_RNTI,1,currentPtr);
+    polar_encoder_fast((uint64_t*)pdcch_pdu_rel15->dci_pdu.Payload[d], (void*)encoder_output, n_RNTI,1,currentPtr);
 #ifdef DEBUG_CHANNEL_CODING
    printf("polar rnti %x,length %d, L %d\n",n_RNTI, pdcch_pdu_rel15->dci_pdu.PayloadSizeBits[d],pdcch_pdu_rel15->dci_pdu.AggregationLevel[d]);
    printf("DCI PDU: [0]->0x%lx \t [1]->0x%lx\n",
@@ -35,6 +35,7 @@
 #include "nr_sch_dmrs.h"
 #include "PHY/MODULATION/nr_modulation.h"
 #include "PHY/NR_REFSIG/dmrs_nr.h"
+#include "common/utils/LOG/vcd_signal_dumper.h"

 //#define DEBUG_DLSCH
 //#define DEBUG_DLSCH_MAPPING
@@ -48,7 +49,7 @@ void nr_pdsch_codeword_scrambling(uint8_t *in,

  uint8_t reset, b_idx;
  uint32_t x1, x2, s=0;
-
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_gNB_PDSCH_CODEWORD_SCRAMBLING, 1);
  reset = 1;
  x2 = (n_RNTI<<15) + (q<<14) + Nid;

@@ -63,7 +64,7 @@ void nr_pdsch_codeword_scrambling(uint8_t *in,
    *out ^= (((in[i])&1) ^ ((s>>b_idx)&1))<<b_idx;
    //printf("i %d b_idx %d in %d s 0x%08x out 0x%08x\n", i, b_idx, in[i], s, *out);
  }
-
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_gNB_PDSCH_CODEWORD_SCRAMBLING, 0);
 }

 void nr_pdsch_codeword_scrambling_optim(uint8_t *in,
@@ -201,11 +202,13 @@ uint8_t nr_generate_pdsch(NR_gNB_DLSCH_t *dlsch,
 
  /// Modulation
  start_meas(dlsch_modulation_stats);
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_gNB_PDSCH_MODULATION, 1);
  for (int q=0; q<rel15->NrOfCodewords; q++)
    nr_modulation(scrambled_output[q],
                         encoded_length,
                         Qm,
                         mod_symbs[q]);
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_gNB_PDSCH_MODULATION, 0);
  stop_meas(dlsch_modulation_stats);
 #ifdef DEBUG_DLSCH
  printf("PDSCH Modulation: Qm %d(%d)\n", Qm, nb_re);
@@ -347,7 +347,7 @@ int nr_dlsch_encoding(unsigned char *a,
  float Coderate = 0.0;
  uint8_t Nl = 4;

-  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_DLSCH_ENCODING, VCD_FUNCTION_IN);
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_gNB_DLSCH_ENCODING, VCD_FUNCTION_IN);

  A = rel15->TBSize[0]<<3;

@@ -539,7 +539,7 @@ int nr_dlsch_encoding(unsigned char *a,
    r_offset += E;
  }

-  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_DLSCH_ENCODING, VCD_FUNCTION_OUT);
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_gNB_DLSCH_ENCODING, VCD_FUNCTION_OUT);

  return 0;
 }
@@ -297,7 +297,7 @@ int nr_generate_pbch(NR_gNB_PBCH *pbch,
    a_reversed |= (((uint64_t)pbch->pbch_a_prime>>i)&1)<<(31-i);

  /// CRC, coding and rate matching
-  polar_encoder_fast (&a_reversed, (uint32_t *)pbch->pbch_e, 0, 0,
+  polar_encoder_fast (&a_reversed, (void*)pbch->pbch_e, 0, 0,
                      nr_polar_params( NR_POLAR_PBCH_MESSAGE_TYPE, NR_POLAR_PBCH_PAYLOAD_BITS, NR_POLAR_PBCH_AGGREGATION_LEVEL,0,NULL)
                     );
 #ifdef DEBUG_PBCH_ENCODING
@@ -752,8 +752,7 @@ void rx_nr_prach(PHY_VARS_gNB *gNB,
    // check energy in nth time shift, for 

    preamble_shift2 = ((preamble_shift==0) ? 0 : ((preamble_shift<<log2_ifft_size)/N_ZC));
-    
-    
+
    for (i=0; i<NCS2; i++) {
      lev = (int32_t)prach_ifft[(preamble_shift2+i)];
      levdB = dB_fixed_times10(lev);
@@ -792,7 +791,7 @@ void rx_nr_prach(PHY_VARS_gNB *gNB,


  if (LOG_DUMPFLAG(PRACH)) {
-    int en = dB_fixed(signal_energy((int32_t*)&rxsigF[0][0],840));  
+    //int en = dB_fixed(signal_energy((int32_t*)&rxsigF[0][0],840));
    //    if (en>60) {
      int k = (12*n_ra_prb) - 6*fp->N_RB_UL;
      
@@ -139,7 +139,7 @@ void compute_nr_prach_seq(uint8_t short_sequence,
    }

    u = prach_root_sequence_map[index];
-
+    LOG_D(PHY,"prach index %d => u=%d\n",index,u);
    inv_u = nr_ZC_inv[u]; // multiplicative inverse of u


@@ -357,6 +357,8 @@ uint32_t nr_ulsch_decoding(PHY_VARS_gNB *phy_vars_gNB,
  }

  // harq_process->trials[nfapi_ulsch_pdu_rel15->round]++;
+
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_gNB_ULSCH_DECODING,1);
  harq_process->TBS = pusch_pdu->pusch_data.tb_size;

  A   = (harq_process->TBS)<<3;
@@ -527,7 +529,7 @@ uint32_t nr_ulsch_decoding(PHY_VARS_gNB *phy_vars_gNB,
 #ifdef DEBUG_ULSCH_DECODING
    if (r==0) {
      write_output("decoder_llr.m","decllr",ulsch_llr,G,1,0);
-      write_output("decoder_in.m","dec",&harq_process->d[0][0],(3*8*Kr_bytes)+12,1,0);
+      write_output("decoder_in.m","dec",&harq_process->d[0][0],E,1,0);
    }

    printf("decoder input(segment %u) :", r);
@@ -608,7 +610,6 @@ uint32_t nr_ulsch_decoding(PHY_VARS_gNB *phy_vars_gNB,
  #endif
        ret = ulsch->max_ldpc_iterations + 1;
      }
-
      nb_total_decod++;

      if (no_iteration_ldpc > ulsch->max_ldpc_iterations){
@@ -722,6 +723,6 @@ uint32_t nr_ulsch_decoding(PHY_VARS_gNB *phy_vars_gNB,
 #endif

  ulsch->last_iteration_cnt = ret;
-
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_gNB_ULSCH_DECODING,0);
  return(ret);
 }
@@ -38,6 +38,7 @@
 #include "PHY/NR_UE_ESTIMATION/nr_estimation.h"
 //#include "SCHED/defs.h"
 //#include "SCHED/extern.h"
+#include "common/utils/LOG/vcd_signal_dumper.h"

 #include "common_lib.h"
 #include <math.h>
@@ -213,6 +214,9 @@ int nr_initial_sync(UE_nr_rxtx_proc_t *proc, PHY_VARS_NR_UE *ue, runmode_t mode,
  NR_DL_FRAME_PARMS *fp = &ue->frame_parms;
  int ret=-1;
  int rx_power=0; //aarx,
+  
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_NR_INITIAL_UE_SYNC, VCD_FUNCTION_IN);
+

  LOG_D(PHY,"nr_initial sync ue RB_DL %d\n", fp->N_RB_DL);

@@ -477,6 +481,7 @@ int nr_initial_sync(UE_nr_rxtx_proc_t *proc, PHY_VARS_NR_UE *ue, runmode_t mode,
  }

  //  exit_fun("debug exit");
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_NR_INITIAL_UE_SYNC, VCD_FUNCTION_OUT);
  return ret;
 }

@@ -262,8 +262,7 @@ int nr_ulsch_encoding(NR_UE_ULSCH_t *ulsch,
 ///////////
 /////////////////////////////////////////////////////////////////////////////////////////  

-
-  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_DLSCH_ENCODING, VCD_FUNCTION_IN);
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_NR_UE_ULSCH_ENCODING, VCD_FUNCTION_IN);

  LOG_D(PHY,"ulsch coding nb_rb %d, Nl = %d\n", nb_rb, harq_process->pusch_pdu.nrOfLayers);
  LOG_D(PHY,"ulsch coding A %d G %d mod_order %d\n", A,G, mod_order);
@@ -331,6 +330,7 @@ int nr_ulsch_encoding(NR_UE_ULSCH_t *ulsch,
      BG = 1;
    }

+    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_NR_SEGMENTATION, VCD_FUNCTION_IN);
    Kb=nr_segmentation(harq_process->b,
                       harq_process->c,
                       harq_process->B,
@@ -339,6 +339,7 @@ int nr_ulsch_encoding(NR_UE_ULSCH_t *ulsch,
                       pz,
                       &harq_process->F,
                       BG);
+    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_NR_SEGMENTATION, VCD_FUNCTION_OUT);

    F = harq_process->F;
    Kr = harq_process->K;
@@ -389,7 +390,11 @@ int nr_ulsch_encoding(NR_UE_ULSCH_t *ulsch,
    impp.n_segments=harq_process->C;
    impp.macro_num=0;

+    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_LDPC_ENCODER_OPTIM, VCD_FUNCTION_IN);
+    
    nrLDPC_encoder(harq_process->c,harq_process->d,*pz,Kb,Kr,BG,&impp);
+    
+    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_LDPC_ENCODER_OPTIM, VCD_FUNCTION_OUT);

    //stop_meas(te_stats);
    //printf("end ldpc encoder -- output\n");
@@ -435,6 +440,7 @@ int nr_ulsch_encoding(NR_UE_ULSCH_t *ulsch,

    Tbslbrm = nr_compute_tbslbrm(0,nb_rb,harq_process->pusch_pdu.nrOfLayers,harq_process->C);

+    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_NR_RATE_MATCHING_LDPC, VCD_FUNCTION_IN);
    nr_rate_matching_ldpc(Ilbrm,
                          Tbslbrm,
                          BG,
@@ -446,6 +452,7 @@ int nr_ulsch_encoding(NR_UE_ULSCH_t *ulsch,
                          Kr-F-2*(*pz),
                          harq_process->pusch_pdu.pusch_data.rv_index,
                          E);
+    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_NR_RATE_MATCHING_LDPC, VCD_FUNCTION_OUT);



@@ -464,10 +471,14 @@ int nr_ulsch_encoding(NR_UE_ULSCH_t *ulsch,
    //stop_meas(rm_stats);

    //start_meas(i_stats);
-  nr_interleaving_ldpc(E,
+    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_NR_INTERLEAVING_LDPC, VCD_FUNCTION_IN);
+    
+    nr_interleaving_ldpc(E,
            mod_order,
            harq_process->e+r_offset,
            harq_process->f+r_offset);
+    
+    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_NR_INTERLEAVING_LDPC, VCD_FUNCTION_OUT);
    //stop_meas(i_stats);


@@ -488,7 +499,7 @@ int nr_ulsch_encoding(NR_UE_ULSCH_t *ulsch,

  memcpy(ulsch->g,harq_process->f,G); // g is the concatenated code block

-  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_DLSCH_ENCODING, VCD_FUNCTION_OUT);
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_NR_UE_ULSCH_ENCODING, VCD_FUNCTION_OUT);

  return(0);
 }
@@ -98,6 +98,8 @@ void nr_ue_ulsch_procedures(PHY_VARS_NR_UE *UE,
                               uint8_t thread_id,
                               int gNB_id) {

+  LOG_D(PHY,"nr_ue_ulsch_procedures hard_id %d %d.%d\n",harq_pid,frame,slot);
+
  uint32_t available_bits, TBS;
  uint8_t mod_order, cwd_index, num_of_codewords, l;
  uint32_t scrambled_output[NR_MAX_NB_CODEWORDS][NR_MAX_PDSCH_ENCODED_LENGTH>>5];
@@ -38,6 +38,7 @@
 #include "PHY/defs_nr_UE.h"

 #include "PHY/NR_REFSIG/ss_pbch_nr.h"
+#include "common/utils/LOG/vcd_signal_dumper.h"

 #define DEFINE_VARIABLES_PSS_NR_H
 #include "PHY/NR_REFSIG/pss_nr.h"
@@ -672,6 +673,7 @@ int pss_synchro_nr(PHY_VARS_NR_UE *PHY_vars_UE, int is, int rate_change)
  int **rxdata = NULL;
  int fo_flag = PHY_vars_UE->UE_fo_compensation;  // flag to enable freq offset estimation and compensation

+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PSS_SYNCHRO_NR, VCD_FUNCTION_IN);
 #ifdef DBG_PSS_NR

  LOG_M("rxdata0_rand.m","rxd0_rand", &PHY_vars_UE->common_vars.rxdata[0][0], frame_parms->samples_per_frame, 1, 1);
@@ -710,6 +712,7 @@ int pss_synchro_nr(PHY_VARS_NR_UE *PHY_vars_UE, int is, int rate_change)

 #endif

+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PSS_SEARCH_TIME_NR, VCD_FUNCTION_IN);
  synchro_position = pss_search_time_nr(rxdata,
                                        frame_parms,
 					fo_flag,
@@ -717,6 +720,7 @@ int pss_synchro_nr(PHY_VARS_NR_UE *PHY_vars_UE, int is, int rate_change)
                                        (int *)&PHY_vars_UE->common_vars.eNb_id,
 					(int *)&PHY_vars_UE->common_vars.freq_offset);

+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PSS_SEARCH_TIME_NR, VCD_FUNCTION_OUT);

 #if TEST_SYNCHRO_TIMING_PSS

@@ -749,6 +753,7 @@ int pss_synchro_nr(PHY_VARS_NR_UE *PHY_vars_UE, int is, int rate_change)
  }
 #endif

+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PSS_SYNCHRO_NR, VCD_FUNCTION_OUT);
  return synchro_position;
 }

@@ -963,7 +963,7 @@ void nr_generate_pucch2(PHY_VARS_NR_UE *ue,
  uint64_t b[16]; // limit to 1024-bit encoded length
  // M_bit is the number of bits of block b (payload after encoding)
  uint16_t M_bit;
-  nr_uci_encoding(payload,nr_bit,pucch_format2_nr,0,nrofSymbols,nrofPRB,1,0,0,&b,&M_bit);
+  nr_uci_encoding(payload,nr_bit,pucch_format2_nr,0,nrofSymbols,nrofPRB,1,0,0,(void*)b,&M_bit);
  /*
   * Implementing TS 38.211
   * Subclauses 6.3.2.5.1 Scrambling (PUCCH format 2)
@@ -1129,7 +1129,7 @@ void nr_generate_pucch3_4(PHY_VARS_NR_UE *ue,
  printf("\t [nr_generate_pucch3_4] start function at slot(nr_tti_tx)=%d with payload=%lu and nr_bit=%d\n", nr_tti_tx, payload, nr_bit);
 #endif
  // b is the block of bits transmitted on the physical channel after payload coding
-  uint64_t b;
+  uint64_t b[16];
  // M_bit is the number of bits of block b (payload after encoding)
  uint16_t M_bit;
  // parameter PUCCH-F4-preDFT-OCC-length set of {2,4} -> to use table -1 or -2
@@ -1154,7 +1154,7 @@ void nr_generate_pucch3_4(PHY_VARS_NR_UE *ue,
  //nrofPRB = 2; // only for test purposes
  if (fmt == pucch_format4_nr) nrofPRB = 1;

-  nr_uci_encoding(payload,nr_bit,fmt,is_pi_over_2_bpsk_enabled,nrofSymbols,nrofPRB,n_SF_PUCCH_s,intraSlotFrequencyHopping,add_dmrs,&b,&M_bit);
+  nr_uci_encoding(payload,nr_bit,fmt,is_pi_over_2_bpsk_enabled,nrofSymbols,nrofPRB,n_SF_PUCCH_s,intraSlotFrequencyHopping,add_dmrs,(void*)b,&M_bit);
  /*
   * Implementing TS 38.211
   * Subclauses 6.3.2.6.1 Scrambling (PUCCH formats 3 and 4)
@@ -1211,6 +1211,8 @@ void postDecode(L1_rxtx_proc_t *proc, notifiedFIFO_elt_t *req) {
      }
 	
      if (!decodeSucess) {
+        T(T_ENB_PHY_ULSCH_UE_NACK, T_INT(eNB->Mod_id), T_INT(rdata->frame), T_INT(rdata->subframe), T_INT(ulsch->rnti),
+          T_INT(rdata->harq_pid));
 	fill_crc_indication(eNB,i,rdata->frame,rdata->subframe,1); // indicate NAK to MAC
 	fill_rx_indication(eNB,i,rdata->frame,rdata->subframe);  // indicate SDU to MAC
 	LOG_D(PHY,"[eNB %d][PUSCH %d] frame %d subframe %d UE %d Error receiving ULSCH, round %d/%d (ACK %d,%d)\n",
@@ -1239,6 +1241,8 @@ void postDecode(L1_rxtx_proc_t *proc, notifiedFIFO_elt_t *req) {
 	fill_rx_indication(eNB,i,rdata->frame,rdata->subframe);  // indicate SDU to MAC
 	ulsch_harq->status = SCH_IDLE;
 	ulsch->harq_mask &= ~(1 << rdata->harq_pid);
+        T (T_ENB_PHY_ULSCH_UE_ACK, T_INT(eNB->Mod_id), T_INT(rdata->frame), T_INT(rdata->subframe), T_INT(ulsch->rnti),
+           T_INT(rdata->harq_pid));
      }  // ulsch not in error
 	
      if (ulsch_harq->O_ACK>0)
@@ -144,7 +144,7 @@ void phy_procedures_gNB_TX(PHY_VARS_gNB *gNB,
  if ((cfg->cell_config.frame_duplex_type.value == TDD) &&
      (nr_slot_select(cfg,frame,slot) == NR_UPLINK_SLOT)) return;

-  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_ENB_TX+offset,1);
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_gNB_TX+offset,1);

  if (do_meas==1) start_meas(&gNB->phy_proc_tx);

@@ -153,12 +153,12 @@ void phy_procedures_gNB_TX(PHY_VARS_gNB *gNB,
    memset(&gNB->common_vars.txdataF[aa][txdataF_offset],0,fp->samples_per_slot_wCP*sizeof(int32_t));
  }

-  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_ENB_COMMON_TX,1);
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_gNB_COMMON_TX,1);
  if (nfapi_mode == 0 || nfapi_mode == 1) { 
    if ((!(frame%ssb_frame_periodicity)))  // generate SSB only for given frames according to SSB periodicity
      nr_common_signal_procedures(gNB,frame, slot);
  }
-  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_ENB_COMMON_TX,0);
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_gNB_COMMON_TX,0);


  if (gNB->pdcch_pdu || gNB->ul_dci_pdu) {
@@ -167,7 +167,7 @@ void phy_procedures_gNB_TX(PHY_VARS_gNB *gNB,
 	  gNB->ul_dci_pdu==NULL?0:gNB->ul_dci_pdu->pdcch_pdu.pdcch_pdu_rel15.numDlDci,
 	  gNB->pdcch_pdu==NULL?0:gNB->pdcch_pdu->pdcch_pdu_rel15.numDlDci);
  
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_ENB_PDCCH_TX,1);
+    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_gNB_PDCCH_TX,1);

    nr_generate_dci_top(gNB->pdcch_pdu,
 			gNB->ul_dci_pdu,
@@ -175,7 +175,7 @@ void phy_procedures_gNB_TX(PHY_VARS_gNB *gNB,
 			&gNB->common_vars.txdataF[0][txdataF_offset],
 			AMP, *fp);
  
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_ENB_PDCCH_TX,0);
+    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_gNB_PDCCH_TX,0);
  }
 
  for (int i=0; i<gNB->num_pdsch_rnti; i++) {
@@ -198,7 +198,7 @@ void phy_procedures_gNB_TX(PHY_VARS_gNB *gNB,
    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_GENERATE_DLSCH,0);
  }

-  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_ENB_TX+offset,0);
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_gNB_TX+offset,0);
 }


@@ -382,6 +382,7 @@ void phy_procedures_gNB_common_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx)

 void phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx) {

+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_gNB_UESPEC_RX,1);
  LOG_D(PHY,"phy_procedures_gNB_uespec_RX frame %d, slot %d\n",frame_rx,slot_rx);

  for (int i=0;i<NUMBER_OF_NR_PUCCH_MAX;i++){
@@ -430,12 +431,12 @@ void phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx)
        (ulsch->rnti > 0)) {
      // for for an active HARQ process
      for (harq_pid=0;harq_pid<NR_MAX_ULSCH_HARQ_PROCESSES;harq_pid++) {
-	ulsch_harq = ulsch->harq_processes[harq_pid];
-	AssertFatal(ulsch_harq!=NULL,"harq_pid %d is not allocated\n",harq_pid);
-	if ((ulsch_harq->status == NR_ACTIVE) &&
-	    (ulsch_harq->frame == frame_rx) &&
-	    (ulsch_harq->slot == slot_rx) &&
-	    (ulsch_harq->handled == 0)){
+	    ulsch_harq = ulsch->harq_processes[harq_pid];
+    	AssertFatal(ulsch_harq!=NULL,"harq_pid %d is not allocated\n",harq_pid);
+    	if ((ulsch_harq->status == NR_ACTIVE) &&
+          (ulsch_harq->frame == frame_rx) &&
+          (ulsch_harq->slot == slot_rx) &&
+          (ulsch_harq->handled == 0)){

 #ifdef DEBUG_RXDATA
          NR_DL_FRAME_PARMS *frame_parms = &gNB->frame_parms;
@@ -450,18 +451,22 @@ void phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx)
          fclose(f);
 #endif

-	  uint8_t symbol_start = ulsch_harq->ulsch_pdu.start_symbol_index;
-	  uint8_t symbol_end = symbol_start + ulsch_harq->ulsch_pdu.nr_of_symbols;
-	  for(uint8_t symbol = symbol_start; symbol < symbol_end; symbol++) {
-	    no_sig = nr_rx_pusch(gNB, ULSCH_id, frame_rx, slot_rx, symbol, harq_pid);
-            if (no_sig) return;
-	  }
-	  //LOG_M("rxdataF_comp.m","rxF_comp",gNB->pusch_vars[0]->rxdataF_comp[0],6900,1,1);
-	  //LOG_M("rxdataF_ext.m","rxF_ext",gNB->pusch_vars[0]->rxdataF_ext[0],6900,1,1);
-	  nr_ulsch_procedures(gNB, frame_rx, slot_rx, ULSCH_id, harq_pid);
-	  break;
-	}
+          uint8_t symbol_start = ulsch_harq->ulsch_pdu.start_symbol_index;
+          uint8_t symbol_end = symbol_start + ulsch_harq->ulsch_pdu.nr_of_symbols;
+          VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_NR_RX_PUSCH,1);
+          for(uint8_t symbol = symbol_start; symbol < symbol_end; symbol++) {
+            nr_rx_pusch(gNB, ULSCH_id, frame_rx, slot_rx, symbol, harq_pid);
+          }
+          VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_NR_RX_PUSCH,0);
+          //LOG_M("rxdataF_comp.m","rxF_comp",gNB->pusch_vars[0]->rxdataF_comp[0],6900,1,1);
+          //LOG_M("rxdataF_ext.m","rxF_ext",gNB->pusch_vars[0]->rxdataF_ext[0],6900,1,1);
+          VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_NR_ULSCH_PROCEDURES_RX,1);
+            nr_ulsch_procedures(gNB, frame_rx, slot_rx, ULSCH_id, harq_pid);
+          VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_NR_ULSCH_PROCEDURES_RX,0);
+          break;
+        }
      }
    }
  }
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_gNB_UESPEC_RX,0);
 }
@@ -57,7 +57,7 @@ int8_t nr_ue_scheduled_response(nr_scheduled_response_t *scheduled_response){
    NR_UE_PDCCH *pdcch_vars = PHY_vars_UE_g[module_id][cc_id]->pdcch_vars[thread_id][0];
    NR_UE_ULSCH_t *ulsch0 = PHY_vars_UE_g[module_id][cc_id]->ulsch[thread_id][0][0];
    NR_DL_FRAME_PARMS frame_parms = PHY_vars_UE_g[module_id][cc_id]->frame_parms;
-    PRACH_RESOURCES_t *prach_resources = PHY_vars_UE_g[module_id][cc_id]->prach_resources[0];
+    //PRACH_RESOURCES_t *prach_resources = PHY_vars_UE_g[module_id][cc_id]->prach_resources[0];
        
    //        PUCCH_ConfigCommon_nr_t    *pucch_config_common = PHY_vars_UE_g[module_id][cc_id]->pucch_config_common_nr[0];
    //        PUCCH_Config_t             *pucch_config_dedicated = PHY_vars_UE_g[module_id][cc_id]->pucch_config_dedicated_nr[0];
@@ -2249,13 +2249,13 @@ void phy_procedures_nrUE_TX(PHY_VARS_NR_UE *ue,
  } // UE_mode==PUSCH
 */

-    if (get_softmodem_params()->do_ra==1) {
+   if (get_softmodem_params()->usim_test==0) {
      LOG_D(PHY, "Sending PUCCH\n");
      pucch_procedures_ue_nr(ue,
                             gNB_id,
                             proc,
                             TRUE);
-    }
+   }

    LOG_D(PHY, "Sending data \n");
    nr_ue_pusch_common_procedures(ue,
@@ -2765,10 +2765,8 @@ int nr_ue_pdcch_procedures(uint8_t gNB_id,
 	 pdcch_vars->nb_search_space);
 #endif

-  fapi_nr_dci_indication_t dci_ind;
-  nr_downlink_indication_t dl_indication;
-  memset((void*)&dci_ind,0,sizeof(dci_ind));
-  memset((void*)&dl_indication,0,sizeof(dl_indication));
+  fapi_nr_dci_indication_t dci_ind={0};
+  nr_downlink_indication_t dl_indication={0};
  dci_cnt = nr_dci_decoding_procedure(ue,
 				      proc->frame_rx,
 				      nr_tti_rx,
@@ -3284,15 +3282,14 @@ void nr_ue_dlsch_procedures(PHY_VARS_NR_UE *ue,
       int *dlsch_errors,
       runmode_t mode) {

-  int harq_pid;
+  int harq_pid = dlsch0->current_harq_pid;
  int frame_rx = proc->frame_rx;
  int nr_tti_rx = proc->nr_tti_rx;
  int ret=0, ret1=0;
  NR_UE_PDSCH *pdsch_vars;
  uint8_t is_cw0_active = 0;
  uint8_t is_cw1_active = 0;
-  nfapi_nr_config_request_t *cfg = &ue->nrUE_config;
-  uint8_t dmrs_type = cfg->pdsch_config.PDSCHTimeDomainResourceAllocation_mappingType[0].value; // TODO: HARDCODED pdsch index
+  uint8_t dmrs_type = dlsch0->harq_processes[harq_pid]->dmrsConfigType;
  uint8_t nb_re_dmrs = (dmrs_type==NFAPI_NR_DMRS_TYPE1)?6:4; // TODO: should changed my mac
  uint16_t length_dmrs = 1; //cfg->pdsch_config.dmrs_max_length.value;
  uint16_t nb_symb_sch = 9;
@@ -3316,7 +3313,6 @@ void nr_ue_dlsch_procedures(PHY_VARS_NR_UE *ue,
  if (dlsch0==NULL)
    AssertFatal(0,"dlsch0 should be defined at this level \n");

-  harq_pid = dlsch0->current_harq_pid;
  is_cw0_active = dlsch0->harq_processes[harq_pid]->status;
  nb_symb_sch = dlsch0->harq_processes[harq_pid]->nb_symbols;
  start_symbol = dlsch0->harq_processes[harq_pid]->start_symbol;
@@ -3376,13 +3372,13 @@ void nr_ue_dlsch_procedures(PHY_VARS_NR_UE *ue,
    }


-      // start ldpc decode for CW 0
-      dlsch0->harq_processes[harq_pid]->G = nr_get_G(dlsch0->harq_processes[harq_pid]->nb_rb,
-						     nb_symb_sch,
-						     nb_re_dmrs,
-						     length_dmrs,
-						     dlsch0->harq_processes[harq_pid]->Qm,
-						     dlsch0->harq_processes[harq_pid]->Nl);
+    // start ldpc decode for CW 0
+    dlsch0->harq_processes[harq_pid]->G = nr_get_G(dlsch0->harq_processes[harq_pid]->nb_rb,
+                                                   nb_symb_sch,
+                                                   nb_re_dmrs,
+                                                   length_dmrs,
+                                                   dlsch0->harq_processes[harq_pid]->Qm,
+                                                   dlsch0->harq_processes[harq_pid]->Nl);
 #if UE_TIMING_TRACE
      start_meas(&ue->dlsch_unscrambling_stats);
 #endif
@@ -370,6 +370,7 @@ bool pucch_procedures_ue_nr(PHY_VARS_NR_UE *ue, uint8_t gNB_id, UE_nr_rxtx_proc_
      }

      m_0 = get_ics_pucch(pucch_resource, format);
+      AssertFatal(m_0 >= 0, "Invalid m_0\n");
      if (format == pucch_format3_nr) {
        if (mac->ULbwp[bwp_id-1]->bwp_Dedicated->pucch_Config->choice.setup->format3->choice.setup->additionalDMRS[0] == 1) {
          index_additional_dmrs = I_PUCCH_ADDITIONAL_DMRS;
@@ -699,7 +700,7 @@ uint8_t get_downlink_ack(PHY_VARS_NR_UE *ue, uint8_t gNB_id,  UE_nr_rxtx_proc_t
  int V_DAI_m_DL = 0;
  NR_UE_MAC_INST_t *mac = get_mac_inst(0);

-  if (mac->DLbwp[0] == NULL) return;
+  if (mac->DLbwp[0] == NULL) return 0;

  if (mac->DLbwp[0]->bwp_Dedicated->pdsch_Config->choice.setup->maxNrofCodeWordsScheduledByDCI[0] == 2) {
    two_transport_blocks = TRUE;
@@ -897,7 +898,7 @@ boolean_t select_pucch_resource(PHY_VARS_NR_UE *ue, NR_UE_MAC_INST_t *mac, uint8
    /* No resource set has been already configured so pucch_configCommon from Sib1 should be used in this case */

    if (ue->UE_mode[gNB_id] != PUSCH) {
-      *initial_pucch_id = mac->ULbwp[bwp_id-1]->bwp_Common->pucch_ConfigCommon->choice.setup->pucch_ResourceCommon;
+      *initial_pucch_id = mac->ULbwp[bwp_id-1]->bwp_Common->pucch_ConfigCommon->choice.setup->pucch_ResourceCommon[0];
      if (*initial_pucch_id >= NB_INITIAL_PUCCH_RESOURCE) {
        LOG_E(PHY,"PUCCH Invalid initial resource index : at line %d in function %s of file %s \n", LINE_FILE , __func__, FILE_NAME);
        *initial_pucch_id = NB_INITIAL_PUCCH_RESOURCE;
@@ -1049,6 +1050,7 @@ boolean_t select_pucch_resource(PHY_VARS_NR_UE *ue, NR_UE_MAC_INST_t *mac, uint8
 int find_pucch_resource_set(NR_UE_MAC_INST_t *mac, uint8_t gNB_id, int uci_size)
 {
  int pucch_resource_set_id = 0;
+  long *pucch_max_pl_bits = NULL;

  /* from TS 38.331 field maxPayloadMinus1
    -- Maximum number of payload bits minus 1 that the UE may transmit using this PUCCH resource set. In a PUCCH occurrence, the UE
@@ -1060,7 +1062,8 @@ int find_pucch_resource_set(NR_UE_MAC_INST_t *mac, uint8_t gNB_id, int uci_size)
  /* look for the first resource set which supports uci_size number of bits for payload */
  while (pucch_resource_set_id < MAX_NB_OF_PUCCH_RESOURCE_SETS) {
    if (mac->ULbwp[bwp_id-1]->bwp_Dedicated->pucch_Config->choice.setup->resourceSetToAddModList->list.array[pucch_resource_set_id] != NULL) {
-      if (uci_size <= mac->ULbwp[bwp_id-1]->bwp_Dedicated->pucch_Config->choice.setup->resourceSetToAddModList->list.array[pucch_resource_set_id]->maxPayloadMinus1 + 1) {
+      pucch_max_pl_bits = mac->ULbwp[bwp_id-1]->bwp_Dedicated->pucch_Config->choice.setup->resourceSetToAddModList->list.array[pucch_resource_set_id]->maxPayloadMinus1;
+      if (uci_size <= (((pucch_max_pl_bits != NULL) ? *pucch_max_pl_bits : 1706) + 1)) {
        NR_TST_PHY_PRINTF("PUCCH found resource set %d \n",  pucch_resource_set_id);
        return (pucch_resource_set_id);
        break;
@@ -1093,35 +1096,36 @@ boolean_t check_pucch_format(NR_UE_MAC_INST_t *mac, uint8_t gNB_id, pucch_format
 {
  pucch_format_nr_t selected_pucch_format;
  pucch_format_nr_t selected_pucch_format_second;
-  NR_SetupRelease_PUCCH_FormatConfig_t *identified_format;
+  NR_SetupRelease_PUCCH_FormatConfig_t *identified_format = NULL;

-  if (format_pucch != pucch_format0_nr) {
-    switch (format_pucch) {
-      case pucch_format1_nr:
-      if (mac->ULbwp[bwp_id-1]->bwp_Dedicated->pucch_Config->choice.setup->format1 != NULL)
-        identified_format = mac->ULbwp[bwp_id-1]->bwp_Dedicated->pucch_Config->choice.setup->format1;
-      break;
+  switch (format_pucch) {
+    case pucch_format1_nr:
+    if (mac->ULbwp[bwp_id-1]->bwp_Dedicated->pucch_Config->choice.setup->format1 != NULL)
+      identified_format = mac->ULbwp[bwp_id-1]->bwp_Dedicated->pucch_Config->choice.setup->format1;
+    break;

-      case pucch_format2_nr:
-      if (mac->ULbwp[bwp_id-1]->bwp_Dedicated->pucch_Config->choice.setup->format2 != NULL)
-        identified_format = mac->ULbwp[bwp_id-1]->bwp_Dedicated->pucch_Config->choice.setup->format2;
-      break;
+    case pucch_format2_nr:
+    if (mac->ULbwp[bwp_id-1]->bwp_Dedicated->pucch_Config->choice.setup->format2 != NULL)
+      identified_format = mac->ULbwp[bwp_id-1]->bwp_Dedicated->pucch_Config->choice.setup->format2;
+    break;

-      case pucch_format3_nr:
-      if (mac->ULbwp[bwp_id-1]->bwp_Dedicated->pucch_Config->choice.setup->format3 != NULL)
-        identified_format = mac->ULbwp[bwp_id-1]->bwp_Dedicated->pucch_Config->choice.setup->format3;
-      break;
+    case pucch_format3_nr:
+    if (mac->ULbwp[bwp_id-1]->bwp_Dedicated->pucch_Config->choice.setup->format3 != NULL)
+      identified_format = mac->ULbwp[bwp_id-1]->bwp_Dedicated->pucch_Config->choice.setup->format3;
+    break;

-      case pucch_format4_nr:
-      if (mac->ULbwp[bwp_id-1]->bwp_Dedicated->pucch_Config->choice.setup->format4 != NULL)
-        identified_format = mac->ULbwp[bwp_id-1]->bwp_Dedicated->pucch_Config->choice.setup->format4;
-      break;
-    }
+    case pucch_format4_nr:
+    if (mac->ULbwp[bwp_id-1]->bwp_Dedicated->pucch_Config->choice.setup->format4 != NULL)
+      identified_format = mac->ULbwp[bwp_id-1]->bwp_Dedicated->pucch_Config->choice.setup->format4;
+    break;

-    if (identified_format->choice.setup->nrofSlots != 1) {
-      LOG_E(PHY,"PUCCH not implemented multislots transmission : at line %d in function %s of file %s \n", LINE_FILE , __func__, FILE_NAME);
-      return (FALSE);
-    }
+    default:
+    break;
+  }
+
+  if ((identified_format != NULL) && (identified_format->choice.setup->nrofSlots[0] != 1)) {
+    LOG_E(PHY,"PUCCH not implemented multislots transmission : at line %d in function %s of file %s \n", LINE_FILE , __func__, FILE_NAME);
+    return (FALSE);
  }

  if (nb_symbols_for_tx <= 2) {
@@ -1290,6 +1294,7 @@ uint8_t get_nb_symbols_pucch(NR_PUCCH_Resource_t *pucch_resource, pucch_format_n
    case pucch_format4_nr:
      return pucch_resource->format.choice.format4->nrofSymbols;
  }
+  return 0;
 }

 uint16_t get_starting_symb_idx(NR_PUCCH_Resource_t *pucch_resource, pucch_format_nr_t format_type)
@@ -1310,6 +1315,7 @@ uint16_t get_starting_symb_idx(NR_PUCCH_Resource_t *pucch_resource, pucch_format
    case pucch_format4_nr:
      return pucch_resource->format.choice.format4->startingSymbolIndex;
  }
+  return 0;
 }

 int get_ics_pucch(NR_PUCCH_Resource_t *pucch_resource, pucch_format_nr_t format_type)
@@ -1320,7 +1326,11 @@ int get_ics_pucch(NR_PUCCH_Resource_t *pucch_resource, pucch_format_nr_t format_

    case pucch_format1_nr:
      return pucch_resource->format.choice.format1->initialCyclicShift;
+
+    default:
+      return -1;
  }
+  return -1;
 }

 NR_PUCCH_Resource_t *select_resource_by_id(int resource_id, NR_PUCCH_Config_t *pucch_config)
@@ -139,7 +139,7 @@ int main(int argc, char **argv)
  uint8_t snr1set=0;
  float roundStats[50];
  float effRate;
-  float psnr;
+  //float psnr;
  float eff_tp_check = 0.7;
  uint8_t snrRun;
  uint32_t TBS;
@@ -696,7 +696,7 @@ int main(int argc, char **argv)

  nr_ue_phy_config_request(&UE_mac->phy_config);
  NR_UE_list_t *UE_list = &RC.nrmac[0]->UE_list;
-  NR_COMMON_channels_t *cc = RC.nrmac[0]->common_channels;
+  //NR_COMMON_channels_t *cc = RC.nrmac[0]->common_channels;
  snrRun = 0;

  for (SNR = snr0; SNR < snr1; SNR += .2) {
@@ -924,7 +924,7 @@ int main(int argc, char **argv)
           (float) n_errors / (float) n_trials);
    printf("*****************************************\n");
    printf("\n");
-    printf("SNR %f : n_errors (negative CRC) = %d/%d, Avg round %.2f, Channel BER %e, Eff Rate %.4f bits/slot, Eff Throughput %.2f\%, TBS %d bits/slot\n", SNR, n_errors, n_trials,roundStats[snrRun],(double)errors_scrambling/available_bits/n_trials,effRate,effRate/TBS*100,TBS);
+    printf("SNR %f : n_errors (negative CRC) = %d/%d, Avg round %.2f, Channel BER %e, Eff Rate %.4f bits/slot, Eff Throughput %.2f, TBS %d bits/slot\n", SNR, n_errors, n_trials,roundStats[snrRun],(double)errors_scrambling/available_bits/n_trials,effRate,effRate/TBS*100,TBS);
    printf("\n");

    if (n_trials == 1) {
@@ -339,6 +339,8 @@ int main(int argc, char **argv){

  
  if (config_index<67)  { prach_sequence_length=0; slot = subframe*2; slot_gNB = 1+(subframe*2); }
+  uint16_t N_ZC;
+  N_ZC = prach_sequence_length == 0 ? 839 : 139;

  printf("Config_index %d, prach_sequence_length %d\n",config_index,prach_sequence_length);

@@ -485,8 +487,8 @@ int main(int argc, char **argv){
  prach_config->num_prach_fd_occasions_list[fd_occasion].k1.value                        = msg1_frequencystart;
  prach_config->restricted_set_config.value                                              = restrictedSetConfig;
  prach_config->prach_sequence_length.value                                              = prach_sequence_length;
-  prach_config->num_prach_fd_occasions_list[fd_occasion].num_root_sequences.value        = num_root_sequences;
  prach_pdu->num_cs                                                                      = get_NCS(NCS_config, format0, restrictedSetConfig);
+  prach_config->num_prach_fd_occasions_list[fd_occasion].num_root_sequences.value        = 1+(64/(N_ZC/prach_pdu->num_cs));
  prach_pdu->prach_format                                                                = prach_format;

  memcpy((void*)&ru->config,(void*)&RC.gNB[0]->gNB_config,sizeof(ru->config));
@@ -525,7 +527,7 @@ int main(int argc, char **argv){
  ue_prach_config->prach_sub_c_spacing                                                = mu;
  ue_prach_config->prach_sequence_length                                              = prach_sequence_length;
  ue_prach_config->restricted_set_config                                              = restrictedSetConfig;
-  ue_prach_config->num_prach_fd_occasions_list[fd_occasion].num_root_sequences        = num_root_sequences;
+  ue_prach_config->num_prach_fd_occasions_list[fd_occasion].num_root_sequences        = prach_config->num_prach_fd_occasions_list[fd_occasion].num_root_sequences.value ;
  ue_prach_config->num_prach_fd_occasions_list[fd_occasion].prach_root_sequence_index = rootSequenceIndex;
  ue_prach_config->num_prach_fd_occasions_list[fd_occasion].k1                        = msg1_frequencystart;

@@ -601,13 +603,10 @@ int main(int argc, char **argv){
  /* tx_lev_dB not used later, no need to set */
  //tx_lev_dB = (unsigned int) dB_fixed(tx_lev);

-  samp_count=0;
-  for (int s=0; s<slot; s++) samp_count+=frame_parms->get_samples_per_slot(s,frame_parms);
-  
-  prach_start = samp_count - UE->N_TA_offset;
+  prach_start = subframe*frame_parms->samples_per_subframe-UE->N_TA_offset;

  #ifdef NR_PRACH_DEBUG
-  LOG_M("txsig0.m", "txs0", &txdata[0][prach_start], frame_parms->samples_per_subframe, 1, 1);
+  LOG_M("txsig0.m", "txs0", &txdata[0][subframe*frame_parms->samples_per_subframe], frame_parms->samples_per_subframe, 1, 1);
    LOG_M("txsig0_frame.m","txs0", txdata[0],frame_parms->samples_per_frame,1,1);
  #endif

@@ -651,8 +650,8 @@ int main(int argc, char **argv){

  rx_prach_start = subframe*frame_parms->samples_per_subframe;
  if (n_frames==1) printf("slot %d, rx_prach_start %d\n",slot,rx_prach_start);
-  uint16_t preamble_rx, preamble_energy, N_ZC;
-  N_ZC = prach_sequence_length == 0 ? 839 : 139;
+  uint16_t preamble_rx, preamble_energy;
+

  for (SNR=snr0; SNR<snr1; SNR+=.1) {
    for (ue_speed=ue_speed0; ue_speed<ue_speed1; ue_speed+=10) {
@@ -703,7 +702,7 @@ int main(int argc, char **argv){
        rx_nr_prach_ru(ru, prach_format, numRA, prachStartSymbol, frame, slot);

        gNB->prach_vars.rxsigF = ru->prach_rxsigF;
-
+	if (n_frames == 1) printf("ncs %d,num_seq %d\n",prach_pdu->num_cs,  prach_config->num_prach_fd_occasions_list[fd_occasion].num_root_sequences.value);
        rx_nr_prach(gNB, prach_pdu, frame, subframe, &preamble_rx, &preamble_energy, &preamble_delay);

 	//        printf(" preamble_energy %d preamble_rx %d preamble_tx %d \n", preamble_energy, preamble_rx, preamble_tx);
@@ -720,8 +719,8 @@ int main(int argc, char **argv){
          #ifdef NR_PRACH_DEBUG
 	  LOG_M("prach0.m","prach0", &txdata[0][prach_start], frame_parms->samples_per_subframe, 1, 1);
            LOG_M("prachF0.m","prachF0", &gNB->prach_vars.prachF[0], N_ZC, 1, 1);
-            LOG_M("rxsig0.m","rxs0", &gNB->common_vars.rxdata[0][rx_prach_start], frame_parms->samples_per_subframe, 1, 1);
-            LOG_M("ru_rxsig0.m","rxs0", &ru->common.rxdata[0][rx_prach_start], frame_parms->samples_per_subframe, 1, 1);
+            LOG_M("rxsig0.m","rxs0", &gNB->common_vars.rxdata[0][subframe*frame_parms->samples_per_subframe], frame_parms->samples_per_subframe, 1, 1);
+            LOG_M("ru_rxsig0.m","rxs0", &ru->common.rxdata[0][subframe*frame_parms->samples_per_subframe], frame_parms->samples_per_subframe, 1, 1);
            LOG_M("rxsigF0.m","rxsF0", gNB->prach_vars.rxsigF[0], N_ZC, 1, 1);
            LOG_M("prach_preamble.m","prachp", &gNB->X_u[0], N_ZC, 1, 1);
            LOG_M("ue_prach_preamble.m","prachp", &UE->X_u[0], N_ZC, 1, 1);
@@ -479,7 +479,7 @@ int main(int argc, char **argv)
    for (trial=0; trial<n_trials; trial++) {
      bzero(txdataF[aa],frame_parms->ofdm_symbol_size*sizeof(int));
      if(format==0){
-        nr_generate_pucch0(UE,txdataF,frame_parms,UE->pucch_config_dedicated,amp,nr_tti_tx,m0,mcs,nrofSymbols,startingSymbolIndex,startingPRB);
+        nr_generate_pucch0(UE,txdataF,frame_parms,PUCCH_GroupHopping,hopping_id,amp,nr_tti_tx,m0,mcs,nrofSymbols,startingSymbolIndex,startingPRB);
      }
      else if (format == 1){
        nr_generate_pucch1(UE,txdataF,frame_parms,UE->pucch_config_dedicated,actual_payload,amp,nr_tti_tx,m0,nrofSymbols,startingSymbolIndex,startingPRB,startingPRB_intraSlotHopping,0,nr_bit);	
@@ -111,7 +111,7 @@ int main(int argc, char **argv)
  int i;
  double SNR, snr0 = -2.0, snr1 = 2.0;
  double sigma, sigma_dB;
-  double snr_step = 1;
+  double snr_step = .2;
  uint8_t snr1set = 0;
  int slot = 8, frame = 0;
  FILE *output_fd = NULL;
@@ -127,7 +127,6 @@ int main(int argc, char **argv)
  SCM_t channel_model = AWGN;  //Rayleigh1_anticorr;
  uint16_t N_RB_DL = 106, N_RB_UL = 106, mu = 1;
  //unsigned char frame_type = 0;
-  int frame_length_complex_samples,frame_length_complex_samples_no_prefix;
  NR_DL_FRAME_PARMS *frame_parms;
  int loglvl = OAILOG_WARNING;
  //uint64_t SSB_positions=0x01;
@@ -151,7 +150,7 @@ int main(int argc, char **argv)
  UE_nr_rxtx_proc_t UE_proc;
  FILE *scg_fd=NULL;

-  int ibwp_size=24;
+  int ibwps=24;
  int ibwp_rboffset=41;
  if ( load_configmodule(argc,argv,CONFIG_ENABLECMDLINEONLY) == 0 ) {
    exit_fun("[NR_ULSIM] Error, configuration module init failed\n");
@@ -387,6 +386,8 @@ int main(int argc, char **argv)

  get_softmodem_params()->phy_test = 1;
  get_softmodem_params()->do_ra = 0;
+  get_softmodem_params()->usim_test = 1;
+

  if (snr1set == 0)
    snr1 = snr0 + 10;
@@ -466,8 +467,6 @@ int main(int argc, char **argv)

  //nr_phy_config_request_sim(gNB, N_RB_DL, N_RB_UL, mu, Nid_cell, SSB_positions);

-  frame_length_complex_samples = frame_parms->samples_per_subframe;
-  frame_length_complex_samples_no_prefix = frame_parms->samples_per_subframe_wCP;

  //configure UE
  UE = malloc(sizeof(PHY_VARS_NR_UE));
@@ -575,6 +574,7 @@ int main(int argc, char **argv)

  printf("\n");

+  for (int i=0;i<16;i++) printf("%f\n",gaussdouble(0.0,1.0));
  for (SNR = snr0; SNR < snr1; SNR += snr_step) {

      varArray_t *table_rx=initVarArray(1000,sizeof(double));
@@ -618,7 +618,7 @@ int main(int argc, char **argv)
      
      int abwp_size  = NRRIV2BW(ubwp->bwp_Common->genericParameters.locationAndBandwidth,275);
      int abwp_start = NRRIV2PRBOFFSET(ubwp->bwp_Common->genericParameters.locationAndBandwidth,275);
-      int ibwp_size  = ibwp_size;
+      int ibwp_size  = ibwps;
      int ibwp_start = ibwp_rboffset;
      if (msg3_flag == 1) {
 	if ((ibwp_start < abwp_start) || (ibwp_size > abwp_size))
@@ -709,54 +709,71 @@ int main(int argc, char **argv)

      available_bits = nr_get_G(nb_rb, nb_symb_sch, nb_re_dmrs, number_dmrs_symbols, mod_order, 1);
      TBS            = nr_compute_tbs(mod_order, code_rate, nb_rb, nb_symb_sch, nb_re_dmrs * number_dmrs_symbols, 0, 0, precod_nbr_layers);
+      pusch_pdu->pusch_data.tb_size = TBS>>3;
+      ul_config.ul_config_list[0].pusch_config_pdu.pusch_data.tb_size = TBS;

+      nr_fill_ulsch(gNB,frame,slot,pusch_pdu);
+      int slot_offset = frame_parms->get_samples_slot_timestamp(slot,frame_parms,0);// - (int)(800*factor);
+      int slot_length = slot_offset - frame_parms->get_samples_slot_timestamp(slot-1,frame_parms,0);
+
+      for (int i=0;i<(TBS>>3);i++) ulsch_ue[0]->harq_processes[harq_pid]->a[i]=i&0xff;
+      double scale = 1;

      if (input_fd == NULL) {
-        pusch_pdu->pusch_data.tb_size = TBS>>3;
-        ul_config.ul_config_list[0].pusch_config_pdu.pusch_data.tb_size = TBS;
-        // set FAPI parameters for UE, put them in the scheduled response and call
-        nr_ue_scheduled_response(&scheduled_response);

-
-        /////////////////////////phy_procedures_nr_ue_TX///////////////////////
-        ///////////
-
-        phy_procedures_nrUE_TX(UE, &UE_proc, gNB_id, 0);
-
-        if (n_trials==1)
-          LOG_M("txsig0.m","txs0", UE->common_vars.txdata[0],frame_length_complex_samples,1,1);
-
-        ///////////
-        ////////////////////////////////////////////////////
-        tx_offset = frame_parms->get_samples_slot_timestamp(slot,frame_parms,0);
-
-        txlev = signal_energy_amp_shift(&UE->common_vars.txdata[0][tx_offset + 5*frame_parms->ofdm_symbol_size + 4*frame_parms->nb_prefix_samples + frame_parms->nb_prefix_samples0],
-                                        frame_parms->ofdm_symbol_size + frame_parms->nb_prefix_samples);
-
-        txlev_float = (double)txlev/(double)AMP; // output of signal_energy is fixed point representation
-
-        n_errors = 0;
-        n_false_positive = 0;
-
-        //AWGN
-        sigma_dB = 10*log10(txlev_float)-SNR;
-        sigma    = pow(10,sigma_dB/10);
-        }	
+        if (SNR==snr0) { 
+	  // set FAPI parameters for UE, put them in the scheduled response and call
+	  nr_ue_scheduled_response(&scheduled_response);
+	  
+	  
+	  /////////////////////////phy_procedures_nr_ue_TX///////////////////////
+	  ///////////
+	  
+	  phy_procedures_nrUE_TX(UE, &UE_proc, gNB_id, 0);
+	  
+	  
+	  if (n_trials==1) {
+	    LOG_M("txsig0.m","txs0", UE->common_vars.txdata[0],frame_parms->samples_per_subframe*10,1,1);
+	    LOG_M("txsig0F.m","txs0F", UE->common_vars.txdataF[0],frame_parms->ofdm_symbol_size*14,1,1);
+	  }
+	  ///////////
+	  ////////////////////////////////////////////////////
+	  tx_offset = frame_parms->get_samples_slot_timestamp(slot,frame_parms,0);
+	  
+	  txlev = signal_energy(&UE->common_vars.txdata[0][tx_offset + 5*frame_parms->ofdm_symbol_size + 4*frame_parms->nb_prefix_samples + frame_parms->nb_prefix_samples0],
+				frame_parms->ofdm_symbol_size + frame_parms->nb_prefix_samples);
+	  
+	  txlev_float = (double)txlev/scale; // output of signal_energy is fixed point representation
+	  
+	  
+	  //AWGN
+	}
+      }	
      else n_trials = 1;

+
+      sigma_dB = 10*log10(txlev_float)-SNR;
+      sigma    = pow(10,sigma_dB/10);
+      printf("txlev_float %f, sigma_dB %f\n",10*log10(txlev_float),sigma_dB);
+
+      n_errors = 0;
+      n_false_positive = 0;
+
+      errors_scrambling  = 0;
+      errors_decoding    = 0;
+
+      int error_flag;
      for (trial = 0; trial < n_trials; trial++) {
 	
-	errors_scrambling  = 0;
-	errors_decoding    = 0;
-	
+	error_flag = 0;
 	  //----------------------------------------------------------
 	  //------------------------ add noise -----------------------
 	  //----------------------------------------------------------
 	if (input_fd == NULL ) {
-	  for (i=0; i<frame_length_complex_samples; i++) {
+	  for (i=0; i<slot_length; i++) {
 	    for (ap=0; ap<frame_parms->nb_antennas_rx; ap++) {
-	      ((short*) gNB->common_vars.rxdata[ap])[(2*i) + (delay*2)]   = (((int16_t *)UE->common_vars.txdata[ap])[(i<<1)])   + (int16_t)(sqrt(sigma/2)*gaussdouble(0.0,1.0)); // convert to fixed point
-	      ((short*) gNB->common_vars.rxdata[ap])[2*i+1 + (delay*2)]   = (((int16_t *)UE->common_vars.txdata[ap])[(i<<1)+1]) + (int16_t)(sqrt(sigma/2)*gaussdouble(0.0,1.0));
+	      ((int16_t*) &gNB->common_vars.rxdata[ap][slot_offset])[(2*i) + (delay*2)]   = (int16_t)((double)(((int16_t *)&UE->common_vars.txdata[ap][slot_offset])[(i<<1)])/sqrt(scale)   + (sqrt(sigma/2)*gaussdouble(0.0,1.0))); // convert to fixed point
+	      ((int16_t*) &gNB->common_vars.rxdata[ap][slot_offset])[(2*i)+1 + (delay*2)]   = (int16_t)((double)(((int16_t *)&UE->common_vars.txdata[ap][slot_offset])[(i<<1)+1])/sqrt(scale) + (sqrt(sigma/2)*gaussdouble(0.0,1.0)));
 	    }
 	  }
 	}
@@ -770,8 +787,6 @@ int main(int argc, char **argv)
 	  if (N_RB_DL <217) ta_offset=800;
 	  else if (N_RB_DL < 106) ta_offset = 400;

-	  int slot_offset = frame_parms->get_samples_slot_timestamp(slot,frame_parms,0);// - (int)(800*factor);
-	  int slot_length = slot_offset - frame_parms->get_samples_slot_timestamp(slot-1,frame_parms,0);
 	  fread((void*)&gNB->common_vars.rxdata[0][slot_offset],
 		sizeof(int16_t),
 		slot_length<<1,
@@ -781,7 +796,6 @@ int main(int argc, char **argv)
 					 ((int16_t*)&gNB->common_vars.rxdata[0][slot_offset])[i],
 					 ((int16_t*)&gNB->common_vars.rxdata[0][slot_offset])[1+i]);
 	  fclose(input_fd);
-	  LOG_M("rxsig0.m","rx0",gNB->common_vars.rxdata[0][slot_offset],slot_length,1,1);
 	}
 	////////////////////////////////////////////////////////////
 	
@@ -795,6 +809,8 @@ int main(int argc, char **argv)
        phy_procedures_gNB_common_RX(gNB, frame, slot);

 	if (n_trials==1) {
+	  LOG_M("rxsig0.m","rx0",&gNB->common_vars.rxdata[0][0],frame_parms->samples_per_subframe*10,1,1);
+
 	  LOG_M("rxsigF0.m","rxsF0",gNB->common_vars.rxdataF[0]+start_symbol*frame_parms->ofdm_symbol_size,nb_symb_sch*frame_parms->ofdm_symbol_size,1,1);

 	}
@@ -813,9 +829,11 @@ int main(int argc, char **argv)
        ////////////////////////////////////////////////////////////

 	if (gNB->ulsch[0][0]->last_iteration_cnt >= 
-	    gNB->ulsch[0][0]->max_ldpc_iterations+1)
+	    gNB->ulsch[0][0]->max_ldpc_iterations+1) {
+	  error_flag = 1; 
 	  n_errors++;
-
+	}
+	
        //----------------------------------------------------------
        //----------------- count and print errors -----------------
        //----------------------------------------------------------
@@ -847,22 +865,30 @@ int main(int argc, char **argv)
            errors_decoding++;
          }
        }
-
-        if (errors_decoding > 0) {
+	if (n_trials == 1) {
+	  for (int r=0;r<ulsch_ue[0]->harq_processes[harq_pid]->C;r++) 
+	    for (int i=0;i<ulsch_ue[0]->harq_processes[harq_pid]->K>>3;i++) {
+	      if ((ulsch_ue[0]->harq_processes[harq_pid]->c[r][i]^ulsch_gNB->harq_processes[harq_pid]->c[r][i]) != 0) printf("************");
+	      printf("r %d: in[%d] %x, out[%d] %x (%x)\n",r,
+		     i,ulsch_ue[0]->harq_processes[harq_pid]->c[r][i],
+		     i,ulsch_gNB->harq_processes[harq_pid]->c[r][i],
+		     ulsch_ue[0]->harq_processes[harq_pid]->c[r][i]^ulsch_gNB->harq_processes[harq_pid]->c[r][i]);
+	    }
+	}
+        if (errors_decoding > 0 && error_flag == 0) {
          n_false_positive++;
 	  if (n_trials==1)
 	    printf("\x1B[31m""[frame %d][trial %d]\tnumber of errors in decoding     = %u\n" "\x1B[0m", frame, trial, errors_decoding);
        } 
-
      } // trial loop

      printf("*****************************************\n");
-      printf("SNR %f: n_errors (negative CRC) = %d/%d, false_positive %d/%d, errors_scrambling %u/%d\n", SNR, n_errors, n_trials, n_false_positive, n_trials, errors_scrambling, n_trials);
+      printf("SNR %f: n_errors (negative CRC) = %d/%d, false_positive %d/%d, errors_scrambling %u/%u\n", SNR, n_errors, n_trials, n_false_positive, n_trials, errors_scrambling, available_bits*n_trials);
      printf("\n");
      printf("SNR %f: Channel BLER %e, Channel BER %e\n", SNR,(double)n_errors/n_trials,(double)errors_scrambling/available_bits/n_trials);
      printf("*****************************************\n");
      printf("\n");
-
+ 
      if (print_perf==1) {
        printDistribution(&gNB->phy_proc_rx,table_rx,"Total PHY proc rx");
        printStatIndent(&gNB->ulsch_channel_estimation_stats,"ULSCH channel estimation time");
@@ -888,7 +914,6 @@ int main(int argc, char **argv)
      }
      
  } // SNR loop
-
  printf("\n");

  free(test_input_bit);
@@ -1545,7 +1545,7 @@ int RCconfig_RRC(uint32_t i, eNB_RRC_INST *rrc, int macrlc_has_f1) {
              RRC_CONFIGURATION_REQ(msg_p).eMBMS_configured = 0;
              printf("No eMBMS configuration, skipping it\n");
              // eMTC configuration
-              char brparamspath[MAX_OPTNAME_SIZE*2 + 16];
+              char brparamspath[MAX_OPTNAME_SIZE*2 + 160];
              sprintf(brparamspath,"%s.%s", ccspath, ENB_CONFIG_STRING_EMTC_PARAMETERS);
              config_get(eMTCParams, sizeof(eMTCParams)/sizeof(paramdef_t), brparamspath);
              RRC_CONFIGURATION_REQ(msg_p).eMTC_configured = eMTCconfig.eMTC_configured&1;
@@ -1554,7 +1554,7 @@ int RCconfig_RRC(uint32_t i, eNB_RRC_INST *rrc, int macrlc_has_f1) {
              else                            printf("No eMTC configuration, skipping it\n");

              // Sidelink configuration
-              char SLparamspath[MAX_OPTNAME_SIZE*2 + 16];
+              char SLparamspath[MAX_OPTNAME_SIZE*2 + 160];
              sprintf(SLparamspath,"%s.%s", ccspath, ENB_CONFIG_STRING_SL_PARAMETERS);
              config_get( SLParams, sizeof(SLParams)/sizeof(paramdef_t), SLparamspath);
              // Sidelink Resource pool information
@@ -226,7 +226,7 @@ int CU_send_UE_CONTEXT_SETUP_REQUEST(instance_t instance,
    
    ie->value.choice.ResourceCoordinationTransferContainer.buf = malloc(4);
    ie->value.choice.ResourceCoordinationTransferContainer.size = 4;
-    strncpy((char *)ie->value.choice.ResourceCoordinationTransferContainer.buf, "123", 3);
+    strncpy((char *)ie->value.choice.ResourceCoordinationTransferContainer.buf, "123", 4);


    OCTET_STRING_fromBuf(&ie->value.choice.ResourceCoordinationTransferContainer, "asdsa1d32sa1d31asd31as",
@@ -295,6 +295,18 @@ store_dlsch_buffer(module_id_t Mod_id,
 #endif
    }

+    /* hack: in schedule_ue_spec, 3 bytes are "reserved" (this should be
+     * done better). An RLC AM entity may ask for only 2 bytes for
+     * ACKing and get a TBS of 32 bits and due to these 3 reserved bytes we may
+     * end up with only 1 byte left for RLC, which is not enough. This hack
+     * prevents the problem. To be done better at some point. If the function
+     * schedule_ue_spec is (has been) reworked, this hack can be removed.
+     * Dig for "TBS - ta_len - header_length_total - sdu_length_total - 3"
+     * in schedule_ue_spec.
+     */
+    if (UE_template->dl_buffer_total > 0 && UE_template->dl_buffer_total <= 2)
+      UE_template->dl_buffer_total += 3;
+
    if (UE_template->dl_buffer_total > 0)
      LOG_D(MAC,
            "[eNB %d] Frame %d Subframe %d : RLC status for UE %d : total DL buffer size %d and total number of pdu %d \n",
@@ -52,6 +52,9 @@ const char *prachfmt03[]={"0","1","2","3"};

 uint16_t get_NCS(uint8_t index, uint16_t format0, uint8_t restricted_set_config) {

+  LOG_D(MAC,"get_NCS: indx %d,format0 %d, restriced_set_config %d\n",
+	index,format0,restricted_set_config);
+
  if (format0 < 3) {
    switch(restricted_set_config){
      case 0:
@@ -1736,7 +1739,7 @@ uint8_t getRBGSize(uint16_t bwp_size, long rbg_size_config) {
  if (bwp_size < 37)  return (rbg_size_config ? 4 : 2);
  if (bwp_size < 73)  return (rbg_size_config ? 8 : 4);
  if (bwp_size < 145) return (rbg_size_config ? 16 : 8);
-  if (bwp_size < 276) return 16;
+  else return 16;
 }

 uint8_t getNRBG(uint16_t bwp_size, uint16_t bwp_start, long rbg_size_config) {
@@ -274,7 +274,7 @@ int8_t nr_ue_decode_mib(module_id_t module_id,
  uint16_t frame_number_4lsb = 0;
  for (int i=0; i<4; i++)
    frame_number_4lsb |= ((extra_bits>>i)&1)<<(3-i);
-  uint8_t half_frame_bit = ( extra_bits >> 4 ) & 0x1;               //	extra bits[4]
+  //uint8_t half_frame_bit = ( extra_bits >> 4 ) & 0x1;               //	extra bits[4]
  uint8_t ssb_subcarrier_offset_msb = ( extra_bits >> 5 ) & 0x1;    //	extra bits[5]
  uint8_t ssb_subcarrier_offset = (uint8_t)mac->mib->ssb_SubcarrierOffset;

@@ -385,7 +385,7 @@ void gNB_dlsch_ulsch_scheduler(module_id_t module_idP,
  }

  start_meas(&RC.nrmac[module_idP]->eNB_scheduler);
-  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_DLSCH_ULSCH_SCHEDULER,VCD_FUNCTION_IN);
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_gNB_DLSCH_ULSCH_SCHEDULER,VCD_FUNCTION_IN);

  pdcp_run(&ctxt);
  //rrc_rx_tx(&ctxt, CC_id);
@@ -502,5 +502,5 @@ void gNB_dlsch_ulsch_scheduler(module_id_t module_idP,

  stop_meas(&RC.nrmac[module_idP]->eNB_scheduler);
  
-  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_DLSCH_ULSCH_SCHEDULER,VCD_FUNCTION_OUT);
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_gNB_DLSCH_ULSCH_SCHEDULER,VCD_FUNCTION_OUT);
 }
@@ -383,7 +383,7 @@ int configure_fapi_dl_pdu(int Mod_idP,
  // antenna ports
  dci_pdu_rel15[0].antenna_ports.val = 0;  // nb of cdm groups w/o data 1 and dmrs port 0

-  LOG_I(MAC, "[gNB scheduler phytest] DCI type 1 payload: freq_alloc %d (%d,%d,%d), time_alloc %d, vrb to prb %d, mcs %d tb_scaling %d ndi %d rv %d\n",
+  LOG_D(MAC, "[gNB scheduler phytest] DCI type 1 payload: freq_alloc %d (%d,%d,%d), time_alloc %d, vrb to prb %d, mcs %d tb_scaling %d ndi %d rv %d\n",
 	dci_pdu_rel15[0].frequency_domain_assignment.val,
 	pdsch_pdu_rel15->rbStart, 
 	pdsch_pdu_rel15->rbSize,	
@@ -424,6 +424,7 @@ int configure_fapi_dl_pdu(int Mod_idP,
 		               bwp);
  if (ret < 0) {
   LOG_I(MAC,"CCE list not empty, couldn't schedule PDSCH\n");
+   free(dci_pdu_rel15);
   return (0);
  }

@@ -453,7 +454,7 @@ int configure_fapi_dl_pdu(int Mod_idP,

  // Hardcode it for now
  TBS = dl_tti_pdsch_pdu->pdsch_pdu.pdsch_pdu_rel15.TBSize[0];
-  LOG_I(MAC, "DLSCH PDU: start PRB %d n_PRB %d startSymbolAndLength %d start symbol %d nb_symbols %d nb_layers %d nb_codewords %d mcs %d TBS: %d\n",
+  LOG_D(MAC, "DLSCH PDU: start PRB %d n_PRB %d startSymbolAndLength %d start symbol %d nb_symbols %d nb_layers %d nb_codewords %d mcs %d TBS: %d\n",
 	pdsch_pdu_rel15->rbStart,
 	pdsch_pdu_rel15->rbSize,
 	startSymbolAndLength,
@@ -464,6 +465,7 @@ int configure_fapi_dl_pdu(int Mod_idP,
 	pdsch_pdu_rel15->mcsIndex[0],
 	TBS);

+  free(dci_pdu_rel15);
  return TBS; //Return TBS in bytes
 }

@@ -544,6 +546,8 @@ void nr_schedule_uss_dlsch_phytest(module_id_t   module_idP,
                                   int num_slots_per_tdd,
                                   nfapi_nr_dl_tti_pdsch_pdu_rel15_t *dlsch_config){

+  LOG_D(MAC, "In nr_schedule_uss_dlsch_phytest frame %d slot %d\n",frameP,slotP);
+
  int post_padding = 0, ta_len = 0, header_length_total = 0, sdu_length_total = 0, num_sdus = 0;
  int lcid, offset, i, header_length_last, TBS_bytes = 0;
  int UE_id = 0, CC_id = 0;
@@ -800,7 +800,6 @@ void fill_dci_pdu_rel15(NR_CellGroupConfig_t *secondaryCellGroup,
                        int bwp_id) {

  uint8_t fsize=0, pos=0;
-  uint8_t nbits=0;

  for (int d=0;d<pdcch_pdu_rel15->numDlDci;d++) {

@@ -588,9 +588,10 @@ static void check_t_reassembly(nr_rlc_entity_um_t *entity)
  cur = entity->rx_list;
  while (cur != NULL &&
         sn_compare_rx(entity, cur->sn, entity->rx_next_reassembly) < 0) {
-    nr_rlc_free_pdu(cur);
+    nr_rlc_pdu_t *p = cur;
    cur = cur->next;
    entity->rx_list = cur;
+    nr_rlc_free_pdu(p);
  }

  if (sn_compare_rx(entity, entity->rx_next_highest,
@@ -271,6 +271,7 @@ typedef enum UE_STATE_e {
  RRC_RECONFIGURED,
  RRC_HO_EXECUTION,
  RRC_NR_NSA,
+  RRC_NR_NSA_RECONFIGURED
 } UE_STATE_t;

 typedef enum HO_STATE_e {
@@ -4613,7 +4613,7 @@ rrc_eNB_process_MeasurementReport(

  /* TODO: improve NR triggering */
  if (measResults2->measId == 7) {
-    if (ue_context_pP->ue_context.Status != RRC_NR_NSA) {
+    if ((ue_context_pP->ue_context.Status != RRC_NR_NSA) && (ue_context_pP->ue_context.Status != RRC_NR_NSA_RECONFIGURED)) {
      MessageDef      *msg;
      ue_context_pP->ue_context.Status = RRC_NR_NSA;

@@ -4636,7 +4636,7 @@ rrc_eNB_process_MeasurementReport(
        for (int e_rab=0; e_rab < X2AP_ENDC_SGNB_ADDITION_REQ(msg).nb_e_rabs_tobeadded; e_rab++) {
          X2AP_ENDC_SGNB_ADDITION_REQ(msg).e_rabs_tobeadded[e_rab].e_rab_id = ue_context_pP->ue_context.e_rab[e_rab].param.e_rab_id;
          X2AP_ENDC_SGNB_ADDITION_REQ(msg).e_rabs_tobeadded[e_rab].gtp_teid = ue_context_pP->ue_context.e_rab[e_rab].param.gtp_teid;
-          X2AP_ENDC_SGNB_ADDITION_REQ(msg).e_rabs_tobeadded[e_rab].drb_ID = 1;
+          X2AP_ENDC_SGNB_ADDITION_REQ(msg).e_rabs_tobeadded[e_rab].drb_ID = ue_context_pP->ue_context.DRB_configList->list.array[e_rab]->drb_Identity; 
          memcpy(&X2AP_ENDC_SGNB_ADDITION_REQ(msg).e_rabs_tobeadded[e_rab].sgw_addr,
                 &ue_context_pP->ue_context.e_rab[e_rab].param.sgw_addr,
                 sizeof(transport_layer_addr_t));
@@ -7773,7 +7773,37 @@ rrc_eNB_decode_dcch(
              LOG_I(RRC,
                    PROTOCOL_RRC_CTXT_UE_FMT" UE State = RRC_HO_EXECUTION (xid %ld)\n",
                    PROTOCOL_RRC_CTXT_UE_ARGS(ctxt_pP),ul_dcch_msg->message.choice.c1.choice.rrcConnectionReconfigurationComplete.rrc_TransactionIdentifier);
-            } else {
+            }
+            else if(ue_context_p->ue_context.Status == RRC_NR_NSA){
+              //Looking for a condition to trigger S1AP E-RAB-Modification-indication, based on the reception of RRCConnectionReconfigurationComplete
+              //including NR specific elements.
+              if(ul_dcch_msg->message.choice.c1.choice.rrcConnectionReconfigurationComplete.criticalExtensions.choice.rrcConnectionReconfigurationComplete_r8.
+                  nonCriticalExtension!=NULL) {
+                if(ul_dcch_msg->message.choice.c1.choice.rrcConnectionReconfigurationComplete.criticalExtensions.choice.rrcConnectionReconfigurationComplete_r8.
+                    nonCriticalExtension->nonCriticalExtension!=NULL) {
+                  if(ul_dcch_msg->message.choice.c1.choice.rrcConnectionReconfigurationComplete.criticalExtensions.choice.rrcConnectionReconfigurationComplete_r8.
+                      nonCriticalExtension->nonCriticalExtension->nonCriticalExtension!=NULL) {
+                    if(ul_dcch_msg->message.choice.c1.choice.rrcConnectionReconfigurationComplete.criticalExtensions.choice.rrcConnectionReconfigurationComplete_r8.
+                        nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension!=NULL) {
+                      if(ul_dcch_msg->message.choice.c1.choice.rrcConnectionReconfigurationComplete.criticalExtensions.choice.rrcConnectionReconfigurationComplete_r8.
+                          nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension!=NULL) {
+                        if (ul_dcch_msg->message.choice.c1.choice.rrcConnectionReconfigurationComplete.criticalExtensions.choice.rrcConnectionReconfigurationComplete_r8.
+                            nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension!=NULL) {
+                          if(ul_dcch_msg->message.choice.c1.choice.rrcConnectionReconfigurationComplete.criticalExtensions.choice.rrcConnectionReconfigurationComplete_r8.
+                              nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension
+                              ->scg_ConfigResponseNR_r15!=NULL) {
+                            ue_context_p->ue_context.Status = RRC_NR_NSA_RECONFIGURED;
+                            /*Trigger E-RAB Modification Indication */
+                            rrc_eNB_send_E_RAB_Modification_Indication(ctxt_pP, ue_context_p);
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+            else {
              dedicated_DRB = 0;
              ue_context_p->ue_context.Status = RRC_RECONFIGURED;
              LOG_I(RRC,
@@ -7783,39 +7813,6 @@ rrc_eNB_decode_dcch(

            ue_context_p->ue_context.reestablishment_xid = -1;

-            //Looking for a condition to trigger S1AP E-RAB-Modification-indication, based on the reception of RRCConnectionReconfigurationComplete
-            //including NR specific elements. Not sure if this is the correct one and the correct placement
-            /*if(ul_dcch_msg->message.choice.c1.choice.rrcConnectionReconfigurationComplete.criticalExtensions.choice.rrcConnectionReconfigurationComplete_r8.
-                nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->
-                scg_ConfigResponseNR_r15->buf!=NULL){
-              //Trigger E-RAB Modification Indication
-              rrc_eNB_send_E_RAB_Modification_Indication(ctxt_pP, ue_context_p);
-            }*/
-
-            if(ul_dcch_msg->message.choice.c1.choice.rrcConnectionReconfigurationComplete.criticalExtensions.choice.rrcConnectionReconfigurationComplete_r8.
-                nonCriticalExtension!=NULL) {
-              if(ul_dcch_msg->message.choice.c1.choice.rrcConnectionReconfigurationComplete.criticalExtensions.choice.rrcConnectionReconfigurationComplete_r8.
-                  nonCriticalExtension->nonCriticalExtension!=NULL) {
-                if(ul_dcch_msg->message.choice.c1.choice.rrcConnectionReconfigurationComplete.criticalExtensions.choice.rrcConnectionReconfigurationComplete_r8.
-                    nonCriticalExtension->nonCriticalExtension->nonCriticalExtension!=NULL) {
-                  if(ul_dcch_msg->message.choice.c1.choice.rrcConnectionReconfigurationComplete.criticalExtensions.choice.rrcConnectionReconfigurationComplete_r8.
-                      nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension!=NULL) {
-                    if(ul_dcch_msg->message.choice.c1.choice.rrcConnectionReconfigurationComplete.criticalExtensions.choice.rrcConnectionReconfigurationComplete_r8.
-                        nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension!=NULL) {
-                      if (ul_dcch_msg->message.choice.c1.choice.rrcConnectionReconfigurationComplete.criticalExtensions.choice.rrcConnectionReconfigurationComplete_r8.
-                          nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension!=NULL) {
-                        if(ul_dcch_msg->message.choice.c1.choice.rrcConnectionReconfigurationComplete.criticalExtensions.choice.rrcConnectionReconfigurationComplete_r8.
-                            nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension
-                            ->scg_ConfigResponseNR_r15!=NULL) {
-                          /*Trigger E-RAB Modification Indication */
-                          rrc_eNB_send_E_RAB_Modification_Indication(ctxt_pP, ue_context_p);
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
          } else {
            dedicated_DRB = 1;
            ue_context_p->ue_context.Status = RRC_RECONFIGURED;
@@ -40,6 +40,7 @@
 #include "openair2/LAYER2/NR_MAC_gNB/mac_proto.h"
 #include "openair2/RRC/LTE/rrc_eNB_GTPV1U.h"
 #include "executables/softmodem-common.h"
+#include <openair2/RRC/NR/rrc_gNB_UE_context.h>

 extern boolean_t nr_rrc_pdcp_config_asn1_req(
    const protocol_ctxt_t *const  ctxt_pP,
@@ -141,6 +142,10 @@ void rrc_parse_ue_capabilities(gNB_RRC_INST *rrc, LTE_UE_CapabilityRAT_Container
  rrc_add_nsa_user(rrc,ue_context_p, m);
 }

+/* generate prototypes for the tree management functions (RB_INSERT used in rrc_add_nsa_user) */
+RB_PROTOTYPE(rrc_nr_ue_tree_s, rrc_gNB_ue_context_s, entries,
+             rrc_gNB_compare_ue_rnti_id);
+
 void rrc_add_nsa_user(gNB_RRC_INST *rrc,struct rrc_gNB_ue_context_s *ue_context_p, x2ap_ENDC_sgnb_addition_req_t *m) {
  // generate nr-Config-r15 containers for LTE RRC : inside message for X2 EN-DC (CG-Config Message from 38.331)
  rrc_gNB_carrier_data_t *carrier=&rrc->carrier;
@@ -420,6 +420,7 @@ static int trx_usrp_write(openair0_device *device,
    s->tx_md.time_spec      = uhd::time_spec_t::from_ticks(timestamp, s->sample_rate);
    s->tx_count++;

+VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_BEAM_SWITCHING_GPIO,1);
    // bit 3 enables gpio (for backward compatibility)
    if (flags_msb&8) {
      // push GPIO bits 7-9 from flags_msb
@@ -428,6 +429,7 @@ static int trx_usrp_write(openair0_device *device,
      s->usrp->set_gpio_attr("FP0", "OUT", gpio789, 0x380);
      s->usrp->clear_command_time();
    }
+VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_BEAM_SWITCHING_GPIO,0);

    if (cc>1) {
      std::vector<void *> buff_ptrs;
@@ -96,11 +96,19 @@ sudo RFSIMULATOR=server ./nr-softmodem -O ../../../targets/PROJECTS/GENERIC-LTE-
 ### Launch UE in another window

 ```bash
-sudo RFSIMULATOR=<TARGET_GNB_INTERFACE_ADDRESS> ./nr-uesoftmodem --rfsim --phy-test --rrc_config_path ../../../ci-scripts/rrc-files 
+sudo RFSIMULATOR=<TARGET_GNB_INTERFACE_ADDRESS> ./nr-uesoftmodem --rfsim --phy-test --rrc_config_path .
 ```
-Note:
+
+Notes:
+
 1. <TARGET_GNB_INTERFACE_ADDRESS> can be 127.0.0.1 if both gNB and nrUE executables run on the same host, OR the IP interface address of the remote host running the gNB executable, if the gNB and nrUE run on separate hosts
-2. the --rrc_config_path parameter can be omitted (but not necessarily) if the gNB and nrUE run on the same host, in which case the gNB provides the nrUE with the necessary rrc configuration
+2. the --rrc_config_path parameter SHALL specify where the 2 RAW files are located (`rbconfig.raw` and `reconfig.raw`).
+   - If you are running on the same machine and launched the 2 executables (`nr-softmodem` and `nr-uesoftmodem`) from the same directory, nothing has to be done.
+   - If you launched the 2 executables from 2 different folders, just point to the location where you launched the `nr-softmodem`:
+     * `sudo RFSIMULATOR=<TARGET_GNB_INTERFACE_ADDRESS> ./nr-uesoftmodem --rfsim --phy-test --rrc_config_path /the/path/where/you/launched/nr-softmodem`
+   - If you are not running on the same machine or launched the 2 executables from 2 different folders, you need to **COPY** the 2 raw files
+     * `scp usera@machineA:/the/path/where/you/launched/nr-softmodem/r*config.raw userb@machineB:/the/path/where/you/will/launch/nr-uesoftmodem/`
+     * Obviously this operation SHALL be done before launching the `nr-uesoftmodem` executable.
 3. to enable the noS1 mode --noS1 and --nokrnmod 1 options should be added to the command line


@@ -149,8 +149,12 @@ void allocCirBuf(rfsimulator_state_t *bridge, int sock) {
    // while calling new_channel_desc_scm() with path losses = 0
    static bool init_done=false;
    if (!init_done) {
-      randominit(0);
-      tableNor(0);
+	    uint64_t rand;
+	    FILE *h=fopen("/dev/random","r");
+            fread(&rand,sizeof(rand),1,h);
+	    fclose(h);
+      randominit(rand);
+      tableNor(rand);
      init_done=true;
    }
    ptr->channel_model=new_channel_desc_scm(bridge->tx_num_channels,bridge->rx_num_channels,
@@ -32,43 +32,50 @@ variables.frame_number_RX1_UE[63:0]
 variables.trx_ts_ue[63:0]
 variables.trx_ts[63:0]
 variables.trx_tst[63:0]
-variables.frame_number_RX0_RU[63:0]
-variables.tti_number_RX0_RU[63:0]
-variables.frame_number_TX0_RU[63:0]
-variables.tti_number_TX0_RU[63:0]
-@28
-functions.mac_schedule_dlsch
-functions.macxface_eNB_dlsch_ulsch_scheduler
-@24
-variables.frame_number_RX0_gNB[63:0]
-variables.slot_number_RX0_gNB[63:0]
-variables.frame_number_TX0_gNB[63:0]
-variables.slot_number_TX0_gNB[63:0]
-@28
-functions.gNB_thread_rxtx0
-@24
-variables.frame_number_RX1_gNB[63:0]
-variables.slot_number_RX1_gNB[63:0]
-variables.frame_number_TX1_gNB[63:0]
-variables.slot_number_TX1_gNB[63:0]
-@28
-functions.gNB_thread_rxtx1
-functions.phy_enb_pdcch_tx
-functions.phy_eNB_dlsch_encoding
-functions.phy_eNB_dlsch_encoding_w
-functions.generate_dlsch
+@22
+variables.frame_number_RX0_UE[63:0]
@420
 variables.frame_number_RX0_UE[63:0]
+@24
+variables.frame_number_RX0_RU[63:0]
+variables.tti_number_RX0_RU[63:0]
+variables.frame_number_RX0_gNB[63:0]
+variables.slot_number_RX0_gNB[63:0]
+variables.slot_number_RX1_gNB[63:0]
+variables.frame_number_RX1_gNB[63:0]
@28
 functions.phy_procedures_ru_feprx0
 functions.phy_procedures_ru_feprx1
+functions.phy_procedures_gNB_uespec_rx
+functions.nr_rx_pusch
+functions.nr_ulsch_procedures_rx
+functions.gNB_ulsch_decoding
+@24
+variables.frame_number_TX0_RU[63:0]
+variables.frame_number_TX0_gNB[63:0]
+variables.frame_number_TX1_gNB[63:0]
+variables.tti_number_TX0_RU[63:0]
+variables.slot_number_TX0_gNB[63:0]
+variables.slot_number_TX1_gNB[63:0]
+@29
+functions.mac_schedule_dlsch
+@28
+functions.macxface_gNB_dlsch_ulsch_scheduler
+functions.gNB_thread_rxtx0
+functions.gNB_thread_rxtx1
+functions.generate_dlsch
+functions.phy_procedures_gNB_common_tx
+functions.phy_procedures_gNB_tx
+functions.gNB_pdcch_tx
+functions.gNB_dlsch_encoding
+functions.gNB_pdsch_codeword_scrambling
+functions.gNB_pdsch_modulation
 functions.phy_procedures_ru_feptx_ofdm0
 functions.phy_procedures_ru_feptx_ofdm1
 functions.phy_procedures_ru_feptx_ofdm2
 functions.phy_procedures_ru_feptx_prec0
 functions.phy_procedures_ru_feptx_prec1
 functions.phy_procedures_ru_feptx_prec2
-@22
 variables.ru_tx_ofdm_mask[63:0]
 [pattern_trace] 1
 [pattern_trace] 0