diff --git a/.gitignore b/.gitignore
index 1ed392ef06..2adc5d457c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,4 @@
 cmake_targets/log/
-cmake_targets/ran_build/
+cmake_targets/*/build/
 targets/bin/
 
diff --git a/ci-scripts/Jenkinsfile-gitlab b/ci-scripts/Jenkinsfile-gitlab
index 6ae75d71ae..b5c34d5b81 100644
--- a/ci-scripts/Jenkinsfile-gitlab
+++ b/ci-scripts/Jenkinsfile-gitlab
@@ -131,10 +131,10 @@ pipeline {
             }
         }
 
-        stage ("Start VM -- nu-ue-usrp") {
+        stage ("Start VM -- nr-ue-usrp") {
             steps {
                 timeout (time: 5, unit: 'MINUTES') {
-                    sh "./ci-scripts/oai-ci-vm-tool build --workspace $WORKSPACE --variant nu-ue-usrp --job-name ${JOB_NAME} --build-id ${BUILD_ID} --daemon"
+                    sh "./ci-scripts/oai-ci-vm-tool build --workspace $WORKSPACE --variant nr-ue-usrp --job-name ${JOB_NAME} --build-id ${BUILD_ID} --daemon"
                 }
             }
         }
@@ -239,7 +239,7 @@ pipeline {
                     steps {
                         gitlabCommitStatus(name: "Build nr-UE-usrp") {
                             timeout (time: 20, unit: 'MINUTES') {
-                                sh "./ci-scripts/oai-ci-vm-tool wait --workspace $WORKSPACE --variant nu-ue-usrp --job-name ${JOB_NAME} --build-id ${BUILD_ID}"
+                                sh "./ci-scripts/oai-ci-vm-tool wait --workspace $WORKSPACE --variant nr-ue-usrp --job-name ${JOB_NAME} --build-id ${BUILD_ID}"
                             }
                         }
                     }
diff --git a/ci-scripts/Jenkinsfile-poll-gNB-UE b/ci-scripts/Jenkinsfile-poll-gNB-UE
new file mode 100644
index 0000000000..dfac9b969d
--- /dev/null
+++ b/ci-scripts/Jenkinsfile-poll-gNB-UE
@@ -0,0 +1,380 @@
+#!/bin/groovy
+/*
+* 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
+*/
+
+
+// Abstraction function to send social media messages:
+// like on Slack or Mattermost
+def sendSocialMediaMessage(pipeChannel, pipeColor, pipeMessage) {
+    if (params.pipelineUsesSlack != null) {
+        if (params.pipelineUsesSlack) {
+            slackSend channel: pipeChannel, color: pipeColor, message: pipeMessage
+        }
+    }
+}
+
+// Location of the test XML file to be run
+def testXMLFile = params.pythonTestXmlFile
+def mainPythonAllXmlFiles = ""
+def buildStageStatus = true
+
+// Name of the phone resource
+def ciUSRPsResource = params.USRPsResource
+
+// Terminate Status
+def termUE = 0
+def termENB = 1
+def termStatusArray = new Boolean[2]
+termStatusArray[termUE] = false
+termStatusArray[termENB] = false
+
+// Global Parameters.
+def eNB_Repository
+def eNB_Branch
+def eNB_CommitID
+def eNB_AllowMergeRequestProcess = false
+def eNB_TargetBranch
+def PROJECT_NAME = "test-boris"
+def GIT_COMMIT_AUTHORi
+def GIT_COMMIT_EMAIL
+def testStageName
+// Reversing list because pop() will take the last (right-most) element
+//def modeList = ['TesteNB', 'TestUE', 'TesteNB'].reverse()
+
+// Global Parameters not to break the main.py command line and code.
+def ADB_IPAddress = "none"
+def ADB_Username = "none"
+def ADB_Password = "none"
+def EPC_IPAddress = "none"
+def EPC_Username = "none"
+def EPC_Password = "none"
+
+
+
+pipeline {
+    agent {
+        label pythonExecutor 
+    }
+    options {
+        disableConcurrentBuilds()
+        gitLabConnection('OAI GitLab')
+        ansiColor('xterm')
+	lock (ciUSRPsResource)
+    }
+
+    stages {
+        stage ('Retrieve latest from branch') {
+            steps {
+	        script {
+	            checkout([$class: 'GitSCM', branches: [[name: "${params.Branch}"]], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[url: 'https://gitlab.eurecom.fr/oai/openairinterface5g.git']]])
+	            sh "git clean -x -d -ff"
+	            sh "git log -n1"
+	        }
+            }
+        }
+        stage ("print latest commit info") {
+            steps {
+        	    script {
+        	        echo "Building on: "
+        	        echo "  Repository -- ${GIT_URL}"
+        	        echo "  Branch -- ${GIT_BRANCH}"
+        	        echo "  Commit -- ${GIT_COMMIT}"
+        	    }
+            }
+        }
+        stage ("Verify Parameters") {
+            steps {
+                script {
+                    JOB_TIMESTAMP = sh returnStdout: true, script: 'date --utc --rfc-3339=seconds | sed -e "s#+00:00##"'
+                    JOB_TIMESTAMP = JOB_TIMESTAMP.trim()
+
+                    echo '\u2705 \u001B[32mVerify Parameters\u001B[0m'
+                    def allParametersPresent = true
+
+                    // It is already too late to check it
+                    if (params.pythonExecutor != null) {
+                       echo "eNB CI executor node  :   ${pythonExecutor}"
+                    }
+                    if (params.eNB_Repository == null) {
+                        eNB_Repository = GIT_URL 
+                    } else {
+                        eNB_Repository = params.eNB_Repository
+                    }
+                    echo "eNB_Repository = ${eNB_Repository}"
+                    if (params.eNB_Branch== null) {
+                        eNB_Branch = GIT_BRANCH
+                    } else {
+                        eNB_Branch = params.eNB_Branch
+                    }
+                    echo "eNB_Branch = ${eNB_Branch}"
+                    if (params.eNB_CommitID == null) {
+                        eNB_CommitID = GIT_COMMIT 
+                    } else {
+                        eNB_CommitID = params.eNB_CommitID
+                    }
+                    echo "eNB_CommitID = ${eNB_CommitID}"
+                    // If not present picking a default Stage Name
+                    if (params.pipelineTestStageName == null) {
+                        // picking default
+                        testStageName = 'Template Test Stage'
+                    } else {
+			testStageName = params.pipelineTestStageName
+	            }
+
+                    if (params.USRPsResource == null) {
+                        allParametersPresent = false
+                    }
+	
+                    if (params.eNB_IPAddress == null) {
+                        allParametersPresent = false
+                    }
+                    if (params.UE_IPAddress == null) {
+                        allParametersPresent = false
+                    }
+                    if (params.eNB_SourceCodePath == null) {
+                        allParametersPresent = false
+                    }
+                    if (params.eNB_Credentials == null) {
+                        allParametersPresent = false
+                    }
+                    if (params.UE_Credentials == null) {
+                        allParametersPresent = false
+                    }
+                    GIT_COMMIT_AUTHOR = sh (
+                        script: 'git show -s --pretty=%an',
+                        returnStdout: true
+                    ).trim()
+                    echo "The author of the commit is: ${GIT_COMMIT_AUTHOR}"
+                    GIT_COMMIT_EMAIL = sh (
+                        script: 'git show -s --pretty=%ae',
+                        returnStdout: true
+                    ).trim()
+                    echo "The email of the author is: ${GIT_COMMIT_EMAIL}"
+                    if (allParametersPresent) {
+                        echo "All parameters are present"
+                    } else {
+                        echo "Some parameters are missing"
+                        sh "./ci-scripts/fail.sh"
+                    }
+                }
+            }
+        }
+
+        stage ("Build and Test") {
+            steps {
+        	    script {
+        	        dir ('ci-scripts') {
+                        // If not present picking a default XML file
+                        if (params.pythonTestXmlFile == null) {
+                            // picking default
+                            testXMLFile = 'xml_files/gnb_usrp_build.xml'
+                            echo "Test XML file(default):   ${testXMLFile}"
+                            mainPythonAllXmlFiles += "--XMLTestFile=" + testXMLFile + " "
+                        } else {
+                            String[] myXmlTestSuite = testXMLFile.split("\\r?\\n")
+                            for (xmlFile in myXmlTestSuite) {
+                                if (fileExists(xmlFile)) {
+                            	mainPythonAllXmlFiles += "--XMLTestFile=" + xmlFile + " "
+                            	echo "Test XML file         :   ${xmlFile}"
+                                }
+                            }
+                        }
+        	    	withCredentials([
+        	    	    [$class: 'UsernamePasswordMultiBinding', credentialsId: "${params.eNB_Credentials}", usernameVariable: 'eNB_Username', passwordVariable: 'eNB_Password'],
+        	    	    [$class: 'UsernamePasswordMultiBinding', credentialsId: "${params.UE_Credentials}", usernameVariable: 'UE_Username', passwordVariable: 'UE_Password']
+        	    	]) {
+        	    	    sh "python3 main.py --mode=InitiateHtml --eNBRepository=${eNB_Repository} --eNBBranch=${eNB_Branch} --eNBCommitID=${eNB_CommitID} --eNB_AllowMerge=${eNB_AllowMergeRequestProcess} --ADBIPAddress=${ADB_IPAddress} --ADBUserName=${ADB_Username} --ADBPassword=${ADB_Password} --eNBIPAddress=${params.eNB_IPAddress} --eNBUserName=${eNB_Username} --eNBPassword=${eNB_Password} ${mainPythonAllXmlFiles}"
+        	    	    String[] myXmlTestSuite = testXMLFile.split("\\r?\\n")
+        	    	    for (xmlFile in myXmlTestSuite) {
+        	    	    if (fileExists(xmlFile)) {
+        	    	        try {
+        	    	            sh "python3 main.py --mode=TesteNB --eNBIPAddress=${params.eNB_IPAddress} --eNBUserName=${eNB_Username} --eNBPassword=${eNB_Password} --UEIPAddress=${params.eNB_IPAddress} --UEUserName=${eNB_Username} --UEPassword=${eNB_Password} --eNBBranch=${eNB_Branch} --eNBSourceCodePath=${params.eNB_SourceCodePath} --UESourceCodePath=${params.eNB_SourceCodePath} --eNBRepository=${eNB_Repository} --eNBCommitID=${eNB_CommitID} --ADBIPAddress=${ADB_IPAddress} --EPCIPAddress=${EPC_IPAddress} --XMLTestFile=${xmlFile}"
+        	    	        } catch (Exception e) {
+        	    	            currentBuild.result = 'FAILURE'
+        	    	            buildStageStatus = false
+        	    	        }
+        	    	    }
+        	    	    }
+                            sh "python3 main.py --mode=FinalizeHtml --finalStatus=${buildStageStatus} --eNBIPAddress=${params.eNB_IPAddress} --eNBUserName=${eNB_Username} --eNBPassword=${eNB_Password}"
+        	        }
+        	    }
+                }
+            }
+	}	
+	
+        stage ("Terminate") {
+            parallel {
+        	stage('Terminate NR UE') {
+        	    steps {
+        		echo '\u2705 \u001B[32mTerminate NR UE\u001B[0m'
+                        withCredentials([
+                            [$class: 'UsernamePasswordMultiBinding', credentialsId: "${params.eNB_Credentials}", usernameVariable: 'UE_Username', passwordVariable: 'UE_Password']
+                        ]) {
+                            sh "python3 ci-scripts/main.py --mode=TerminateOAIUE --UEIPAddress=${params.eNB_IPAddress} --UEUserName=${UE_Username} --UEPassword=${UE_Password}"
+                        }
+        	    }
+        	    post {
+        		success {
+        		    script {
+        			termStatusArray[termUE] = true
+        		    }
+        		}
+        	    }
+        	}
+       	    stage('Terminate NR eNB') {
+       	        steps {
+		    echo '\u2705 \u001B[32mTerminate NR eNB\u001B[0m'
+                        withCredentials([
+                            [$class: 'UsernamePasswordMultiBinding', credentialsId: "${params.eNB_Credentials}", usernameVariable: 'eNB_Username', passwordVariable: 'eNB_Password']
+                        ]) {
+                            sh "python3 ci-scripts/main.py --mode=TerminateeNB --eNBIPAddress=${params.eNB_IPAddress} --eNBUserName=${eNB_Username} --eNBPassword=${eNB_Password}"
+                        }
+        	      }
+                    post {
+        	        success {
+                            script {
+        		        termStatusArray[termENB] = true
+        		    }
+                        }
+        	    }
+                }
+            }
+        }
+
+        stage('Log Collection') {
+            parallel {
+        	stage('Log Collection (gNB and NR UE - Build)') {
+        	    steps {
+        		withCredentials([
+        		     [$class: 'UsernamePasswordMultiBinding', credentialsId: "${params.eNB_Credentials}", usernameVariable: 'eNB_Username', passwordVariable: 'eNB_Password']
+        		]) {
+        		    echo '\u2705 \u001B[32mLog Collection (gNB and NR UE - Build)\u001B[0m'
+        		    sh "python3 ci-scripts/main.py --mode=LogCollectBuild --eNBIPAddress=${params.eNB_IPAddress} --eNBUserName=${eNB_Username} --eNBPassword=${eNB_Password} --eNBSourceCodePath=${params.eNB_SourceCodePath}"
+        
+        		    echo '\u2705 \u001B[32mLog Transfer (gNB and NR UE - Build)\u001B[0m'
+        		    sh "sshpass -p \'${eNB_Password}\' scp -o 'StrictHostKeyChecking no' -o 'ConnectTimeout 10' ${eNB_Username}@${params.eNB_IPAddress}:${eNB_SourceCodePath}/cmake_targets/build.log.zip ./build.log.${env.BUILD_ID}.zip || true"
+        		}
+        		script {
+        		    if(fileExists("build.log.${env.BUILD_ID}.zip")) {
+        			archiveArtifacts "build.log.${env.BUILD_ID}.zip"
+        		    }
+        		}
+        	    }
+        	}
+        	stage('Log Collection (gNB - Run)') {
+        	    steps {
+        		withCredentials([
+        		     [$class: 'UsernamePasswordMultiBinding', credentialsId: "${params.eNB_Credentials}", usernameVariable: 'eNB_Username', passwordVariable: 'eNB_Password']
+        		]) {
+        		    echo '\u2705 \u001B[32mLog Collection (gNB - Run)\u001B[0m'
+        		    sh "python3 ci-scripts/main.py --mode=LogCollecteNB --eNBIPAddress=${params.eNB_IPAddress} --eNBUserName=${eNB_Username} --eNBPassword=${eNB_Password} --eNBSourceCodePath=${params.eNB_SourceCodePath}"
+        
+        		    echo '\u2705 \u001B[32mLog Transfer (gNB - Run)\u001B[0m'
+        		    sh "sshpass -p \'${eNB_Password}\' scp -o 'StrictHostKeyChecking no' -o 'ConnectTimeout 10' ${eNB_Username}@${params.eNB_IPAddress}:${eNB_SourceCodePath}/cmake_targets/enb.log.zip ./enb.log.${env.BUILD_ID}.zip || true"
+        		}
+        		script {
+        		    if(fileExists("enb.log.${env.BUILD_ID}.zip")) {
+        			archiveArtifacts "enb.log.${env.BUILD_ID}.zip"
+        		    }
+        		    if(fileExists("ci-scripts/test_results.html")) {
+        			sh "mv ci-scripts/test_results.html test_results-${JOB_NAME}.html"
+        			sh "sed -i -e 's#TEMPLATE_JOB_NAME#${JOB_NAME}#' -e 's@build #TEMPLATE_BUILD_ID@build #${BUILD_ID}@' -e 's#Build-ID: TEMPLATE_BUILD_ID#Build-ID: <a href=\"${BUILD_URL}\">${BUILD_ID}</a>#' -e 's#TEMPLATE_STAGE_NAME#${testStageName}#' test_results-${JOB_NAME}.html"
+        			archiveArtifacts "test_results-${JOB_NAME}.html"
+        		    }
+        		}
+        	    }
+        	}
+        	stage('Log Collection (NR UE - Run)') {
+        	    steps {
+        		withCredentials([
+        		     [$class: 'UsernamePasswordMultiBinding', credentialsId: "${params.eNB_Credentials}", usernameVariable: 'eNB_Username', passwordVariable: 'eNB_Password']
+        		]) {
+        		    echo '\u2705 \u001B[32mLog Collection (gNB - Run)\u001B[0m'
+        		    sh "python3 ci-scripts/main.py --mode=LogCollectOAIUE --UEIPAddress=${params.eNB_IPAddress} --UEUserName=${eNB_Username} --UEPassword=${eNB_Password} --eNBIPAddress=${params.eNB_IPAddress} --eNBUserName=${eNB_Username} --eNBPassword=${eNB_Password} --UESourceCodePath=${params.eNB_SourceCodePath}"
+        
+        		    echo '\u2705 \u001B[32mLog Transfer (gNB - Run)\u001B[0m'
+        		    sh "sshpass -p \'${eNB_Password}\' scp -o 'StrictHostKeyChecking no' -o 'ConnectTimeout 10' ${eNB_Username}@${params.eNB_IPAddress}:${eNB_SourceCodePath}/cmake_targets/ue.log.zip ./ue.log.${env.BUILD_ID}.zip || true"
+        		}
+        		script {
+        		    if(fileExists("ue.log.${env.BUILD_ID}.zip")) {
+        			archiveArtifacts "ue.log.${env.BUILD_ID}.zip"
+        		    }
+        		}
+        	    }
+        	}
+            }
+        }
+    }
+
+    post {
+        always {
+            script {
+                if ("MERGE".equals(env.gitlabActionType)) {
+                    echo "This is a MERGE event"
+                } else {
+                    gitlabCommitStatus(name: "Test-gNB-nrUE") {
+                        if ((currentBuild.result == null) || (currentBuild.result == 'SUCCESS')) {
+                            echo "Setting the gitlab commit status to pass"
+                        } else {
+                            sh "./ci-scripts/fail.sh"
+                        }
+                    }
+                }
+                emailext attachmentsPattern: '*results*.html',
+                     body: '''Hi,
+Here are attached HTML report files for $PROJECT_NAME - Build # $BUILD_NUMBER - $BUILD_STATUS!
+
+Regards,
+OAI CI Team''',
+                     replyTo: 'no-reply@openairinterface.org',
+                     subject: '$PROJECT_NAME - Build # $BUILD_NUMBER - $BUILD_STATUS!',
+                     to: GIT_COMMIT_EMAIL
+	    }
+        }
+        success {
+            script {
+                def message = "OAI " + JOB_NAME + " build (" + BUILD_ID + "): passed (" + BUILD_URL + ")"
+                if ("MERGE".equals(env.gitlabActionType)) {
+                    echo "This is a MERGE event"
+                    //addGitLabMRComment comment: message
+                    def message2 = "OAI " + JOB_NAME + " build (" + BUILD_ID + "): passed (" + BUILD_URL + ") -- MergeRequest #" + env.gitlabMergeRequestIid + " (" + env.gitlabMergeRequestTitle + ")"
+                    sendSocialMediaMessage('ci-test', 'good', message2)
+                } else {
+                    sendSocialMediaMessage('ci-test', 'good', message)
+                }
+            }
+        }
+        failure {
+            script {
+                def message = "OAI " + JOB_NAME + " build (" + BUILD_ID + "): failed (" + BUILD_URL + ")"
+                if ("MERGE".equals(env.gitlabActionType)) {
+                    echo "This is a MERGE event"
+                    //addGitLabMRComment comment: message
+                    def message2 = "OAI " + JOB_NAME + " build (" + BUILD_ID + "): failed (" + BUILD_URL + ") -- MergeRequest #" + env.gitlabMergeRequestIid + " (" + env.gitlabMergeRequestTitle + ")"
+                    sendSocialMediaMessage('ci-test', 'danger', message2)
+                } else {
+                    sendSocialMediaMessage('ci-test', 'danger', message)
+                }
+            }
+        }
+    }
+}
+
diff --git a/ci-scripts/conf_files/gnb.band78.tm1.106PRB.usrpn300.conf b/ci-scripts/conf_files/gnb.band78.tm1.106PRB.usrpn300.conf
new file mode 100644
index 0000000000..e71bb00ffb
--- /dev/null
+++ b/ci-scripts/conf_files/gnb.band78.tm1.106PRB.usrpn300.conf
@@ -0,0 +1,298 @@
+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 = 208; mnc = 93; mnc_length = 2;});	 
+
+    tr_s_preference     = "local_mac"
+
+    ////////// Physical parameters:
+
+    component_carriers = (
+      {
+      node_function                                                 = "3GPP_gNODEB";
+      node_timing                                                   = "synch_to_ext_device";
+      node_synch_ref                                                = 0;
+      frame_type                                                    = "TDD";
+      DL_prefix_type                                                = "NORMAL";
+      UL_prefix_type                                                = "NORMAL";
+      eutra_band                                                    = 78;
+      downlink_frequency                                            = 3510000000L;
+      uplink_frequency_offset                                       = -120000000;
+      Nid_cell                                                      = 0;
+      N_RB_DL                                                       = 106;
+      nb_antenna_ports                                              = 1;
+      nb_antennas_tx                                                = 1;
+      nb_antennas_rx                                                = 1;
+      tx_gain                                                       = 90;
+      rx_gain                                                       = 125;
+      MIB_subCarrierSpacingCommon                                   = 30;
+      MIB_ssb_SubcarrierOffset                                      = 0;
+      MIB_dmrs_TypeA_Position                                       = 2;
+      pdcch_ConfigSIB1                                              = 0;
+      SIB1_frequencyOffsetSSB                                       = "khz5";
+      SIB1_ssb_PeriodicityServingCell                               = 5;
+      SIB1_ss_PBCH_BlockPower                                       = -60;
+      absoluteFrequencySSB                                          = 0;
+      DL_FreqBandIndicatorNR                                        = 15;
+      DL_absoluteFrequencyPointA                                    = 15;
+      DL_offsetToCarrier                                            = 15;
+      DL_SCS_SubcarrierSpacing                                      = "kHz30";
+      DL_SCS_SpecificCarrier_k0                                     = 0;
+      DL_carrierBandwidth                                           = 15;
+      DL_locationAndBandwidth                                       = 15;
+      DL_BWP_SubcarrierSpacing                                      = "kHz30";
+      DL_BWP_prefix_type                                            = "NORMAL";
+      UL_FreqBandIndicatorNR                                        = 15;
+      UL_absoluteFrequencyPointA                                    = 13;
+      UL_additionalSpectrumEmission                                 = 3;
+      UL_p_Max                                                      = -1;
+      UL_frequencyShift7p5khz                                       = "TRUE";
+      UL_offsetToCarrier                                            = 10;
+      UL_SCS_SubcarrierSpacing                                      = "kHz30";
+      UL_SCS_SpecificCarrier_k0                                     = 0;
+      UL_carrierBandwidth                                           = 15;
+      UL_locationAndBandwidth                                       = 15;
+      UL_BWP_SubcarrierSpacing                                      = "kHz30";
+      UL_BWP_prefix_type                                            = "NORMAL";
+      UL_timeAlignmentTimerCommon                                   = "infinity";
+      ServingCellConfigCommon_n_TimingAdvanceOffset                 = "n0"
+      ServingCellConfigCommon_ssb_PositionsInBurst_PR               = 0x01;
+      ServingCellConfigCommon_ssb_periodicityServingCell            = 10;
+      ServingCellConfigCommon_dmrs_TypeA_Position                   = 2;
+      NIA_SubcarrierSpacing                                         = "kHz15"; 
+      ServingCellConfigCommon_ss_PBCH_BlockPower                    = -60;
+      referenceSubcarrierSpacing                                    = "kHz15";
+      dl_UL_TransmissionPeriodicity                                 = "ms0p5";
+      nrofDownlinkSlots                                             = 10;
+      nrofDownlinkSymbols                                           = 10;
+      nrofUplinkSlots                                               = 10;
+      nrofUplinkSymbols                                             = 10;
+      rach_totalNumberOfRA_Preambles                                = 63;
+      rach_ssb_perRACH_OccasionAndCB_PreamblesPerSSB_choice         = "oneEighth";
+      rach_ssb_perRACH_OccasionAndCB_PreamblesPerSSB_oneEighth      = 4;
+      rach_ssb_perRACH_OccasionAndCB_PreamblesPerSSB_oneFourth      = 8;
+      rach_ssb_perRACH_OccasionAndCB_PreamblesPerSSB_oneHalf        = 16;
+      rach_ssb_perRACH_OccasionAndCB_PreamblesPerSSB_one            = 24;
+      rach_ssb_perRACH_OccasionAndCB_PreamblesPerSSB_two            = 32;
+      rach_ssb_perRACH_OccasionAndCB_PreamblesPerSSB_four           = 8;
+      rach_ssb_perRACH_OccasionAndCB_PreamblesPerSSB_eight          = 4;
+      rach_ssb_perRACH_OccasionAndCB_PreamblesPerSSB_sixteen        = 2;
+      rach_groupBconfigured                                         = "ENABLE";
+      rach_ra_Msg3SizeGroupA                                        = 56;
+      rach_messagePowerOffsetGroupB                                 = "dB0";
+      rach_numberOfRA_PreamblesGroupA                               = 32;
+      rach_ra_ContentionResolutionTimer                             = 8;
+      rsrp_ThresholdSSB                                             = 64;
+      rsrp_ThresholdSSB_SUL                                         = 64;
+      prach_RootSequenceIndex_choice                                = "l839";
+      prach_RootSequenceIndex_l839                                  = 0;
+      prach_RootSequenceIndex_l139                                  = 0;
+      prach_msg1_SubcarrierSpacing                                  = "kHz30";
+      restrictedSetConfig                                           = "unrestrictedSet";
+      msg3_transformPrecoding                                       = "ENABLE";
+      prach_ConfigurationIndex                                      = 10;
+      prach_msg1_FDM                                                = "one";
+      prach_msg1_FrequencyStart                                     = 10;
+      zeroCorrelationZoneConfig                                     = 10;
+      preambleReceivedTargetPower                                   = -150;
+      preambleTransMax                                              = 6;
+      powerRampingStep                                              = "dB0";
+      ra_ResponseWindow                                             = 8;
+      groupHoppingEnabledTransformPrecoding                         = "ENABLE";
+      msg3_DeltaPreamble                                            = 0;
+      p0_NominalWithGrant                                           = 0;
+      PUSCH_TimeDomainResourceAllocation_k2                         = 0;
+      PUSCH_TimeDomainResourceAllocation_mappingType                = "typeA";
+      PUSCH_TimeDomainResourceAllocation_startSymbolAndLength       = 0;
+      pucch_ResourceCommon                                          = 0;
+      pucch_GroupHopping                                            = "neither";
+      hoppingId                                                     = 0;
+      p0_nominal                                                    = -30;
+      PDSCH_TimeDomainResourceAllocation_k0                         = 2;
+      PDSCH_TimeDomainResourceAllocation_mappingType                = "typeA";
+      PDSCH_TimeDomainResourceAllocation_startSymbolAndLength       = 0;
+      rateMatchPatternId                                            = 0;
+      RateMatchPattern_patternType                                  = "bitmaps";
+      symbolsInResourceBlock                                        = "oneSlot";
+      periodicityAndPattern                                         = 2;
+      RateMatchPattern_controlResourceSet                           = 5;
+      RateMatchPattern_subcarrierSpacing                            = "kHz30";
+      RateMatchPattern_mode                                         = "dynamic";
+      controlResourceSetZero                                        = 0;
+      searchSpaceZero                                               = 0;
+      searchSpaceSIB1                                               = 10;
+      searchSpaceOtherSystemInformation                             = 10;
+      pagingSearchSpace                                             = 10;
+      ra_SearchSpace                                                = 10;
+      PDCCH_common_controlResourceSetId                             = 5;
+      PDCCH_common_ControlResourceSet_duration                      = 2;
+      PDCCH_cce_REG_MappingType                                     = "nonInterleaved";
+      PDCCH_reg_BundleSize                                          = 3;
+      PDCCH_interleaverSize                                         = 3;
+      PDCCH_shiftIndex                                              = 10;  
+      PDCCH_precoderGranularity                                     = "sameAsREG-bundle";
+      PDCCH_TCI_StateId                                             = 32;
+      tci_PresentInDCI                                              = "ENABLE";
+      PDCCH_DMRS_ScramblingID                                       = 0;
+      SearchSpaceId                                                 = 10;
+      commonSearchSpaces_controlResourceSetId                       = 5;
+      SearchSpace_monitoringSlotPeriodicityAndOffset_choice         = "sl1";
+      SearchSpace_monitoringSlotPeriodicityAndOffset_value          = 0;
+      SearchSpace_duration                                          = 2;
+      SearchSpace_nrofCandidates_aggregationLevel1                  = 0;
+      SearchSpace_nrofCandidates_aggregationLevel2                  = 0;
+      SearchSpace_nrofCandidates_aggregationLevel4                  = 0;
+      SearchSpace_nrofCandidates_aggregationLevel8                  = 0;
+      SearchSpace_nrofCandidates_aggregationLevel16                 = 0;
+      SearchSpace_searchSpaceType                                   = "common";
+      Common_dci_Format2_0_nrofCandidates_SFI_aggregationLevel1     = 1;
+      Common_dci_Format2_0_nrofCandidates_SFI_aggregationLevel2     = 1;
+      Common_dci_Format2_0_nrofCandidates_SFI_aggregationLevel4     = 1;
+      Common_dci_Format2_0_nrofCandidates_SFI_aggregationLevel8     = 1;
+      Common_dci_Format2_0_nrofCandidates_SFI_aggregationLevel16    = 1; 
+      Common_dci_Format2_3_monitoringPeriodicity                    = 1;
+      Common_dci_Format2_3_nrofPDCCH_Candidates                     = 1;
+      ue_Specific__dci_Formats                                      = "formats0-0-And-1-0";
+      RateMatchPatternLTE_CRS_carrierFreqDL                         = 6;
+      RateMatchPatternLTE_CRS_carrierBandwidthDL                    = 6;
+      RateMatchPatternLTE_CRS_nrofCRS_Ports                         = 1;
+      RateMatchPatternLTE_CRS_v_Shift                               = 0;
+      RateMatchPatternLTE_CRS_radioframeAllocationPeriod            = 1;
+      RateMatchPatternLTE_CRS_radioframeAllocationOffset            = 0;
+      RateMatchPatternLTE_CRS_subframeAllocation_choice             = "oneFrame";
+      }
+    );
+
+
+    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;
+    };
+
+
+    ////////// MME parameters:
+    mme_ip_address      = ( { ipv4       = "192.168.12.26";
+                              ipv6       = "192:168:30::17";
+                              active     = "yes";
+                              preference = "ipv4";
+                            }
+                          );
+
+    NETWORK_INTERFACES :
+    {
+
+        GNB_INTERFACE_NAME_FOR_S1_MME            = "eth0";
+        GNB_IPV4_ADDRESS_FOR_S1_MME              = "192.168.12.111/24";
+        GNB_INTERFACE_NAME_FOR_S1U               = "eth0";
+        GNB_IPV4_ADDRESS_FOR_S1U                 = "192.168.12.111/24";
+        GNB_PORT_FOR_S1U                         = 2152; # Spec 2152
+    };
+  }
+);
+
+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];
+	 sdr_addrs = "addr=192.168.20.2,second_addr=192.168.10.2,mgmt_addr=192.168.20.2,clock_source=external,time_source=external";
+
+    }
+);  
+
+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";
+    #two option for worker "WORKER_DISABLE" or "WORKER_ENABLE"
+    worker_config      = "WORKER_ENABLE";
+  }
+);
+
+NETWORK_CONTROLLER :
+{
+    FLEXRAN_ENABLED        = "no";
+    FLEXRAN_INTERFACE_NAME = "lo";
+    FLEXRAN_IPV4_ADDRESS   = "127.0.0.1";
+    FLEXRAN_PORT           = 2210;
+    FLEXRAN_CACHE          = "/mnt/oai_agent_cache";
+    FLEXRAN_AWAIT_RECONF   = "no";
+};
+
+     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";
+    };
+
diff --git a/ci-scripts/main.py b/ci-scripts/main.py
index 70bfa1894f..d94fe73a7d 100644
--- a/ci-scripts/main.py
+++ b/ci-scripts/main.py
@@ -1,3 +1,4 @@
+# dummy commit
 #/*
 # * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
 # * contributor license agreements.  See the NOTICE file distributed with
@@ -43,6 +44,9 @@ ENB_PROCESS_SEG_FAULT = -11
 ENB_PROCESS_ASSERTION = -12
 ENB_PROCESS_REALTIME_ISSUE = -13
 ENB_PROCESS_NOLOGFILE_TO_ANALYZE = -14
+UE_PROCESS_NOLOGFILE_TO_ANALYZE = -20
+UE_PROCESS_COULD_NOT_SYNC = -21
+UE_PROCESS_ASSERTION = -22
 HSS_PROCESS_FAILED = -2
 HSS_PROCESS_OK = +2
 MME_PROCESS_FAILED = -3
@@ -64,6 +68,7 @@ import xml.etree.ElementTree as ET
 import logging
 import datetime
 import signal
+#import platform
 from multiprocessing import Process, Lock, SimpleQueue
 logging.basicConfig(
 	level=logging.DEBUG,
@@ -98,8 +103,11 @@ class SSHConnection():
 		self.desc = ''
 		self.Build_eNB_args = ''
 		self.Initialize_eNB_args = ''
+		self.air_interface = 'lte'
 		self.eNBLogFile = ''
 		self.eNB_instance = ''
+		self.eNBOptions = ''
+		self.rruOptions = ''
 		self.ping_args = ''
 		self.ping_packetloss_threshold = ''
 		self.iperf_args = ''
@@ -120,13 +128,25 @@ class SSHConnection():
 		self.htmlTabNames = []
 		self.htmlTabIcons = []
 		self.finalStatus = False
+		self.OsVersion = ''
+		self.KernelVersion = ''
+		self.UhdVersion = ''
+		self.UsrpBoard = ''
+		self.CpuNb = ''
+		self.CpuModel = ''
+		self.CpuMHz = ''
+		self.UEIPAddress = ''
+		self.UEUserName = ''
+		self.UEPassword = ''
+		self.UE_instance = ''
+		self.UELogFile = ''
+		self.UESourceCodePath = ''
+		self.Build_OAI_UE_args = ''
+		self.Initialize_OAI_UE_args = ''
+		self.Initialize_OAI_eNB_args = ''
+		self.clean_repository = True
 		self.eNBOsVersion = ''
-		self.eNBKernelVersion = ''
-		self.eNBUhdVersion = ''
-		self.eNBCpuNb = ''
-		self.eNBCpuModel = ''
-		self.eNBCpuMHz = ''
-
+		
 	def open(self, ipaddress, username, password):
 		count = 0
 		connect_status = False
@@ -321,11 +341,48 @@ class SSHConnection():
 		self.command('mkdir -p build_log_' + self.testCase_id, '\$', 5)
 		self.command('mv log/* ' + 'build_log_' + self.testCase_id, '\$', 5)
 		self.command('mv compile_oai_enb.log ' + 'build_log_' + self.testCase_id, '\$', 5)
-		# Workaround to run with develop-nr
-		self.command('if [ -e ran_build ]; then cp -rf ran_build lte_build_oai; fi', '\$', 30)
 		self.close()
 		self.CreateHtmlTestRow(self.Build_eNB_args, 'OK', ALL_PROCESSES_OK)
 
+	def BuildOAIUE(self):
+		if self.UEIPAddress == '' or self.eNBRepository == '' or self.eNBBranch == '' or self.UEUserName == '' or self.UEPassword == '' or self.UESourceCodePath == '':
+			Usage()
+			sys.exit('Insufficient Parameter')
+		self.open(self.UEIPAddress, self.UEUserName, self.UEPassword)
+		self.command('mkdir -p ' + self.UESourceCodePath, '\$', 5)
+		self.command('cd ' + self.UESourceCodePath, '\$', 5)
+		self.command('if [ ! -e .git ]; then stdbuf -o0 git clone ' + self.eNBRepository + ' .; else stdbuf -o0 git fetch; fi', '\$', 600)
+		# here add a check if git clone or git fetch went smoothly
+		self.command('git config user.email "jenkins@openairinterface.org"', '\$', 5)
+		self.command('git config user.name "OAI Jenkins"', '\$', 5)
+		if self.clean_repository:
+			pass
+			self.command('echo ' + self.UEPassword + ' | sudo -S git clean -x -d -ff', '\$', 30)
+		# if the commit ID is provided use it to point to it
+		if self.eNBCommitID != '':
+			self.command('git checkout -f ' + self.eNBCommitID, '\$', 5)
+		# if the branch is not develop, then it is a merge request and we need to do 
+		# the potential merge. Note that merge conflicts should already been checked earlier
+		if (self.eNB_AllowMerge):
+			if self.eNBTargetBranch == '':
+				if (self.eNBBranch != 'develop') and (self.eNBBranch != 'origin/develop'):
+					self.command('git merge --ff origin/develop -m "Temporary merge for CI"', '\$', 5)
+			else:
+				logging.debug('Merging with the target branch: ' + self.eNBTargetBranch)
+				self.command('git merge --ff origin/' + self.eNBTargetBranch + ' -m "Temporary merge for CI"', '\$', 5)
+		self.command('source oaienv', '\$', 5)
+		self.command('cd cmake_targets', '\$', 5)
+		self.command('mkdir -p log', '\$', 5)
+		self.command('chmod 777 log', '\$', 5)
+		# no need to remove in log (git clean did the trick)
+		self.command('stdbuf -o0 ./build_oai ' + self.Build_OAI_UE_args + ' 2>&1 | stdbuf -o0 tee -a compile_oai_ue.log', 'Bypassing the Tests', 600)
+		self.command('mkdir -p build_log_' + self.testCase_id, '\$', 5)
+		self.command('mv log/* ' + 'build_log_' + self.testCase_id, '\$', 5)
+		self.command('mv compile_oai_ue.log ' + 'build_log_' + self.testCase_id, '\$', 5)
+		self.close()
+		self.CreateHtmlTestRow(self.Build_OAI_UE_args, 'OK', ALL_PROCESSES_OK, 'OAI UE')
+
+
 	def InitializeHSS(self):
 		if self.EPCIPAddress == '' or self.EPCUserName == '' or self.EPCPassword == '' or self.EPCSourceCodePath == '' or self.EPCType == '':
 			Usage()
@@ -411,6 +468,7 @@ class SSHConnection():
 		self.command('cd ' + self.eNBSourceCodePath, '\$', 5)
 		# Initialize_eNB_args usually start with -O and followed by the location in repository
 		full_config_file = self.Initialize_eNB_args.replace('-O ','')
+		extra_options = ''
 		extIdx = full_config_file.find('.conf')
 		if (extIdx > 0):
 			extra_options = full_config_file[extIdx + 5:]
@@ -431,6 +489,16 @@ class SSHConnection():
 		result = re.search('rru', str(config_file))
 		if result is not None:
 			rruCheck = True
+		# do not reset board twice in IF4.5 case
+		result = re.search('rru|enb', str(config_file))
+		if result is not None:
+			self.command('echo ' + self.eNBPassword + ' | sudo -S uhd_find_devices', '\$', 30)
+			result = re.search('type: b200', str(self.ssh.before))
+			if result is not None:
+				logging.debug('Found a B2xx device --> resetting it')
+				self.command('echo ' + self.eNBPassword + ' | sudo -S sudo b2xx_fx3_utils --reset-device', '\$', 5)
+				# Reloading FGPA bin firmware
+				self.command('echo ' + self.eNBPassword + ' | sudo -S uhd_find_devices', '\$', 30)
 		# Make a copy and adapt to EPC / eNB IP addresses
 		self.command('cp ' + full_config_file + ' ' + ci_full_config_file, '\$', 5)
 		self.command('sed -i -e \'s/CI_MME_IP_ADDR/' + self.EPCIPAddress + '/\' ' + ci_full_config_file, '\$', 2);
@@ -438,12 +506,20 @@ class SSHConnection():
 		# Launch eNB with the modified config file
 		self.command('source oaienv', '\$', 5)
 		self.command('cd cmake_targets', '\$', 5)
-		self.command('echo "ulimit -c unlimited && ./lte_build_oai/build/lte-softmodem -O ' + self.eNBSourceCodePath + '/' + ci_full_config_file + extra_options + '" > ./my-lte-softmodem-run' + str(self.eNB_instance) + '.sh ', '\$', 5)
+		self.command('echo "ulimit -c unlimited && ./ran_build/build/' + self.air_interface + '-softmodem -O ' + self.eNBSourceCodePath + '/' + ci_full_config_file + extra_options + '" > ./my-lte-softmodem-run' + str(self.eNB_instance) + '.sh ', '\$', 5)
 		self.command('chmod 775 ./my-lte-softmodem-run' + str(self.eNB_instance) + '.sh ', '\$', 5)
-		self.command('echo ' + self.eNBPassword + ' | sudo -S rm -Rf enb_' + self.testCase_id + '.log', '\$', 5)
-		self.command('echo ' + self.eNBPassword + ' | sudo -S -E daemon --inherit --unsafe --name=enb' + str(self.eNB_instance) + '_daemon --chdir=' + self.eNBSourceCodePath + '/cmake_targets -o ' + self.eNBSourceCodePath + '/cmake_targets/enb_' + self.testCase_id + '.log ./my-lte-softmodem-run' + str(self.eNB_instance) + '.sh', '\$', 5)
+		self.command('echo ' + self.eNBPassword + ' | sudo -S rm -Rf enb_' + self.testCase_id + '.log', '\$', 5)				
+		#to use daemon on CentOS we need to source the function
+		#linux_distro = platform.linux_distribution()[0]
+		#if re.match('(.*)CentOS(.*)', linux_distro, re.IGNORECASE):
+		#self.command('source /etc/init.d/functions', '\$', 5)
+		#use nohup instead of daemon
+		#self.command('echo ' + self.eNBPassword + ' | sudo -S -E daemon --inherit --unsafe --name=enb' + str(self.eNB_instance) + '_daemon --chdir=' + self.eNBSourceCodePath + '/cmake_targets -o ' + self.eNBSourceCodePath + '/cmake_targets/enb_' + self.testCase_id + '.log ./my-lte-softmodem-run' + str(self.eNB_instance) + '.sh', '\$', 5)
+		self.command('echo $USER; nohup sudo ./my-lte-softmodem-run' + str(self.eNB_instance) + '.sh' + ' > ' + self.eNBSourceCodePath + '/cmake_targets/enb_' + self.testCase_id + '.log' + ' 2>&1 &', self.eNBUserName, 5)		
 		if not rruCheck:
 			self.eNBLogFile = 'enb_' + self.testCase_id + '.log'
+			if extra_options != '':
+				self.eNBOptions = extra_options
 		time.sleep(6)
 		doLoop = True
 		loopCounter = 10
@@ -482,6 +558,8 @@ class SSHConnection():
 					time.sleep(6)
 				else:
 					doLoop = False
+					if rruCheck and extra_options != '':
+						self.rruOptions = extra_options
 					self.CreateHtmlTestRow('-O ' + config_file + extra_options, 'OK', ALL_PROCESSES_OK)
 					logging.debug('\u001B[1m Initialize eNB Completed\u001B[0m')
 
@@ -517,6 +595,165 @@ class SSHConnection():
 			job.join()
 		self.CreateHtmlTestRow('N/A', 'OK', ALL_PROCESSES_OK)
 
+	def InitializeOAIUE(self):
+		if self.UEIPAddress == '' or self.UEUserName == '' or self.UEPassword == '' or self.UESourceCodePath == '':
+			Usage()
+			sys.exit('Insufficient Parameter')
+		#initialize_OAI_UE_flag = True
+		#pStatus = self.CheckOAIUEProcessExist(initialize_OAI_UE_flag)
+		#if (pStatus < 0):
+		#	self.CreateHtmlTestRow(self.Initialize_OAI_UE_args, 'KO', pStatus)
+		#	self.CreateHtmlTabFooter(False)
+		#	sys.exit(1)
+		self.open(self.UEIPAddress, self.UEUserName, self.UEPassword)
+		# b2xx_fx3_utils reset procedure
+		self.command('echo ' + self.UEPassword + ' | sudo -S uhd_find_devices', '\$', 30)
+		result = re.search('type: n3xx', str(self.ssh.before))
+		if result is not None:
+			pass
+			logging.debug('Found a B2xx device --> resetting it')
+			self.command('echo ' + self.UEPassword + ' | sudo -S sudo b2xx_fx3_utils --reset-device', '\$', 5)
+			# Reloading FGPA bin firmware
+			self.command('echo ' + self.UEPassword + ' | sudo -S uhd_find_devices', '\$', 30)
+		else:
+			logging.debug('Did not find any B2xx device')
+		self.command('cd ' + self.UESourceCodePath, '\$', 5)
+		# Initialize_OAI_UE_args usually start with -C and followed by the location in repository
+		self.command('source oaienv', '\$', 5)
+		self.command('cd cmake_targets/ran_build/build', '\$', 5)
+		self.command('echo "ulimit -c unlimited && ./'+ self.air_interface +'-uesoftmodem ' + self.Initialize_OAI_UE_args + '" > ./my-lte-uesoftmodem-run' + str(self.UE_instance) + '.sh', '\$', 5)
+		self.command('chmod 775 ./my-lte-uesoftmodem-run' + str(self.UE_instance) + '.sh', '\$', 5)
+		self.command('echo ' + self.UEPassword + ' | sudo -S rm -Rf ' + self.UESourceCodePath + '/cmake_targets/ue_' + self.testCase_id + '.log', '\$', 5)
+		#to use daemon on CentOS we need to source the function
+		#linux_distro = platform.linux_distribution()[0]		
+		#if re.match('(.*)CentOS(.*)', linux_distro, re.IGNORECASE):
+			#self.command('source /etc/init.d/functions', '\$', 5)
+		#use nohup instead of daemon
+		self.command('echo $USER; nohup sudo ./my-lte-uesoftmodem-run' + str(self.UE_instance) + '.sh' + ' > ' + self.UESourceCodePath + '/cmake_targets/ue_' + self.testCase_id + '.log ' + ' 2>&1 &', self.UEUserName, 5)
+		#self.command('echo ' + self.UEPassword + ' | sudo -S -E daemon --inherit --unsafe --name=ue' + str(self.UE_instance) + '_daemon --chdir=' + self.UESourceCodePath + '/cmake_targets/ran_build/build -o ' + self.UESourceCodePath + '/cmake_targets/ue_' + self.testCase_id + '.log ./my-lte-uesoftmodem-run' + str(self.UE_instance) + '.sh', '\$', 5)
+		self.UELogFile = 'ue_' + self.testCase_id + '.log'
+		time.sleep(6)
+		self.command('cd ../..', '\$', 5)
+		doLoop = True
+		loopCounter = 10
+		while (doLoop):
+			loopCounter = loopCounter - 1
+			if (loopCounter == 0):
+				self.close()
+				doLoop = False
+				logging.error('\u001B[1;37;41m UE logging system did not show got sync! \u001B[0m')
+				self.CreateHtmlTestRow(self.Initialize_OAI_UE_args, 'KO', ALL_PROCESSES_OK, 'OAI UE')
+				self.CreateHtmlTabFooter(False)
+				sys.exit(1)
+			else:
+				self.command('stdbuf -o0 cat ' + self.UELogFile + ' | egrep --text --color=never -i "wait|sync"', '\$', 4)
+				if self.air_interface == 'nr':
+					result = re.search('Starting sync detection', str(self.ssh.before))
+				else:
+					result = re.search('got sync', str(self.ssh.before))
+				if result is None:
+					time.sleep(10)
+				else:
+					doLoop = False
+					self.CreateHtmlTestRow(self.Initialize_OAI_UE_args, 'OK', ALL_PROCESSES_OK, 'OAI UE')
+					logging.debug('\u001B[1m Initialize OAI UE Completed\u001B[0m')
+		self.close()
+
+	def InitializeOAIeNB(self):
+		if self.eNBIPAddress == '' or self.eNBUserName == '' or self.eNBPassword == '' or self.eNBSourceCodePath == '':
+			Usage()
+			sys.exit('Insufficient Parameter')
+		#initialize_OAI_eNB_flag = True
+		#pStatus = self.CheckOAIeNBProcessExist(initialize_OAI_eNB_flag)
+		#if (pStatus < 0):
+		#	self.CreateHtmlTestRow(self.Initialize_OAI_eNB_args, 'KO', pStatus)
+		#	self.CreateHtmlTabFooter(False)
+		#	sys.exit(1)
+		self.open(self.eNBIPAddress, self.eNBUserName, self.eNBPassword)
+		self.command('cd ' + self.eNBSourceCodePath, '\$', 5)
+		# Initialize_OAI_eNB_args usually start with -C and followed by the location in repository
+		#full_config_file = self.Initialize_OAI_eNB_args.replace('-O ','')
+		#extIdx = full_config_file.find('.conf')
+		#if (extIdx > 0):
+		#	extra_options = full_config_file[extIdx + 5:]
+		#	# if tracer options is on, compiling and running T Tracer
+		#	result = re.search('T_stdout', str(extra_options))
+		##	if result is not None:
+		#		logging.debug('\u001B[1m Compiling and launching T Tracer\u001B[0m')
+		#		self.command('cd common/utils/T/tracer', '\$', 5)
+		#		self.command('make', '\$', 10)
+		#		self.command('echo $USER; nohup ./record -d ../T_messages.txt -o ' + self.eNBSourceCodePath + '/cmake_targets/enb_' + self.testCase_id + '_record.raw -ON -off VCD -off HEAVY -off LEGACY_GROUP_TRACE -off LEGACY_GROUP_DEBUG > ' + self.eNBSourceCodePath + '/cmake_targets/enb_' + self.testCase_id + '_record.log 2>&1 &', self.eNBUserName, 5)
+		#		self.command('cd ' + self.eNBSourceCodePath, '\$', 5)
+		#	full_config_file = full_config_file[:extIdx + 5]
+		#	config_path, config_file = os.path.split(full_config_file)
+		#ci_full_config_file = config_path + '/ci-' + config_file
+		#rruCheck = False
+		#result = re.search('rru', str(config_file))
+		#if result is not None:
+		#	rruCheck = True
+		## Make a copy and adapt to EPC / eNB IP addresses
+		#self.command('cp ' + full_config_file + ' ' + ci_full_config_file, '\$', 5)
+		#self.command('sed -i -e \'s/CI_eNB_IP_ADDR/' + self.eNBIPAddress + '/\' ' + ci_full_config_file, '\$', 2);
+		# Launch eNB with the modified config file
+		self.command('source oaienv', '\$', 5)
+		self.command('cd cmake_targets/ran_build/build', '\$', 5)
+		#self.command('echo "ulimit -c unlimited && ./' + self.air_interface + '-softmodem ' + self.Initialize_OAI_eNB_args + '" > ./my-lte-softmodem-run' + str(self.eNB_instance) + '.sh', '\$', 5)
+		self.eNBLogFile = 'enb_' + self.testCase_id + '.log'
+		self.command('echo "ulimit -c unlimited && ./' + self.air_interface + '-softmodem ' + self.Initialize_OAI_eNB_args + '|& tee ' + self.eNBSourceCodePath + '/cmake_targets/' + self.eNBLogFile + '" > ./my-lte-softmodem-run' + str(self.eNB_instance) + '.sh', '\$', 5)
+		self.command('chmod 775 ./my-lte-softmodem-run' + str(self.eNB_instance) + '.sh', '\$', 5)
+		self.command('echo ' + self.eNBPassword + ' | sudo -S rm -Rf ' + self.eNBSourceCodePath + '/cmake_targets/enb_' + self.testCase_id + '.log', '\$', 5)
+		#to use daemon on CentOS we need to source the function
+		#linux_distro = platform.linux_distribution()[0]		
+		#if re.match('(.*)CentOS(.*)', linux_distro, re.IGNORECASE):
+			#self.command('source /etc/init.d/functions', '\$', 5)
+		#use nohup instead of daemon
+		self.command('echo $USER; nohup sudo ./my-lte-softmodem-run' + str(self.eNB_instance) + '.sh' + ' > ' + self.eNBSourceCodePath + '/cmake_targets/enb_' + self.testCase_id + '.log' + ' 2>&1 &', self.eNBUserName, 5)
+		#self.command('echo ' + self.eNBPassword + ' | sudo -S -E daemon --inherit --unsafe --name=enb' + str(self.eNB_instance) + '_daemon --chdir=' + self.eNBSourceCodePath + '/cmake_targets/ran_build/build -o ' + self.eNBSourceCodePath + '/cmake_targets/enb_' + self.testCase_id + '.log ./my-lte-softmodem-run' + str(self.eNB_instance) + '.sh', '\$', 5)
+		time.sleep(6)
+		self.command('cd ../..', '\$', 5)
+		doLoop = True
+		loopCounter = 10
+		print('gNB log file: ' + self.eNBLogFile)
+		while (doLoop):
+			loopCounter = loopCounter - 1
+			if (loopCounter == 0):
+				# In case of T tracer recording, we may need to kill it
+				#result = re.search('T_stdout', str(self.Initialize_OAI_eNB_args))
+				#if result is not None:
+				#	self.command('killall --signal SIGKILL record', '\$', 5)
+				self.close()
+				doLoop = False
+				logging.error('\u001B[1;37;41m eNB logging system did not show got sync! \u001B[0m')
+				self.CreateHtmlTestRow(self.Initialize_OAI_eNB_args, 'KO', ALL_PROCESSES_OK, 'OAI eNB')
+				self.CreateHtmlTabFooter(False)
+				## In case of T tracer recording, we need to kill tshark on EPC side
+				#result = re.search('T_stdout', str(self.Initialize_OAI_eNB_args))
+				#if result is not None:
+				#	self.open(self.EPCIPAddress, self.EPCUserName, self.EPCPassword)
+				#	logging.debug('\u001B[1m Stopping tshark \u001B[0m')
+				#	self.command('echo ' + self.EPCPassword + ' | sudo -S killall --signal SIGKILL tshark', '\$', 5)
+				#	self.close()
+				#	time.sleep(1)
+				#	pcap_log_file = 'enb_' + self.testCase_id + '_s1log.pcap'
+				#	copyin_res = self.copyin(self.EPCIPAddress, self.EPCUserName, self.EPCPassword, '/tmp/' + pcap_log_file, '.')
+				#	if (copyin_res == 0):
+				#		self.copyout(self.eNBIPAddress, self.eNBUserName, self.eNBPassword, pcap_log_file, self.eNBSourceCodePath + '/cmake_targets/.')
+				sys.exit(1)
+			else:
+				#print('current directory: ' + os.getcwd())
+				#self.command('pwd', '\$', 4)
+				#print('self.command pwd: ' + str(self.ssh.before))
+				self.command('stdbuf -o0 cat ' + self.eNBLogFile + ' | egrep --text --color=never -i "wait|sync"', '\$', 30)
+				#print(self.ssh.before)
+				result = re.search('got sync', str(self.ssh.before))
+				if result is None:
+					time.sleep(11)
+				else:
+					doLoop = False
+					self.CreateHtmlTestRow(self.Initialize_OAI_eNB_args, 'OK', ALL_PROCESSES_OK, 'OAI eNB')
+					logging.debug('\u001B[1m Initialize OAI eNB Completed\u001B[0m')
+		self.close()
+
 	def checkDevTTYisUnlocked(self):
 		self.open(self.ADBIPAddress, self.ADBUserName, self.ADBPassword)
 		count = 0
@@ -604,21 +841,150 @@ class SSHConnection():
 		time.sleep(4)
 		# We should check if we register
 		count = 0
-		while count < 3:
+		attach_cnt = 0
+		attach_status = False
+		while count < 5:
 			self.command('AT+CEREG?', 'OK', 5)
-			result = re.search('CEREG: 2,(?P<state>[0-9\-]+)', str(self.ssh.before))
+			result = re.search('CEREG: 2,(?P<state>[0-9\-]+),', str(self.ssh.before))
 			if result is not None:
 				mDataConnectionState = int(result.group('state'))
 				if mDataConnectionState is not None:
-					logging.debug('+CEREG: 2,' + str(mDataConnectionState))
+					if mDataConnectionState == 1:
+						count = 10
+						attach_status = True
+						result = re.search('CEREG: 2,1,"(?P<networky>[0-9A-Z]+)","(?P<networkz>[0-9A-Z]+)"', str(self.ssh.before))
+						if result is not None:
+							networky = result.group('networky')
+							networkz = result.group('networkz')
+							logging.debug('\u001B[1m CAT-M module attached to eNB (' + str(networky) + '/' + str(networkz) + ')\u001B[0m')
+						else:
+							logging.debug('\u001B[1m CAT-M module attached to eNB\u001B[0m')
+					else:
+						logging.debug('+CEREG: 2,' + str(mDataConnectionState))
+						attach_cnt = attach_cnt + 1
 			else:
 				logging.debug(str(self.ssh.before))
+				attach_cnt = attach_cnt + 1
 			count = count + 1
 			time.sleep(1)
+		if attach_status:
+			self.command('AT+CESQ', 'OK', 5)
+			result = re.search('CESQ: 99,99,255,255,(?P<rsrq>[0-9]+),(?P<rsrp>[0-9]+)', str(self.ssh.before))
+			if result is not None:
+				nRSRQ = int(result.group('rsrq'))
+				nRSRP = int(result.group('rsrp'))
+				if (nRSRQ is not None) and (nRSRP is not None):
+					logging.debug('    RSRQ = ' + str(-20+(nRSRQ/2)) + ' dB')
+					logging.debug('    RSRP = ' + str(-140+nRSRP) + ' dBm')
 		self.close()
 		self.picocom_closure = False
-		self.CreateHtmlTestRow('N/A', 'OK', ALL_PROCESSES_OK)
+		html_queue = SimpleQueue()
 		self.checkDevTTYisUnlocked()
+		if attach_status:
+			html_cell = '<pre style="background-color:white">CAT-M module\nAttachment Completed in ' + str(attach_cnt+4) + ' seconds'
+			if (nRSRQ is not None) and (nRSRP is not None):
+				html_cell += '\n   RSRQ = ' + str(-20+(nRSRQ/2)) + ' dB'
+				html_cell += '\n   RSRP = ' + str(-140+nRSRP) + ' dBm</pre>'
+			else:
+				html_cell += '</pre>'
+			html_queue.put(html_cell)
+			self.CreateHtmlTestRowQueue('N/A', 'OK', 1, html_queue)
+		else:
+			html_cell = '<pre style="background-color:white">CAT-M module\nAttachment Failed</pre>'
+			html_queue.put(html_cell)
+			self.CreateHtmlTestRowQueue('N/A', 'KO', 1, html_queue)
+
+	def PingCatM(self):
+		if self.EPCIPAddress == '' or self.EPCUserName == '' or self.EPCPassword == '' or self.EPCSourceCodePath == '':
+			Usage()
+			sys.exit('Insufficient Parameter')
+		initialize_eNB_flag = False
+		pStatus = self.CheckProcessExist(initialize_eNB_flag)
+		if (pStatus < 0):
+			self.CreateHtmlTestRow(self.ping_args, 'KO', pStatus)
+			self.CreateHtmlTabFooter(False)
+			sys.exit(1)
+		try:
+			statusQueue = SimpleQueue()
+			lock = Lock()
+			self.open(self.EPCIPAddress, self.EPCUserName, self.EPCPassword)
+			self.command('cd ' + self.EPCSourceCodePath, '\$', 5)
+			self.command('cd scripts', '\$', 5)
+			if re.match('OAI', self.EPCType, re.IGNORECASE):
+				logging.debug('Using the OAI EPC HSS: not implemented yet')
+				self.CreateHtmlTestRow(self.ping_args, 'KO', pStatus)
+				self.CreateHtmlTabFooter(False)
+				sys.exit(1)
+			else:
+				self.command('egrep --color=never "Allocated ipv4 addr" /opt/ltebox/var/log/xGwLog.0', '\$', 5)
+				result = re.search('Allocated ipv4 addr: (?P<ipaddr>[0-9\.]+) from Pool', str(self.ssh.before))
+				if result is not None:
+					moduleIPAddr = result.group('ipaddr')
+				else:
+					return
+			ping_time = re.findall("-c (\d+)",str(self.ping_args))
+			device_id = 'catm'
+			ping_status = self.command('stdbuf -o0 ping ' + self.ping_args + ' ' + str(moduleIPAddr) + ' 2>&1 | stdbuf -o0 tee -a ping_' + self.testCase_id + '_' + device_id + '.log', '\$', int(ping_time[0])*1.5)
+			# TIMEOUT CASE
+			if ping_status < 0:
+				message = 'Ping with UE (' + str(moduleIPAddr) + ') crashed due to TIMEOUT!'
+				logging.debug('\u001B[1;37;41m ' + message + ' \u001B[0m')
+				self.ping_iperf_wrong_exit(lock, moduleIPAddr, device_id, statusQueue, message)
+				return
+			result = re.search(', (?P<packetloss>[0-9\.]+)% packet loss, time [0-9\.]+ms', str(self.ssh.before))
+			if result is None:
+				message = 'Packet Loss Not Found!'
+				logging.debug('\u001B[1;37;41m ' + message + ' \u001B[0m')
+				self.ping_iperf_wrong_exit(lock, moduleIPAddr, device_id, statusQueue, message)
+				return
+			packetloss = result.group('packetloss')
+			if float(packetloss) == 100:
+				message = 'Packet Loss is 100%'
+				logging.debug('\u001B[1;37;41m ' + message + ' \u001B[0m')
+				self.ping_iperf_wrong_exit(lock, moduleIPAddr, device_id, statusQueue, message)
+				return
+			result = re.search('rtt min\/avg\/max\/mdev = (?P<rtt_min>[0-9\.]+)\/(?P<rtt_avg>[0-9\.]+)\/(?P<rtt_max>[0-9\.]+)\/[0-9\.]+ ms', str(self.ssh.before))
+			if result is None:
+				message = 'Ping RTT_Min RTT_Avg RTT_Max Not Found!'
+				logging.debug('\u001B[1;37;41m ' + message + ' \u001B[0m')
+				self.ping_iperf_wrong_exit(lock, moduleIPAddr, device_id, statusQueue, message)
+				return
+			rtt_min = result.group('rtt_min')
+			rtt_avg = result.group('rtt_avg')
+			rtt_max = result.group('rtt_max')
+			pal_msg = 'Packet Loss : ' + packetloss + '%'
+			min_msg = 'RTT(Min)    : ' + rtt_min + ' ms'
+			avg_msg = 'RTT(Avg)    : ' + rtt_avg + ' ms'
+			max_msg = 'RTT(Max)    : ' + rtt_max + ' ms'
+			lock.acquire()
+			logging.debug('\u001B[1;37;44m ping result (' + moduleIPAddr + ') \u001B[0m')
+			logging.debug('\u001B[1;34m    ' + pal_msg + '\u001B[0m')
+			logging.debug('\u001B[1;34m    ' + min_msg + '\u001B[0m')
+			logging.debug('\u001B[1;34m    ' + avg_msg + '\u001B[0m')
+			logging.debug('\u001B[1;34m    ' + max_msg + '\u001B[0m')
+			qMsg = pal_msg + '\n' + min_msg + '\n' + avg_msg + '\n' + max_msg
+			packetLossOK = True
+			if packetloss is not None:
+				if float(packetloss) > float(self.ping_packetloss_threshold):
+					qMsg += '\nPacket Loss too high'
+					logging.debug('\u001B[1;37;41m Packet Loss too high \u001B[0m')
+					packetLossOK = False
+				elif float(packetloss) > 0:
+					qMsg += '\nPacket Loss is not 0%'
+					logging.debug('\u001B[1;30;43m Packet Loss is not 0% \u001B[0m')
+			lock.release()
+			self.close()
+			html_cell = '<pre style="background-color:white">CAT-M module\nIP Address  : ' + moduleIPAddr + '\n' + qMsg + '</pre>'
+			statusQueue.put(html_cell)
+			if (packetLossOK):
+				self.CreateHtmlTestRowQueue(self.ping_args, 'OK', 1, statusQueue)
+			else:
+				self.CreateHtmlTestRowQueue(self.ping_args, 'KO', 1, statusQueue)
+				self.AutoTerminateUEandeNB()
+				self.CreateHtmlTabFooter(False)
+				sys.exit(1)
+		except:
+			os.kill(os.getppid(),signal.SIGUSR1)
 
 	def AttachUE_common(self, device_id, statusQueue, lock):
 		try:
@@ -1527,11 +1893,53 @@ class SSHConnection():
 						result = logStatus
 			return result
 
+	def CheckOAIUEProcessExist(self, initialize_OAI_UE_flag):
+		multi_jobs = []
+		status_queue = SimpleQueue()
+		if initialize_OAI_UE_flag == False:
+			p = Process(target = SSH.CheckOAIUEProcess, args = (status_queue,))
+			p.daemon = True
+			p.start()
+			multi_jobs.append(p)
+		for job in multi_jobs:
+			job.join()
+
+		if (status_queue.empty()):
+			return -15
+		else:
+			result = 0
+			while (not status_queue.empty()):
+				status = status_queue.get()
+				if (status < 0):
+					result = status
+			if result == OAI_UE_PROCESS_FAILED:
+				fileCheck = re.search('enb_', str(self.UELogFile))
+				if fileCheck is not None:
+					self.copyin(self.UEIPAddress, self.UEUserName, self.UEPassword, self.UESourceCodePath + '/cmake_targets/' + self.UELogFile, '.')
+					logStatus = self.AnalyzeLogFile_UE(self.UELogFile)
+					if logStatus < 0:
+						result = logStatus
+			return result
+
+	def CheckOAIUEProcess(self, status_queue):
+		try:
+			self.open(self.OAIUEIPAddress, self.OAIUEUserName, self.OAIUEPassword)
+			self.command('stdbuf -o0 ps -aux | grep -v grep | grep --color=never ' + self.air_interface + '-uesoftmodem', '\$', 5)
+			result = re.search(self.air_interface + '-uesoftmodem', str(self.ssh.before))
+			if result is None:
+				logging.debug('\u001B[1;37;41m OAI UE Process Not Found! \u001B[0m')
+				status_queue.put(OAI_UE_PROCESS_FAILED)
+			else:
+				status_queue.put(OAI_UE_PROCESS_OK)
+			self.close()
+		except:
+			os.kill(os.getppid(),signal.SIGUSR1)
+
 	def CheckeNBProcess(self, status_queue):
 		try:
 			self.open(self.eNBIPAddress, self.eNBUserName, self.eNBPassword)
-			self.command('stdbuf -o0 ps -aux | grep -v grep | grep --color=never lte-softmodem', '\$', 5)
-			result = re.search('lte-softmodem', str(self.ssh.before))
+			self.command('stdbuf -o0 ps -aux | grep -v grep | grep --color=never ' + self.air_interface + '-softmodem', '\$', 5)
+			result = re.search(self.air_interface + '-softmodem', str(self.ssh.before))
 			if result is None:
 				logging.debug('\u001B[1;37;41m eNB Process Not Found! \u001B[0m')
 				status_queue.put(ENB_PROCESS_FAILED)
@@ -1615,7 +2023,18 @@ class SSHConnection():
 		uciStatMsgCount = 0
 		pdcpFailure = 0
 		ulschFailure = 0
+		self.htmleNBFailureMsg = ''
 		for line in enb_log_file.readlines():
+			if self.rruOptions != '':
+				res1 = re.search('max_rxgain (?P<requested_option>[0-9]+)', self.rruOptions)
+				res2 = re.search('max_rxgain (?P<applied_option>[0-9]+)',  str(line))
+				if res1 is not None and res2 is not None:
+					requested_option = int(res1.group('requested_option'))
+					applied_option = int(res2.group('applied_option'))
+					if requested_option == applied_option:
+						self.htmleNBFailureMsg += '<span class="glyphicon glyphicon-ok-circle"></span> Command line option(s) correctly applied <span class="glyphicon glyphicon-arrow-right"></span> ' + self.rruOptions + '\n\n'
+					else:
+						self.htmleNBFailureMsg += '<span class="glyphicon glyphicon-ban-circle"></span> Command line option(s) NOT applied <span class="glyphicon glyphicon-arrow-right"></span> ' + self.rruOptions + '\n\n'
 			result = re.search('[Ss]egmentation [Ff]ault', str(line))
 			if result is not None:
 				foundSegFault = True
@@ -1734,17 +2153,172 @@ class SSHConnection():
 			return ENB_PROCESS_REALTIME_ISSUE
 		return 0
 
+	def AnalyzeLogFile_UE(self, UElogFile):
+		if (not os.path.isfile('./' + UElogFile)):
+			return -1
+		ue_log_file = open('./' + UElogFile, 'r')
+		foundAssertion = False
+		msgAssertion = ''
+		msgLine = 0
+		foundSegFault = False
+		foundRealTimeIssue = False
+		rlcDiscardBuffer = 0
+		rachCanceledProcedure = 0
+		uciStatMsgCount = 0
+		pdcpFailure = 0
+		ulschFailure = 0
+		no_cell_sync_found = False
+		mib_found = False
+		frequency_found = False
+		self.htmlUEFailureMsg = ''
+		for line in ue_log_file.readlines():
+			result = re.search('[Ss]egmentation [Ff]ault', str(line))
+			if result is not None:
+				foundSegFault = True
+			result = re.search('[Cc]ore [dD]ump', str(line))
+			if result is not None:
+				foundSegFault = True
+			result = re.search('[Aa]ssertion', str(line))
+			if result is not None:
+				foundAssertion = True
+			result = re.search('LLL', str(line))
+			if result is not None:
+				foundRealTimeIssue = True
+			if foundAssertion and (msgLine < 3):
+				msgLine += 1
+				msgAssertion += str(line)
+			result = re.search('uci->stat', str(line))
+			if result is not None:
+				uciStatMsgCount += 1
+			# No cell synchronization found, abandoning
+			result = re.search('No cell synchronization found, abandoning', str(line))
+			if result is not None:
+				no_cell_sync_found = True
+			result = re.search("MIB Information => ([a-zA-Z]{1,10}), ([a-zA-Z]{1,10}), NidCell (?P<nidcell>\d{1,3}), N_RB_DL (?P<n_rb_dl>\d{1,3}), PHICH DURATION (?P<phich_duration>\d), PHICH RESOURCE (?P<phich_resource>.{1,4}), TX_ANT (?P<tx_ant>\d)", str(line))
+			if result is not None and (not mib_found):
+				try:
+					mibMsg = "MIB Information: " + result.group(1) + ', ' + result.group(2)
+					self.htmlUEFailureMsg += mibMsg + '\n'
+					logging.debug('\033[94m' + mibMsg + '\033[0m')
+					mibMsg = "    nidcell = " + result.group('nidcell')
+					self.htmlUEFailureMsg += mibMsg
+					logging.debug('\033[94m' + mibMsg + '\033[0m')
+					mibMsg = "    n_rb_dl = " + result.group('n_rb_dl')
+					self.htmlUEFailureMsg += mibMsg + '\n'
+					logging.debug('\033[94m' + mibMsg + '\033[0m')
+					mibMsg = "    phich_duration = " + result.group('phich_duration')
+					self.htmlUEFailureMsg += mibMsg
+					logging.debug('\033[94m' + mibMsg + '\033[0m')
+					mibMsg = "    phich_resource = " + result.group('phich_resource')
+					self.htmlUEFailureMsg += mibMsg + '\n'
+					logging.debug('\033[94m' + mibMsg + '\033[0m')
+					mibMsg = "    tx_ant = " + result.group('tx_ant')
+					self.htmlUEFailureMsg += mibMsg + '\n'
+					logging.debug('\033[94m' + mibMsg + '\033[0m')
+					mib_found = True
+				except Exception as e:
+					logging.error('\033[91m' + "MIB marker was not found" + '\033[0m')
+			result = re.search("Measured Carrier Frequency (?P<measured_carrier_frequency>\d{1,15}) Hz", str(line))
+			if result is not None and (not frequency_found):
+				try:
+					mibMsg = "Measured Carrier Frequency = " + result.group('measured_carrier_frequency') + ' Hz'
+					self.htmlUEFailureMsg += mibMsg + '\n'
+					logging.debug('\033[94m' + mibMsg + '\033[0m')
+					frequency_found = True
+				except Exception as e:
+					logging.error('\033[91m' + "Measured Carrier Frequency not found" + '\033[0m')
+			result = re.search("Found (?P<operator>[\w,\s]{1,15}) \(name from internal table\)", str(line))
+			if result is not None:
+				try:
+					mibMsg = "The operator is: " + result.group('operator')
+					self.htmlUEFailureMsg += mibMsg + '\n'
+					logging.debug('\033[94m' + mibMsg + '\033[0m')
+				except Exception as e:
+					logging.error('\033[91m' + "Operator name not found" + '\033[0m')
+			result = re.search("SIB5 InterFreqCarrierFreq element (.{1,4})/(.{1,4})", str(line))
+			if result is not None:
+				try:
+					mibMsg = "SIB5 InterFreqCarrierFreq element " + result.group(1) + '/' + result.group(2)
+					self.htmlUEFailureMsg += mibMsg + ' -> '
+					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))
+			if result is not None:
+				try:
+					freq = result.group('carrier_frequency')
+					new_freq = re.sub('/[0-9]+','',freq)
+					float_freq = float(new_freq) / 1000000
+					self.htmlUEFailureMsg += 'DL Freq: ' + ('%.1f' % float_freq) + ' MHz'
+					logging.debug('\033[94m' + "    DL Carrier Frequency is: " + 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))
+			if result is not None:
+				try:
+					prb = result.group('allowed_bandwidth')
+					self.htmlUEFailureMsg += ' -- PRB: ' + prb + '\n'
+					logging.debug('\033[94m' + "    AllowedMeasBandwidth: " + prb + '\033[0m')
+				except Exception as e:
+					logging.error('\033[91m' + "    AllowedMeasBandwidth not found" + '\033[0m')
+		ue_log_file.close()
+		if uciStatMsgCount > 0:
+			statMsg = 'UE showed ' + str(uciStatMsgCount) + ' "uci->stat" message(s)'
+			logging.debug('\u001B[1;30;43m ' + statMsg + ' \u001B[0m')
+			self.htmlUEFailureMsg += statMsg + '\n'
+		if pdcpFailure > 0:
+			statMsg = 'UE showed ' + str(pdcpFailure) + ' "PDCP Out of Resources" message(s)'
+			logging.debug('\u001B[1;30;43m ' + statMsg + ' \u001B[0m')
+			self.htmlUEFailureMsg += statMsg + '\n'
+		if ulschFailure > 0:
+			statMsg = 'UE showed ' + str(ulschFailure) + ' "ULSCH in error in round" message(s)'
+			logging.debug('\u001B[1;30;43m ' + statMsg + ' \u001B[0m')
+			self.htmlUEFailureMsg += statMsg + '\n'
+		if rachCanceledProcedure > 0:
+			rachMsg = 'UE cancelled ' + str(rachCanceledProcedure) + ' RA procedure(s)'
+			logging.debug('\u001B[1;30;43m ' + rachMsg + ' \u001B[0m')
+			self.htmlUEFailureMsg += rachMsg + '\n'
+		if foundSegFault:
+			logging.debug('\u001B[1;37;41m UE ended with a Segmentation Fault! \u001B[0m')
+			return ENB_PROCESS_SEG_FAULT
+		if foundAssertion:
+			logging.debug('\u001B[1;37;43m UE ended with an assertion! \u001B[0m')
+			# removed for esthetics
+			#self.htmlUEFailureMsg += msgAssertion
+			self.htmlUEFailureMsg += 'UE ended with an assertion!\n'
+			if not mib_found or not frequency_found:
+				return UE_PROCESS_ASSERTION
+		if foundRealTimeIssue:
+			logging.debug('\u001B[1;37;41m UE faced real time issues! \u001B[0m')
+			self.htmlUEFailureMsg += 'UE faced real time issues!\n'
+			#return ENB_PROCESS_REALTIME_ISSUE
+		if no_cell_sync_found and not mib_found:
+			logging.debug('\u001B[1;37;41m UE could not synchronize ! \u001B[0m')
+			self.htmlUEFailureMsg += 'UE could not synchronize!\n'
+			return UE_PROCESS_COULD_NOT_SYNC
+		if rlcDiscardBuffer > 0:
+			rlcMsg = 'UE RLC discarded ' + str(rlcDiscardBuffer) + ' buffer(s)'
+			logging.debug('\u001B[1;37;41m ' + rlcMsg + ' \u001B[0m')
+			self.htmlUEFailureMsg += rlcMsg + '\n'
+			return ENB_PROCESS_REALTIME_ISSUE
+		return 0
+
 	def TerminateeNB(self):
 		self.open(self.eNBIPAddress, self.eNBUserName, self.eNBPassword)
 		self.command('cd ' + self.eNBSourceCodePath + '/cmake_targets', '\$', 5)
+		#to use daemon on CentOS we need to source the function
+		#linux_distro = platform.linux_distribution()[0]		
+		#if re.match('(.*)CentOS(.*)', linux_distro, re.IGNORECASE):
+			#self.command('source /etc/init.d/functions', '\$', 5)
+		#use nohup instead of daemon
 		self.command('echo ' + self.eNBPassword + ' | sudo -S daemon --name=enb' + str(self.eNB_instance) + '_daemon --stop', '\$', 5)
 		self.command('rm -f my-lte-softmodem-run' + str(self.eNB_instance) + '.sh', '\$', 5)
-		self.command('echo ' + self.eNBPassword + ' | sudo -S killall --signal SIGINT lte-softmodem || true', '\$', 5)
+		self.command('echo ' + self.eNBPassword + ' | sudo -S killall --signal SIGINT -r .*-softmodem || true', '\$', 5)
 		time.sleep(5)
-		self.command('stdbuf -o0  ps -aux | grep -v grep | grep lte-softmodem', '\$', 5)
-		result = re.search('lte-softmodem', str(self.ssh.before))
+		self.command('stdbuf -o0  ps -aux | grep softmodem | grep -v grep', '\$', 5)
+		result = re.search('-softmodem', str(self.ssh.before))
 		if result is not None:
-			self.command('echo ' + self.eNBPassword + ' | sudo -S killall --signal SIGKILL lte-softmodem || true', '\$', 5)
+			self.command('echo ' + self.eNBPassword + ' | sudo -S killall --signal SIGKILL -r .*-softmodem || true', '\$', 5)
 			time.sleep(5)
 		self.close()
 		# If tracer options is on, stopping tshark on EPC side
@@ -1810,6 +2384,10 @@ class SSHConnection():
 			self.command('cd ' + self.EPCSourceCodePath, '\$', 5)
 			self.command('cd scripts', '\$', 5)
 			self.command('rm -f ./kill_hss.sh', '\$', 5)
+			#to use daemon on CentOS we need to source the function
+			#linux_distro = platform.linux_distribution()[0]         
+			#if re.match('(.*)CentOS(.*)', linux_distro, re.IGNORECASE):
+				#self.command('source /etc/init.d/functions', '\$', 5)
 			self.command('echo ' + self.EPCPassword + ' | sudo -S daemon --name=simulated_hss --stop', '\$', 5)
 			time.sleep(1)
 			self.command('echo ' + self.EPCPassword + ' | sudo -S killall --signal SIGKILL hss_sim', '\$', 5)
@@ -1874,6 +2452,50 @@ class SSHConnection():
 			job.join()
 		self.CreateHtmlTestRow('N/A', 'OK', ALL_PROCESSES_OK)
 
+	def TerminateOAIUE(self):
+		self.open(self.UEIPAddress, self.UEUserName, self.UEPassword)
+		self.command('cd ' + self.UESourceCodePath + '/cmake_targets', '\$', 5)
+		#to use daemon on CentOS we need to source the function
+		#linux_distro = platform.linux_distribution()[0]
+		#if re.match('(.*)CentOS(.*)', linux_distro, re.IGNORECASE):
+			#self.command('source /etc/init.d/functions', '\$', 5)
+		#self.command('echo ' + self.UEPassword + ' | sudo -S daemon --name=ue' + str(self.UE_instance) + '_daemon --stop', '\$', 5)
+		self.command('rm -f my-lte-uesoftmodem-run' + str(self.UE_instance) + '.sh', '\$', 5)
+		self.command('echo ' + self.UEPassword + ' | sudo -S killall --signal SIGINT -r .*-uesoftmodem || true', '\$', 5)
+		time.sleep(5)
+		self.command('stdbuf -o0  ps -aux | grep uesoftmodem | grep -v grep', '\$', 5)
+		result = re.search('-uesoftmodem', str(self.ssh.before))
+		if result is not None:
+			self.command('echo ' + self.UEPassword + ' | sudo -S killall --signal SIGKILL -r .*-uesoftmodem || true', '\$', 5)
+			time.sleep(5)
+		self.close()
+		result = re.search('ue_', str(self.UELogFile))
+		if result is not None:
+			copyin_res = self.copyin(self.UEIPAddress, self.UEUserName, self.UEPassword, self.UESourceCodePath + '/cmake_targets/' + self.UELogFile, '.')
+			if (copyin_res == -1):
+				logging.debug('\u001B[1;37;41m Could not copy UE logfile to analyze it! \u001B[0m')
+				optionsMsg = '<pre style="background-color:white">Could not copy UE logfile to analyze it!</pre>'
+				self.CreateHtmlTestRow(optionsMsg, 'KO', UE_PROCESS_NOLOGFILE_TO_ANALYZE, 'UE')
+				self.UELogFile = ''
+				return
+			logging.debug('\u001B[1m Analyzing UE logfile \u001B[0m')
+			logStatus = self.AnalyzeLogFile_UE(self.UELogFile)
+			if (logStatus < 0):
+				optionsMsg = '<pre style="background-color:white"><b>Sniffing Unsuccessful</b>\n'
+				optionsMsg += self.htmlUEFailureMsg
+				optionsMsg += '</pre>'
+				self.CreateHtmlTestRow(optionsMsg, 'KO', logStatus, 'UE')
+				self.CreateHtmlTabFooter(False)
+				sys.exit(1)
+			else:
+				optionsMsg = '<pre style="background-color:white"><b>Sniffing Successful</b>\n'
+				optionsMsg += self.htmlUEFailureMsg
+				optionsMsg += '</pre>'
+				self.CreateHtmlTestRow(optionsMsg, 'OK', ALL_PROCESSES_OK)
+			self.UELogFile = ''
+		else:
+			self.CreateHtmlTestRow('<pre style="background-color:white">No Log File to analyze</pre>', 'OK', ALL_PROCESSES_OK)
+
 	def AutoTerminateUEandeNB(self):
 		self.testCase_id = 'AUTO-KILL-UE'
 		self.desc = 'Automatic Termination of UE'
@@ -1890,8 +2512,20 @@ class SSHConnection():
 		self.CreateHtmlTestRow(str(self.idle_sleep_time) + ' sec', 'OK', ALL_PROCESSES_OK)
 
 	def LogCollectBuild(self):
-		self.open(self.eNBIPAddress, self.eNBUserName, self.eNBPassword)
-		self.command('cd ' + self.eNBSourceCodePath, '\$', 5)
+		if (self.eNBIPAddress != '' and self.eNBUserName != '' and self.eNBPassword != ''):
+			IPAddress = self.eNBIPAddress
+			UserName = self.eNBUserName
+			Password = self.eNBPassword
+			SourceCodePath = self.eNBSourceCodePath
+		elif (self.UEIPAddress != '' and self.UEUserName != '' and self.UEPassword != ''):
+			IPAddress = self.UEIPAddress
+			UserName = self.UEUserName
+			Password = self.UEPassword
+			SourceCodePath = self.UESourceCodePath
+		else:
+			sys.exit('Insufficient Parameter')
+		self.open(IPAddress, UserName, Password)
+		self.command('cd ' + SourceCodePath, '\$', 5)
 		self.command('cd cmake_targets', '\$', 5)
 		self.command('rm -f build.log.zip', '\$', 5)
 		self.command('zip build.log.zip build_log_*/*', '\$', 60)
@@ -1907,6 +2541,7 @@ class SSHConnection():
 		self.command('echo ' + self.eNBPassword + ' | sudo -S rm enb*.log core* enb_*record.raw enb_*.pcap enb_*txt', '\$', 5)
 		self.close()
 
+
 	def LogCollectPing(self):
 		self.open(self.EPCIPAddress, self.EPCUserName, self.EPCPassword)
 		self.command('cd ' + self.EPCSourceCodePath, '\$', 5)
@@ -1964,43 +2599,69 @@ class SSHConnection():
 			self.command('zip spgw.log.zip xGwLog.0', '\$', 60)
 		self.close()
 
+	def LogCollectOAIUE(self):
+		self.open(self.UEIPAddress, self.UEUserName, self.UEPassword)
+		self.command('cd ' + self.UESourceCodePath, '\$', 5)
+		self.command('cd cmake_targets', '\$', 5)
+		self.command('echo ' + self.UEPassword + ' | sudo -S rm -f ue.log.zip', '\$', 5)
+		self.command('echo ' + self.UEPassword + ' | sudo -S zip ue.log.zip ue*.log core* ue_*record.raw ue_*.pcap ue_*txt', '\$', 60)
+		self.command('echo ' + self.UEPassword + ' | sudo -S rm ue*.log core* ue_*record.raw ue_*.pcap ue_*txt', '\$', 5)
+		self.close()
+
 	def RetrieveSystemVersion(self):
 		if self.eNBIPAddress == 'none':
-			self.eNBOsVersion = 'Ubuntu 16.04.5 LTS'
-			self.eNBKernelVersion = '4.15.0-45-generic'
-			self.eNBUhdVersion = '3.13.0.1-0'
-			self.eNBCpuNb = '4'
-			self.eNBCpuModel = 'Intel(R) Core(TM) i5-6200U'
-			self.eNBCpuMHz = '2399.996 MHz'
+			self.OsVersion = 'Ubuntu 16.04.5 LTS'
+			self.KernelVersion = '4.15.0-45-generic'
+			self.UhdVersion = '3.13.0.1-0'
+			self.UsrpBoard = 'B210'
+			self.CpuNb = '4'
+			self.CpuModel = 'Intel(R) Core(TM) i5-6200U'
+			self.CpuMHz = '2399.996 MHz'
 			return
-		if self.eNBIPAddress == '' or self.eNBUserName == '' or self.eNBPassword == '':
+		machine = None
+		if self.eNBIPAddress != '' and self.eNBUserName != '' and self.eNBPassword != '':
+			machine = 'eNB'
+			IPAddress = self.eNBIPAddress
+			UserName = self.eNBUserName
+			Password = self.eNBPassword
+		elif self.UEIPAddress != '' and self.UEUserName != '' and self.UEPassword != '':
+			machine = 'UE'
+			IPAddress = self.UEIPAddress
+			UserName = self.UEUserName
+			Password = self.UEPassword
+		if machine is None:
 			Usage()
 			sys.exit('Insufficient Parameter')
-		self.open(self.eNBIPAddress, self.eNBUserName, self.eNBPassword)
+		self.open(IPAddress, UserName, Password)
 		self.command('lsb_release -a', '\$', 5)
 		result = re.search('Description:\\\\t(?P<os_type>[a-zA-Z0-9\-\_\.\ ]+)', str(self.ssh.before))
 		if result is not None:
-			self.eNBOsVersion = result.group('os_type')
-			logging.debug('OS is: ' + self.eNBOsVersion)
+			self.OsVersion = result.group('os_type')
+			logging.debug('OS is: ' + self.OsVersion)
 		self.command('uname -r', '\$', 5)
 		result = re.search('uname -r\\\\r\\\\n(?P<kernel_version>[a-zA-Z0-9\-\_\.]+)', str(self.ssh.before))
 		if result is not None:
-			self.eNBKernelVersion = result.group('kernel_version')
-			logging.debug('Kernel Version is: ' + self.eNBKernelVersion)
+			self.KernelVersion = result.group('kernel_version')
+			logging.debug('Kernel Version is: ' + self.KernelVersion)
 		self.command('dpkg --list | egrep --color=never libuhd003', '\$', 5)
 		result = re.search('libuhd003:amd64 *(?P<uhd_version>[0-9\.]+)', str(self.ssh.before))
 		if result is not None:
-			self.eNBUhdVersion = result.group('uhd_version')
-			logging.debug('UHD Version is: ' + self.eNBUhdVersion)
+			self.UhdVersion = result.group('uhd_version')
+			logging.debug('UHD Version is: ' + self.UhdVersion)
+		self.command('echo ' + Password + ' | sudo -S uhd_find_devices', '\$', 12)
+		result = re.search('product: (?P<usrp_board>[0-9A-Za-z]+)\\\\r\\\\n', str(self.ssh.before))
+		if result is not None:
+			self.UsrpBoard = result.group('usrp_board')
+			logging.debug('USRP Board  is: ' + self.UsrpBoard)
 		self.command('lscpu', '\$', 5)
 		result = re.search('CPU\(s\): *(?P<nb_cpus>[0-9]+).*Model name: *(?P<model>[a-zA-Z0-9\-\_\.\ \(\)]+).*CPU MHz: *(?P<cpu_mhz>[0-9\.]+)', str(self.ssh.before))
 		if result is not None:
-			self.eNBCpuNb = result.group('nb_cpus')
-			logging.debug('nb_cpus: ' + self.eNBCpuNb)
-			self.eNBCpuModel = result.group('model')
-			logging.debug('model: ' + self.eNBCpuModel)
-			self.eNBCpuMHz = result.group('cpu_mhz') + ' MHz'
-			logging.debug('cpu_mhz: ' + self.eNBCpuMHz)
+			self.CpuNb = result.group('nb_cpus')
+			logging.debug('nb_cpus: ' + self.CpuNb)
+			self.CpuModel = result.group('model')
+			logging.debug('model: ' + self.CpuModel)
+			self.CpuMHz = result.group('cpu_mhz') + ' MHz'
+			logging.debug('cpu_mhz: ' + self.CpuMHz)
 		self.close()
 
 #-----------------------------------------------------------
@@ -2008,6 +2669,9 @@ class SSHConnection():
 #-----------------------------------------------------------
 	def CreateHtmlHeader(self):
 		if (not self.htmlHeaderCreated):
+			logging.debug('\u001B[1m----------------------------------------\u001B[0m')
+			logging.debug('\u001B[1m  Creating HTML header \u001B[0m')
+			logging.debug('\u001B[1m----------------------------------------\u001B[0m')
 			self.htmlFile = open('test_results.html', 'w')
 			self.htmlFile.write('<!DOCTYPE html>\n')
 			self.htmlFile.write('<html class="no-js" lang="en-US">\n')
@@ -2085,18 +2749,13 @@ class SSHConnection():
 				self.htmlFile.write('     </tr>\n')
 			self.htmlFile.write('  </table>\n')
 
-			terminate_ue_flag = True
 			if (self.ADBIPAddress != 'none'):
+				terminate_ue_flag = True
 				self.GetAllUEDevices(terminate_ue_flag)
 				self.GetAllCatMDevices(terminate_ue_flag)
-			else:
-				self.UEDevices.append('doughq9rehg')
-				self.UEDevices.append('dnsgiuahgia')
-				self.UEDevices.append('uehgieng9')
-			self.htmlUEConnected = len(self.UEDevices)
-
-			self.htmlFile.write('  <h2><span class="glyphicon glyphicon-phone"></span> <span class="glyphicon glyphicon-menu-right"></span> ' + str(len(self.UEDevices)) + ' UE(s) is(are) connected to ADB bench server</h2>\n')
-			self.htmlFile.write('  <h2><span class="glyphicon glyphicon-phone"></span> <span class="glyphicon glyphicon-menu-right"></span> ' + str(len(self.CatMDevices)) + ' CAT-M UE(s) is(are) connected to bench server</h2>\n')
+				self.htmlUEConnected = len(self.UEDevices)
+				self.htmlFile.write('  <h2><span class="glyphicon glyphicon-phone"></span> <span class="glyphicon glyphicon-menu-right"></span> ' + str(len(self.UEDevices)) + ' UE(s) is(are) connected to ADB bench server</h2>\n')
+				self.htmlFile.write('  <h2><span class="glyphicon glyphicon-phone"></span> <span class="glyphicon glyphicon-menu-right"></span> ' + str(len(self.CatMDevices)) + ' CAT-M UE(s) is(are) connected to bench server</h2>\n')
 			self.htmlFile.write('  <br>\n')
 			self.htmlFile.write('  <ul class="nav nav-pills">\n')
 			count = 0
@@ -2163,6 +2822,9 @@ class SSHConnection():
 
 	def CreateHtmlFooter(self, passStatus):
 		if (os.path.isfile('test_results.html')):
+			logging.debug('\u001B[1m----------------------------------------\u001B[0m')
+			logging.debug('\u001B[1m  Creating HTML footer \u001B[0m')
+			logging.debug('\u001B[1m----------------------------------------\u001B[0m')
 			self.RetrieveSystemVersion()
 			self.htmlFile = open('test_results.html', 'a')
 			self.htmlFile.write('</div>\n')
@@ -2173,26 +2835,30 @@ class SSHConnection():
 			self.htmlFile.write('      </tr>\n')
 			self.htmlFile.write('      <tr>\n')
 			self.htmlFile.write('        <td>OS Version</td>\n')
-			self.htmlFile.write('        <td><span class="label label-default">' + self.eNBOsVersion + '</span></td>\n')
+			self.htmlFile.write('        <td><span class="label label-default">' + self.OsVersion + '</span></td>\n')
 			self.htmlFile.write('        <td>Kernel Version</td>\n')
-			self.htmlFile.write('        <td><span class="label label-default">' + self.eNBKernelVersion + '</span></td>\n')
+			self.htmlFile.write('        <td><span class="label label-default">' + self.KernelVersion + '</span></td>\n')
 			self.htmlFile.write('        <td>UHD Version</td>\n')
-			self.htmlFile.write('        <td><span class="label label-default">' + self.eNBUhdVersion + '</span></td>\n')
+			self.htmlFile.write('        <td><span class="label label-default">' + self.UhdVersion + '</span></td>\n')
+			self.htmlFile.write('        <td>USRP Board</td>\n')
+			self.htmlFile.write('        <td><span class="label label-default">' + self.UsrpBoard + '</span></td>\n')
 			self.htmlFile.write('      </tr>\n')
 			self.htmlFile.write('      <tr>\n')
 			self.htmlFile.write('        <td>Nb CPUs</td>\n')
-			self.htmlFile.write('        <td><span class="label label-default">' + self.eNBCpuNb + '</span></td>\n')
+			self.htmlFile.write('        <td><span class="label label-default">' + self.CpuNb + '</span></td>\n')
 			self.htmlFile.write('        <td>CPU Model Name</td>\n')
-			self.htmlFile.write('        <td><span class="label label-default">' + self.eNBCpuModel + '</span></td>\n')
+			self.htmlFile.write('        <td><span class="label label-default">' + self.CpuModel + '</span></td>\n')
 			self.htmlFile.write('        <td>CPU Frequency</td>\n')
-			self.htmlFile.write('        <td><span class="label label-default">' + self.eNBCpuMHz + '</span></td>\n')
+			self.htmlFile.write('        <td><span class="label label-default">' + self.CpuMHz + '</span></td>\n')
+			self.htmlFile.write('        <td></td>\n')
+			self.htmlFile.write('        <td></td>\n')
 			self.htmlFile.write('      </tr>\n')
 			self.htmlFile.write('      <tr>\n')
-			self.htmlFile.write('        <th colspan=4 bgcolor = "#33CCFF">Final Status</th>\n')
+			self.htmlFile.write('        <th colspan=5 bgcolor = "#33CCFF">Final Status</th>\n')
 			if passStatus:
-				self.htmlFile.write('        <th colspan=2 bgcolor="green"><font color="white">PASS <span class="glyphicon glyphicon-ok"></span></font></th>\n')
+				self.htmlFile.write('        <th colspan=3 bgcolor="green"><font color="white">PASS <span class="glyphicon glyphicon-ok"></span></font></th>\n')
 			else:
-				self.htmlFile.write('        <th colspan=2 bgcolor="red"><font color="white">FAIL <span class="glyphicon glyphicon-remove"></span> </font></th>\n')
+				self.htmlFile.write('        <th colspan=3 bgcolor="red"><font color="white">FAIL <span class="glyphicon glyphicon-remove"></span> </font></th>\n')
 			self.htmlFile.write('      </tr>\n')
 			self.htmlFile.write('  </table>\n')
 			self.htmlFile.write('  <p></p>\n')
@@ -2201,7 +2867,7 @@ class SSHConnection():
 			self.htmlFile.write('</html>\n')
 			self.htmlFile.close()
 
-	def CreateHtmlTestRow(self, options, status, processesStatus):
+	def CreateHtmlTestRow(self, options, status, processesStatus, machine='eNB'):
 		if ((not self.htmlFooterCreated) and (self.htmlHeaderCreated)):
 			self.htmlFile.write('      <tr>\n')
 			self.htmlFile.write('        <td bgcolor = "lightcyan" >' + self.testCase_id  + '</td>\n')
@@ -2213,15 +2879,17 @@ class SSHConnection():
 				if (processesStatus == 0):
 					self.htmlFile.write('        <td bgcolor = "lightcoral" >' + str(status)  + '</td>\n')
 				elif (processesStatus == ENB_PROCESS_FAILED):
-					self.htmlFile.write('        <td bgcolor = "lightcoral" >KO - eNB process not found</td>\n')
+					self.htmlFile.write('        <td bgcolor = "lightcoral" >KO - ' + machine + ' process not found</td>\n')
 				elif (processesStatus == ENB_PROCESS_SEG_FAULT):
-					self.htmlFile.write('        <td bgcolor = "lightcoral" >KO - eNB process ended in Segmentation Fault</td>\n')
-				elif (processesStatus == ENB_PROCESS_ASSERTION):
-					self.htmlFile.write('        <td bgcolor = "lightcoral" >KO - eNB process ended in Assertion</td>\n')
+					self.htmlFile.write('        <td bgcolor = "lightcoral" >KO - ' + machine + ' process ended in Segmentation Fault</td>\n')
+				elif (processesStatus == ENB_PROCESS_ASSERTION) or (processesStatus == UE_PROCESS_ASSERTION):
+					self.htmlFile.write('        <td bgcolor = "lightcoral" >KO - ' + machine + ' process ended in Assertion</td>\n')
 				elif (processesStatus == ENB_PROCESS_REALTIME_ISSUE):
-					self.htmlFile.write('        <td bgcolor = "lightcoral" >KO - eNB process faced Real Time issue(s)</td>\n')
-				elif (processesStatus == ENB_PROCESS_NOLOGFILE_TO_ANALYZE):
-					self.htmlFile.write('        <td bgcolor = "orange" >OK</td>\n')
+					self.htmlFile.write('        <td bgcolor = "lightcoral" >KO - ' + machine + ' process faced Real Time issue(s)</td>\n')
+				elif (processesStatus == ENB_PROCESS_NOLOGFILE_TO_ANALYZE) or (processesStatus == UE_PROCESS_NOLOGFILE_TO_ANALYZE):
+					self.htmlFile.write('        <td bgcolor = "orange" >OK?</td>\n')
+				elif (processesStatus == UE_PROCESS_COULD_NOT_SYNC):
+					self.htmlFile.write('        <td bgcolor = "lightcoral" >KO - UE could not sync</td>\n')
 				elif (processesStatus == HSS_PROCESS_FAILED):
 					self.htmlFile.write('        <td bgcolor = "lightcoral" >KO - HSS process not found</td>\n')
 				elif (processesStatus == MME_PROCESS_FAILED):
@@ -2325,8 +2993,11 @@ def Usage():
 	print('  --XMLTestFile=[XML Test File to be run]')
 	print('------------------------------------------------------------')
 
+#def GetModeFromXML():
+#	SSH.mode = test.findtext('mode')
+
 def CheckClassValidity(action,id):
-	if action != 'Build_eNB' and action != 'Initialize_eNB' and action != 'Terminate_eNB' and action != 'Initialize_UE' and action != 'Terminate_UE' and action != 'Attach_UE' and action != 'Detach_UE' and action != 'Ping' and action != 'Iperf' and action != 'Reboot_UE' and action != 'Initialize_HSS' and action != 'Terminate_HSS' and action != 'Initialize_MME' and action != 'Terminate_MME' and action != 'Initialize_SPGW' and action != 'Terminate_SPGW'  and action != 'Initialize_CatM_module' and action != 'Terminate_CatM_module' and action != 'Attach_CatM_module' and action != 'Detach_CatM_module' and action != 'IdleSleep':
+	if action != 'Build_eNB' and action != 'Initialize_eNB' and action != 'Terminate_eNB' and action != 'Initialize_UE' and action != 'Terminate_UE' and action != 'Attach_UE' and action != 'Detach_UE' and action != 'Build_OAI_UE' and action != 'Initialize_OAI_UE' and action != 'Terminate_OAI_UE' and action != 'Initialize_OAI_eNB' and action != 'Ping' and action != 'Iperf' and action != 'Reboot_UE' and action != 'Initialize_HSS' and action != 'Terminate_HSS' and action != 'Initialize_MME' and action != 'Terminate_MME' and action != 'Initialize_SPGW' and action != 'Terminate_SPGW'  and action != 'Initialize_CatM_module' and action != 'Terminate_CatM_module' and action != 'Attach_CatM_module' and action != 'Detach_CatM_module' and action != 'Ping_CatM_module' and action != 'IdleSleep':
 		logging.debug('ERROR: test-case ' + id + ' has wrong class ' + action)
 		return False
 	return True
@@ -2340,11 +3011,21 @@ def GetParametersFromXML(action):
 		SSH.eNB_instance = test.findtext('eNB_instance')
 		if (SSH.eNB_instance is None):
 			SSH.eNB_instance = '0'
-
+		SSH.air_interface = test.findtext('air_interface')
+		if (SSH.air_interface is None):
+			SSH.air_interface = 'lte'
+		else:
+			SSH.air_interface = SSH.air_interface.lower()
+	
 	if action == 'Terminate_eNB':
 		SSH.eNB_instance = test.findtext('eNB_instance')
 		if (SSH.eNB_instance is None):
 			SSH.eNB_instance = '0'
+		SSH.air_interface = test.findtext('air_interface')
+		if (SSH.air_interface is None):
+			SSH.air_interface = 'lte'
+		else:
+			SSH.air_interface = SSH.air_interface.lower()
 
 	if action == 'Attach_UE':
 		nbMaxUEtoAttach = test.findtext('nbMaxUEtoAttach')
@@ -2353,7 +3034,42 @@ def GetParametersFromXML(action):
 		else:
 			SSH.nbMaxUEtoAttach = int(nbMaxUEtoAttach)
 
-	if action == 'Ping':
+	if action == 'Build_OAI_UE':
+		SSH.Build_OAI_UE_args = test.findtext('Build_OAI_UE_args')
+		SSH.clean_repository = test.findtext('clean_repository')
+		if (SSH.clean_repository == 'false'):
+			SSH.clean_repository = False
+		else:
+			SSH.clean_repository = True
+
+	if action == 'Initialize_OAI_UE':
+		SSH.Initialize_OAI_UE_args = test.findtext('Initialize_OAI_UE_args')
+		SSH.UE_instance = test.findtext('UE_instance')
+		if (SSH.UE_instance is None):
+			SSH.UE_instance = '0'
+		SSH.air_interface = test.findtext('air_interface')
+		if (SSH.air_interface is None):
+			SSH.air_interface = 'lte'
+		else:
+			SSH.air_interface = SSH.air_interface.lower()
+	
+	if action == 'Initialize_OAI_eNB':
+		SSH.Initialize_OAI_eNB_args = test.findtext('Initialize_OAI_eNB_args')
+		SSH.UE_instance = test.findtext('eNB_instance')
+		if (SSH.eNB_instance is None):
+			SSH.eNB_instance = '0'
+		SSH.air_interface = test.findtext('air_interface')
+		if (SSH.air_interface is None):
+			SSH.air_interface = 'lte'
+		else:
+			SSH.air_interface = SSH.air_interface.lower()
+
+	if action == 'Terminate_OAI_UE':
+		SSH.eNB_instance = test.findtext('UE_instance')
+		if (SSH.UE_instance is None):
+			SSH.UE_instance = '0'
+
+	if action == 'Ping' or action == 'Ping_CatM_module':
 		SSH.ping_args = test.findtext('ping_args')
 		SSH.ping_packetloss_threshold = test.findtext('ping_packetloss_threshold')
 
@@ -2395,6 +3111,7 @@ SSH = SSHConnection()
 
 argvs = sys.argv
 argc = len(argvs)
+cwd = os.getcwd()
 
 while len(argvs) > 1:
 	myArgv = argvs.pop(1)	# 0th is this file's name
@@ -2403,6 +3120,9 @@ while len(argvs) > 1:
 		sys.exit(0)
 	elif re.match('^\-\-mode=(.+)$', myArgv, re.IGNORECASE):
 		matchReg = re.match('^\-\-mode=(.+)$', myArgv, re.IGNORECASE)
+		#if matchReg and mode is not None:
+			#print('Warning: the mode is defined in both xml file and command line')
+			#print('ignoring the mode defined in the xml file')
 		mode = matchReg.group(1)
 	elif re.match('^\-\-eNBIPAddress=(.+)$', myArgv, re.IGNORECASE):
 		matchReg = re.match('^\-\-eNBIPAddress=(.+)$', myArgv, re.IGNORECASE)
@@ -2467,6 +3187,18 @@ while len(argvs) > 1:
 		matchReg = re.match('^\-\-XMLTestFile=(.+)$', myArgv, re.IGNORECASE)
 		SSH.testXMLfiles.append(matchReg.group(1))
 		SSH.nbTestXMLfiles += 1
+	elif re.match('^\-\-UEIPAddress=(.+)$', myArgv, re.IGNORECASE):
+		matchReg = re.match('^\-\-UEIPAddress=(.+)$', myArgv, re.IGNORECASE)
+		SSH.UEIPAddress = matchReg.group(1)
+	elif re.match('^\-\-UEUserName=(.+)$', myArgv, re.IGNORECASE):
+		matchReg = re.match('^\-\-UEUserName=(.+)$', myArgv, re.IGNORECASE)
+		SSH.UEUserName = matchReg.group(1)
+	elif re.match('^\-\-UEPassword=(.+)$', myArgv, re.IGNORECASE):
+		matchReg = re.match('^\-\-UEPassword=(.+)$', myArgv, re.IGNORECASE)
+		SSH.UEPassword = matchReg.group(1)
+	elif re.match('^\-\-UESourceCodePath=(.+)$', myArgv, re.IGNORECASE):
+		matchReg = re.match('^\-\-UESourceCodePath=(.+)$', myArgv, re.IGNORECASE)
+		SSH.UESourceCodePath = matchReg.group(1)
 	elif re.match('^\-\-finalStatus=(.+)$', myArgv, re.IGNORECASE):
 		matchReg = re.match('^\-\-finalStatus=(.+)$', myArgv, re.IGNORECASE)
 		finalStatus = matchReg.group(1)
@@ -2482,11 +3214,17 @@ if re.match('^TerminateeNB$', mode, re.IGNORECASE):
 		sys.exit('Insufficient Parameter')
 	SSH.TerminateeNB()
 elif re.match('^TerminateUE$', mode, re.IGNORECASE):
-	if SSH.ADBIPAddress == '' or SSH.ADBUserName == '' or SSH.ADBPassword == '':
+	if (SSH.ADBIPAddress == '' or SSH.ADBUserName == '' or SSH.ADBPassword == ''):
 		Usage()
 		sys.exit('Insufficient Parameter')
 	signal.signal(signal.SIGUSR1, receive_signal)
 	SSH.TerminateUE()
+elif re.match('^TerminateOAIUE$', mode, re.IGNORECASE):
+	if SSH.UEIPAddress == '' or SSH.UEUserName == '' or SSH.UEPassword == '':
+		Usage()
+		sys.exit('Insufficient Parameter')
+	signal.signal(signal.SIGUSR1, receive_signal)
+	SSH.TerminateOAIUE()
 elif re.match('^TerminateHSS$', mode, re.IGNORECASE):
 	if SSH.EPCIPAddress == '' or SSH.EPCUserName == '' or SSH.EPCPassword == '' or SSH.EPCType == '' or SSH.EPCSourceCodePath == '':
 		Usage()
@@ -2503,7 +3241,7 @@ elif re.match('^TerminateSPGW$', mode, re.IGNORECASE):
 		sys.exit('Insufficient Parameter')
 	SSH.TerminateSPGW()
 elif re.match('^LogCollectBuild$', mode, re.IGNORECASE):
-	if SSH.eNBIPAddress == '' or SSH.eNBUserName == '' or SSH.eNBPassword == '' or SSH.eNBSourceCodePath == '':
+	if (SSH.eNBIPAddress == '' or SSH.eNBUserName == '' or SSH.eNBPassword == '' or SSH.eNBSourceCodePath == '') and (SSH.UEIPAddress == '' or SSH.UEUserName == '' or SSH.UEPassword == '' or SSH.UESourceCodePath == ''):
 		Usage()
 		sys.exit('Insufficient Parameter')
 	SSH.LogCollectBuild()
@@ -2537,36 +3275,62 @@ elif re.match('^LogCollectIperf$', mode, re.IGNORECASE):
 		Usage()
 		sys.exit('Insufficient Parameter')
 	SSH.LogCollectIperf()
+elif re.match('^LogCollectOAIUE$', mode, re.IGNORECASE):
+	if SSH.UEIPAddress == '' or SSH.UEUserName == '' or SSH.UEPassword == '' or SSH.UESourceCodePath == '':
+		Usage()
+		sys.exit('Insufficient Parameter')
+	SSH.LogCollectOAIUE()
 elif re.match('^InitiateHtml$', mode, re.IGNORECASE):
-	if SSH.ADBIPAddress == '' or SSH.ADBUserName == '' or SSH.ADBPassword == '':
+	if (SSH.ADBIPAddress == '' or SSH.ADBUserName == '' or SSH.ADBPassword == ''):
 		Usage()
 		sys.exit('Insufficient Parameter')
 	count = 0
+	foundCount = 0
 	while (count < SSH.nbTestXMLfiles):
-		xml_test_file = sys.path[0] + "/" + SSH.testXMLfiles[count]
-		xmlTree = ET.parse(xml_test_file)
-		xmlRoot = xmlTree.getroot()
-		SSH.htmlTabRefs.append(xmlRoot.findtext('htmlTabRef',default='test-tab-' + str(count)))
-		SSH.htmlTabNames.append(xmlRoot.findtext('htmlTabName',default='Test-' + str(count)))
-		SSH.htmlTabIcons.append(xmlRoot.findtext('htmlTabIcon',default='info-sign'))
+		xml_test_file = cwd + "/" + SSH.testXMLfiles[count]
+		if (os.path.isfile(xml_test_file)):
+			try:
+				xmlTree = ET.parse(xml_test_file)
+			except:
+				print("Error while parsing file: " + xml_test_file)
+			xmlRoot = xmlTree.getroot()
+			SSH.htmlTabRefs.append(xmlRoot.findtext('htmlTabRef',default='test-tab-' + str(count)))
+			SSH.htmlTabNames.append(xmlRoot.findtext('htmlTabName',default='Test-' + str(count)))
+			SSH.htmlTabIcons.append(xmlRoot.findtext('htmlTabIcon',default='info-sign'))
+			foundCount += 1
 		count += 1
+	if foundCount != SSH.nbTestXMLfiles:
+		SSH.nbTestXMLfiles = foundCount
 	SSH.CreateHtmlHeader()
 elif re.match('^FinalizeHtml$', mode, re.IGNORECASE):
 	SSH.CreateHtmlFooter(SSH.finalStatus)
-elif re.match('^TesteNB$', mode, re.IGNORECASE):
-	if SSH.eNBIPAddress == '' or SSH.eNBRepository == '' or SSH.eNBBranch == '' or SSH.eNBUserName == '' or SSH.eNBPassword == '' or SSH.eNBSourceCodePath == '' or SSH.EPCIPAddress == '' or SSH.EPCUserName == '' or SSH.EPCPassword == '' or SSH.EPCType == '' or SSH.EPCSourceCodePath == '' or SSH.ADBIPAddress == '' or SSH.ADBUserName == '' or SSH.ADBPassword == '':
-		Usage()
-		sys.exit('Insufficient Parameter')
+elif re.match('^TesteNB$', mode, re.IGNORECASE) or re.match('^TestUE$', mode, re.IGNORECASE):
+	if re.match('^TesteNB$', mode, re.IGNORECASE):
+		if (SSH.eNBRepository == '' or SSH.eNBBranch == '' or SSH.eNBSourceCodePath == ''):
+			Usage()
+			sys.exit('Insufficient Parameter')
+		if (SSH.eNBIPAddress == '' or SSH.eNBUserName == '' or SSH.eNBPassword == '') and (SSH.UEIPAddress == '' or SSH.UEUserName == '' or SSH.UEPassword == ''):
+			Usage()
+			sys.exit('Insufficient Parameter')
+		elif SSH.ADBIPAddress == 'none' and SSH.EPCIPAddress == 'none':
+			pass
+		elif SSH.EPCIPAddress == '' or SSH.EPCUserName == '' or SSH.EPCPassword == '' or SSH.EPCType == '' or SSH.EPCSourceCodePath == '' or SSH.ADBIPAddress == '' or SSH.ADBUserName == '' or SSH.ADBPassword == '':
+			Usage()
+			sys.exit('Insufficient Parameter')
+		if (SSH.EPCIPAddress != ''):
+			SSH.copyout(SSH.EPCIPAddress, SSH.EPCUserName, SSH.EPCPassword, cwd + "/tcp_iperf_stats.awk", "/tmp")
+			SSH.copyout(SSH.EPCIPAddress, SSH.EPCUserName, SSH.EPCPassword, cwd + "/active_net_interfaces.awk", "/tmp")
+	else:
+		if SSH.UEIPAddress == '' or SSH.eNBRepository == '' or SSH.eNBBranch == '' or SSH.UEUserName == '' or SSH.UEPassword == '' or SSH.UESourceCodePath == '':
+			Usage()
+			sys.exit('UE: Insufficient Parameter')
 
-	if (SSH.EPCIPAddress != 'none'):
-		SSH.copyout(SSH.EPCIPAddress, SSH.EPCUserName, SSH.EPCPassword, sys.path[0] + "/tcp_iperf_stats.awk", "/tmp")
-		SSH.copyout(SSH.EPCIPAddress, SSH.EPCUserName, SSH.EPCPassword, sys.path[0] + "/active_net_interfaces.awk", "/tmp")
 	#read test_case_list.xml file
         # if no parameters for XML file, use default value
 	if (SSH.nbTestXMLfiles != 1):
-		xml_test_file = sys.path[0] + "/test_case_list.xml"
+		xml_test_file = cwd + "/test_case_list.xml"
 	else:
-		xml_test_file = sys.path[0] + "/" + SSH.testXMLfiles[0]
+		xml_test_file = cwd + "/" + SSH.testXMLfiles[0]
 
 	xmlTree = ET.parse(xml_test_file)
 	xmlRoot = xmlTree.getroot()
@@ -2622,6 +3386,7 @@ elif re.match('^TesteNB$', mode, re.IGNORECASE):
 			SSH.testCase_id = id
 			SSH.desc = test.findtext('desc')
 			action = test.findtext('class')
+			mode = test.findtext('mode')
 			if (CheckClassValidity(action, id) == False):
 				continue
 			SSH.ShowTestID()
@@ -2643,6 +3408,14 @@ elif re.match('^TesteNB$', mode, re.IGNORECASE):
 				SSH.AttachUE()
 			elif action == 'Detach_UE':
 				SSH.DetachUE()
+			elif action == 'Build_OAI_UE':
+				SSH.BuildOAIUE()
+			elif action == 'Initialize_OAI_UE':
+				SSH.InitializeOAIUE()
+			elif action == 'Terminate_OAI_UE':
+				SSH.TerminateOAIUE()
+			elif action == 'Initialize_OAI_eNB':
+				SSH.InitializeOAIeNB()
 			elif action == 'Initialize_CatM_module':
 				SSH.InitializeCatM()
 			elif action == 'Terminate_CatM_module':
@@ -2651,6 +3424,8 @@ elif re.match('^TesteNB$', mode, re.IGNORECASE):
 				SSH.AttachCatM()
 			elif action == 'Detach_CatM_module':
 				SSH.TerminateCatM()
+			elif action == 'Ping_CatM_module':
+				SSH.PingCatM()
 			elif action == 'Ping':
 				SSH.Ping()
 			elif action == 'Iperf':
diff --git a/ci-scripts/oai-ci-vm-tool b/ci-scripts/oai-ci-vm-tool
index 940bcd2852..3d9fb87cba 100755
--- a/ci-scripts/oai-ci-vm-tool
+++ b/ci-scripts/oai-ci-vm-tool
@@ -39,7 +39,7 @@ function variant_usage {
     echo "    --variant phy-sim      OR -v3"
     echo "    --variant cppcheck     OR -v4"
     echo "    --variant gnb-usrp     OR -v5"
-    echo "    --variant nu-ue-usrp   OR -v6"
+    echo "    --variant nr-ue-usrp   OR -v6"
     echo "    --variant enb-ethernet OR -v7"
     echo "    --variant ue-ethernet  OR -v8"
 }
@@ -252,9 +252,9 @@ case $key in
     VM_NAME=ci-phy-sim
     ARCHIVES_LOC=phy_sim
     LOG_PATTERN=.Rel15.txt
-    NB_PATTERN_FILES=8
+    NB_PATTERN_FILES=10
     BUILD_OPTIONS="--phy_simulators"
-    VM_MEMORY=4096
+    VM_MEMORY=8192
     RUN_OPTIONS="./run_exec_autotests.bash -g \"01510*\" -q -np -b"
     NBARGS=$[$NBARGS+256]
     shift
@@ -331,9 +331,9 @@ case $key in
         VM_NAME=ci-phy-sim
         ARCHIVES_LOC=phy_sim
         LOG_PATTERN=.Rel15.txt
-        NB_PATTERN_FILES=8
+        NB_PATTERN_FILES=10
         BUILD_OPTIONS="--phy_simulators"
-	VM_MEMORY=4096
+	VM_MEMORY=8192
         RUN_OPTIONS="./run_exec_autotests.bash -g \"01510*\" -q -np -b"
         NBARGS=$[$NBARGS+256]
         ;;
@@ -354,7 +354,7 @@ case $key in
         BUILD_OPTIONS="--gNB -w USRP"
         NBARGS=$[$NBARGS+256]
         ;;
-        nu-ue-usrp)
+        nr-ue-usrp)
         VM_NAME=ci-ue-nr-usrp
         ARCHIVES_LOC=nrue_usrp
         LOG_PATTERN=.Rel15.txt
diff --git a/ci-scripts/xml_files/enb_usrp210_band40_test_20mhz_tm1.xml b/ci-scripts/xml_files/enb_usrp210_band40_test_20mhz_tm1_not_run.xml
similarity index 100%
rename from ci-scripts/xml_files/enb_usrp210_band40_test_20mhz_tm1.xml
rename to ci-scripts/xml_files/enb_usrp210_band40_test_20mhz_tm1_not_run.xml
diff --git a/ci-scripts/xml_files/gnb_nr_ue_usrp_run.xml b/ci-scripts/xml_files/gnb_nr_ue_usrp_run.xml
new file mode 100644
index 0000000000..f9d068c5b2
--- /dev/null
+++ b/ci-scripts/xml_files/gnb_nr_ue_usrp_run.xml
@@ -0,0 +1,64 @@
+<!--
+
+ 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-USRP</htmlTabRef>
+        <htmlTabName>run OAI gNB and OAI NR UE USRP</htmlTabName>
+        <htmlTabIcon>tasks</htmlTabIcon>	
+	<TestCaseRequestedList>
+090101 000001 090102 000001 090108 090109
+	</TestCaseRequestedList>
+	<TestCaseExclusionList></TestCaseExclusionList>
+	
+        <testCase id="090101">
+                <class>Initialize_OAI_eNB</class>
+                <desc>Initialize gNB USRP</desc>
+		<Initialize_OAI_eNB_args>-O ../../../ci-scripts/conf_files/gnb.band78.tm1.106PRB.usrpn300.conf</Initialize_OAI_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="090102">
+                <class>Initialize_OAI_UE</class>
+                <desc>Initialize NR UE USRP</desc>
+		<Initialize_OAI_UE_args>-C 3510000000 --numerology 1 -r 106 --phy-test --usrp-args "addr=192.168.30.2,clock_source=external,time_source=external" --threadoffset 16</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>
diff --git a/ci-scripts/xml_files/gnb_usrp_build.xml b/ci-scripts/xml_files/gnb_usrp_build.xml
new file mode 100644
index 0000000000..1b57c077ba
--- /dev/null
+++ b/ci-scripts/xml_files/gnb_usrp_build.xml
@@ -0,0 +1,39 @@
+<!--
+
+ 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>gnb-build-tab</htmlTabRef>
+	<htmlTabName>Build-gNB</htmlTabName>
+	<htmlTabIcon>wrench</htmlTabIcon>
+	<TestCaseRequestedList>
+010101
+	</TestCaseRequestedList>
+	<TestCaseExclusionList></TestCaseExclusionList>
+
+	<testCase id="010101">
+		<mode>TesteNB</mode>	
+		<class>Build_eNB</class>
+		<desc>Build gNB (USRP)</desc>
+		<Build_eNB_args>--gNB -w USRP</Build_eNB_args>
+	</testCase>
+
+</testCaseList>
diff --git a/ci-scripts/xml_files/if4p5_usrp210_band40_test_20mhz.xml b/ci-scripts/xml_files/if4p5_usrp210_band40_test_20mhz_not_run.xml
similarity index 100%
rename from ci-scripts/xml_files/if4p5_usrp210_band40_test_20mhz.xml
rename to ci-scripts/xml_files/if4p5_usrp210_band40_test_20mhz_not_run.xml
diff --git a/ci-scripts/xml_files/nr_ue_usrp_build.xml b/ci-scripts/xml_files/nr_ue_usrp_build.xml
new file mode 100644
index 0000000000..7d8d97d2c5
--- /dev/null
+++ b/ci-scripts/xml_files/nr_ue_usrp_build.xml
@@ -0,0 +1,40 @@
+<!--
+
+ 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>nr-ue-build-tab</htmlTabRef>
+	<htmlTabName>Build-NR-UE</htmlTabName>
+	<htmlTabIcon>wrench</htmlTabIcon>
+	<TestCaseRequestedList>
+010102
+	</TestCaseRequestedList>
+	<TestCaseExclusionList></TestCaseExclusionList>
+
+	<testCase id="010102">
+		<mode>TestUE</mode>
+		<class>Build_OAI_UE</class>
+		<desc>Build NR UE (USRP)</desc>
+		<Build_OAI_UE_args>--nrUE -w USRP</Build_OAI_UE_args>
+		<clean_repository>false</clean_repository>
+	</testCase>
+
+</testCaseList>
diff --git a/cmake_targets/CMakeLists.txt b/cmake_targets/CMakeLists.txt
index c05f89be9e..4e05552c1a 100644
--- a/cmake_targets/CMakeLists.txt
+++ b/cmake_targets/CMakeLists.txt
@@ -167,7 +167,7 @@ endif()
 
 #
 set(CMAKE_C_FLAGS
-  "${CMAKE_C_FLAGS} ${C_FLAGS_PROCESSOR} -std=gnu99 -Wall -Wstrict-prototypes -fno-strict-aliasing -rdynamic -funroll-loops -Wno-packed-bitfield-compat -fPIC ")
+  "${CMAKE_C_FLAGS} ${C_FLAGS_PROCESSOR} -std=gnu99 -Wall -Wstrict-prototypes -fno-strict-aliasing -rdynamic -funroll-loops -Wno-packed-bitfield-compat -fPIC")
 # add autotools definitions that were maybe used!
 set(MKVER "'MAKE_VERSION(a,b,c)=((a)*256+(b)*16+c)'")
 set(CMAKE_C_FLAGS
@@ -671,7 +671,7 @@ add_boolean_option(EXMIMO_IOT              True "????")
 add_boolean_option(LOCALIZATION            False "???")
 add_integer_option(MAX_NUM_CCs             1     "????")
 add_boolean_option(MU_RECEIVER             False "????")
-add_boolean_option(PHYSIM                  True  "for L1 simulators (dlsim, ulsim, ...)")
+add_boolean_option(PHYSIM                  False  "for L1 simulators (dlsim, ulsim, ...)")
 add_boolean_option(PHY_CONTEXT             True "not clear: must remain False for dlsim")
 add_boolean_option(PHY_EMUL                False "not clear: must remain False for dlsim")
 add_boolean_option(SMBV                    False "Rohde&Schwarz SMBV100A vector signal generator")
@@ -754,6 +754,7 @@ include_directories("${OPENAIR_BIN_DIR}")
 
 # Legacy exact order
 
+include_directories("${OPENAIR_DIR}/executables")
 include_directories("${OPENAIR2_DIR}/COMMON")
 include_directories("${OPENAIR2_DIR}/UTIL")
 include_directories("${OPENAIR2_DIR}/UTIL/LOG")
@@ -1118,15 +1119,19 @@ set(PHY_POLARSRC
   ${OPENAIR1_DIR}/PHY/CODING/nrPolar_tools/nr_polar_procedures.c
   ${OPENAIR1_DIR}/PHY/CODING/nrPolar_tools/nr_polar_sequence_pattern.c
 )
+set(PHY_SMALLBLOCKSRC
+  ${OPENAIR1_DIR}/PHY/CODING/nrSmallBlock/encodeSmallBlock.c
+  ${OPENAIR1_DIR}/PHY/CODING/nrSmallBlock/decodeSmallBlock.c
+)
 set(PHY_TURBOIF
   ${OPENAIR1_DIR}/PHY/CODING/coding_load.c
-  )
+)
 set(PHY_LDPCSRC
   ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c
   ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_encoder/ldpc_encoder.c
   ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_encoder/ldpc_encoder2.c
   ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_encoder/ldpc_generate_coefficient.c
-  )
+)
 
 add_library(coding MODULE ${PHY_TURBOSRC} )
 set(PHY_SRC_COMMON
@@ -1275,6 +1280,7 @@ set(PHY_SRC_UE
   ${OPENAIR1_DIR}/PHY/NR_TRANSPORT/nr_dlsch.c
   ${OPENAIR1_DIR}/PHY/NR_TRANSPORT/nr_dlsch_tools.c
   ${OPENAIR1_DIR}/PHY/NR_TRANSPORT/nr_dlsch_coding.c
+  ${OPENAIR1_DIR}/PHY/NR_TRANSPORT/nr_ulsch_decoding.c
   ${OPENAIR1_DIR}/PHY/NR_TRANSPORT/nr_tbs_tools.c
   ${OPENAIR1_DIR}/PHY/NR_TRANSPORT/nr_sch_dmrs.c
   ${OPENAIR1_DIR}/PHY/NR_REFSIG/nr_gold.c
@@ -1291,6 +1297,7 @@ set(PHY_SRC_UE
   ${OPENAIR1_DIR}/PHY/TOOLS/time_meas.c
   ${OPENAIR1_DIR}/PHY/TOOLS/lut.c
   ${PHY_POLARSRC}
+  ${PHY_SMALLBLOCKSRC}
   ${PHY_LDPCSRC}
   ${OPENAIR1_DIR}/PHY/NR_TRANSPORT/pucch_rx.c # added by prasanth
   )
@@ -1305,6 +1312,7 @@ set(PHY_SRC_UE
   ${OPENAIR1_DIR}/PHY/NR_UE_TRANSPORT/nr_initial_sync.c
   ${OPENAIR1_DIR}/PHY/NR_UE_TRANSPORT/nr_pbch.c
   ${OPENAIR1_DIR}/PHY/NR_UE_TRANSPORT/nr_dlsch_demodulation.c
+  ${OPENAIR1_DIR}/PHY/NR_UE_TRANSPORT/nr_ulsch_coding.c
   ${OPENAIR1_DIR}/PHY/NR_UE_TRANSPORT/nr_dlsch_decoding.c
   ${OPENAIR1_DIR}/PHY/NR_UE_TRANSPORT/nr_dlsch_llr_computation.c
   ${OPENAIR1_DIR}/PHY/NR_TRANSPORT/nr_tbs_tools.c
@@ -1335,6 +1343,7 @@ set(PHY_SRC_UE
   ${OPENAIR1_DIR}/PHY/INIT/nr_init_ue.c
   #  ${OPENAIR1_DIR}/SIMULATION/NR_UE_PHY/unit_tests/src/pucch_uci_test.c
   ${PHY_POLARSRC}
+  ${PHY_SMALLBLOCKSRC}
   ${PHY_LDPCSRC}
   )
 
@@ -1576,6 +1585,7 @@ add_library(L2
   ${ENB_APP_SRC}
   )
 add_dependencies(L2 rrc_flag s1ap_flag x2_flag)
+
 add_library(MAC_NR
   ${MAC_NR_SRC}
   )
@@ -1594,7 +1604,6 @@ add_dependencies(S1AP_LIB nr_rrc_flag s1ap_flag)
 add_library(L2_UE
   ${L2_SRC_UE}
   ${MAC_SRC_UE}
-  #${MAC_NR_SRC_UE}
 )
 if (NOT ${NOS1})
 target_compile_definitions(L2_UE PUBLIC -DPDCP_USE_NETLINK)
@@ -1603,44 +1612,13 @@ endif()
 add_dependencies(L2_UE rrc_flag s1ap_flag x2_flag)
 
 add_library( NR_L2_UE
-    #${L2_SRC_UE}
     ${NR_L2_SRC_UE}
     ${MAC_NR_SRC_UE}
-    #${MAC_SRC_UE}
-)
-
-set ( NR_LTE_UE_REUSE_SRC
-  ${OPENAIR1_DIR}/PHY/LTE_ESTIMATION/lte_sync_timefreq.c
-  ${OPENAIR1_DIR}/SCHED/phy_procedures_lte_common.c
-  #${OPENAIR1_DIR}/SCHED_UE/phy_procedures_lte_ue.c
-  ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/lte_mcs.c
-  #${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/pmch_common.c
-
-  #${OPENAIR1_DIR}/PHY/LTE_REFSIG/lte_dl_cell_spec.c
-  #${OPENAIR1_DIR}/PHY/CODING/lte_segmentation.c
-  #${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/prach_common.c
-#  ${OPENAIR1_DIR}/PHY/INIT/lte_init_ue.c
-  ${OPENAIR1_DIR}/PHY/CODING/crc_byte.c
-  ${OPENAIR1_DIR}/PHY/CODING/viterbi_lte.c
-  ${OPENAIR1_DIR}/PHY/CODING/viterbi.c
-  #${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/phich_common.c
-  ${OPENAIR1_DIR}/PHY/LTE_UE_TRANSPORT/dlsch_llr_computation.c
-
-#  ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/dci_tools_common.c
-#  ${OPENAIR1_DIR}/PHY/CODING/lte_rate_matching.c
-  ${OPENAIR1_DIR}/PHY/CODING/ccoding_byte_lte.c
-  ${OPENAIR1_DIR}/PHY/CODING/ccoding_byte.c
-  ${OPENAIR1_DIR}/PHY/LTE_REFSIG/lte_gold.c
-  ${OPENAIR1_DIR}/PHY/LTE_ESTIMATION/lte_est_freq_offset.c
-  ${OPENAIR1_DIR}/PHY/LTE_ESTIMATION/lte_dl_channel_estimation.c
-  ${OPENAIR1_DIR}/PHY/LTE_ESTIMATION/lte_ue_measurements.c
-  #${OPENAIR1_DIR}/PHY/LTE_UE_TRANSPORT/dlsch_demodulation.c
-  #${OPENAIR1_DIR}/PHY/LTE_UE_TRANSPORT/dlsch_llr_computation_avx2.c
-)
-
-add_library( NR_LTE_UE_REUSE_LIB
-    ${NR_LTE_UE_REUSE_SRC}
-)
+    )
+  
+add_library( MAC_NR_COMMON
+  ${OPENAIR2_DIR}/LAYER2/NR_MAC_gNB/nr_mac_common.c
+  )
 
 include_directories("${OPENAIR2_DIR}/NR_UE_PHY_INTERFACE")
 include_directories("${OPENAIR2_DIR}/LAYER2/NR_MAC_UE")
@@ -2137,11 +2115,18 @@ if (${XFORMS})
     ${OPENAIR1_DIR}/PHY/TOOLS/nr_phy_scope.c
     )
   set(XFORMS_SOURCE_SOFTMODEM
-    ${OPENAIR_TARGETS}/RT/USER/stats.c
+	  ${OPENAIR_DIR}/targets/RT/USER/stats.c
     )
   set(XFORMS_LIBRARIES "forms")
 endif (${XFORMS})
 
+include_directories ("/usr/include/X11")
+
+add_library(gnbScope MODULE
+  ${OPENAIR1_DIR}/PHY/TOOLS/nr_phy_scope.c
+  )
+target_link_libraries(gnbScope forms)
+
 set(CMAKE_MODULE_PATH "${OPENAIR_DIR}/cmake_targets/tools/MODULES" "${CMAKE_MODULE_PATH}")
 
 #include T directory even if the T is off because T macros are in the code
@@ -2185,6 +2170,24 @@ add_definitions(-DASN1_MINIMUM_VERSION=924)
 #################################
 # add executables for operation
 #################################
+add_library(minimal_lib
+  ${OPENAIR_DIR}/common/utils/backtrace.c
+  ${OPENAIR_DIR}/common/utils/LOG/log.c
+  ${OPENAIR_DIR}/common/config/config_userapi.c
+  ${OPENAIR_DIR}/common/config/config_load_configmodule.c
+  ${OPENAIR_DIR}/common/config/config_cmdline.c
+  ${OPENAIR_DIR}/common/utils/minimal_stub.c
+  )
+target_link_libraries(minimal_lib pthread dl)
+
+add_executable(replay_node
+  ${OPENAIR_TARGETS}/ARCH/rfsimulator/stored_node.c
+  )
+target_link_libraries (replay_node minimal_lib)
+
+add_executable(measurement_display
+  ${OPENAIR_DIR}/common/utils/threadPool/measurement_display.c)
+target_link_libraries (measurement_display minimal_lib)
 
 # lte-softmodem is both eNB and UE implementation
 ###################################################
@@ -2347,19 +2350,16 @@ add_executable(nr-softmodem
   ${nr_rrc_h}
   ${s1ap_h}
 #  ${OPENAIR_BIN_DIR}/messages_xml.h
-  ${OPENAIR_TARGETS}/RT/USER/rt_wrapper.c
-  ${OPENAIR_TARGETS}/RT/USER/nr-gnb.c
-  ${OPENAIR_TARGETS}/RT/USER/nr-ru.c
-  ${OPENAIR_TARGETS}/RT/USER/nr-softmodem.c
+  ${OPENAIR_DIR}/executables/nr-gnb.c
+  ${OPENAIR_DIR}/executables/nr-ru.c
+  ${OPENAIR_DIR}/executables/nr-softmodem.c
   ${OPENAIR1_DIR}/SIMULATION/TOOLS/taus.c
-  ${OPENAIR_TARGETS}/COMMON/create_nr_tasks.c
   ${OPENAIR_TARGETS}/ARCH/COMMON/common_lib.c
   ${OPENAIR1_DIR}/SIMULATION/ETH_TRANSPORT/netlink_init.c
   ${OPENAIR_DIR}/common/utils/utils.c
   ${OPENAIR_DIR}/common/utils/system.c
   ${GTPU_need_ITTI}
-  ${XFORMS_SOURCE}
-  ${XFORMS_SOURCE_SOFTMODEM}
+  ${XFORMS_SOURCE_NR}
   ${T_SOURCE}
   ${CONFIG_SOURCES}
   ${SHLIB_LOADER_SOURCES}
@@ -2369,7 +2369,7 @@ target_link_libraries (nr-softmodem
   -Wl,--start-group
   UTIL HASHTABLE SCTP_CLIENT UDP SCHED_LIB SCHED_RU_LIB SCHED_NR_LIB PHY_NR PHY PHY_COMMON PHY_RU LFDS GTPV1U SECU_CN SECU_OSA
   ${ITTI_LIB} ${FLPT_MSG_LIB} ${ASYNC_IF_LIB} ${FLEXRAN_AGENT_LIB} LFDS7 ${MSC_LIB} ${RAL_LIB} ${NAS_UE_LIB}
-  RRC_LIB NR_RRC_LIB S1AP_LIB S1AP_ENB L2 L2_NR
+  RRC_LIB NR_RRC_LIB S1AP_LIB S1AP_ENB L2 L2_NR MAC_NR_COMMON
   NFAPI_COMMON_LIB NFAPI_LIB NFAPI_VNF_LIB NFAPI_PNF_LIB NFAPI_USER_LIB
   -Wl,--end-group z dl)
 
@@ -2385,13 +2385,10 @@ add_executable(nr-softmodem-nos1
   ${rrc_h}
   ${s1ap_h}
 #  ${OPENAIR_BIN_DIR}/messages_xml.h
-  ${OPENAIR_TARGETS}/RT/USER/rt_wrapper.c
-  ${OPENAIR_TARGETS}/RT/USER/nr-gnb.c
-  ${OPENAIR_TARGETS}/RT/USER/nr-ru.c
-  ${OPENAIR_TARGETS}/RT/USER/nr-softmodem.c
+  ${OPENAIR_DIR}/executables/nr-gnb.c
+  ${OPENAIR_DIR}/executables/nr-ru.c
+  ${OPENAIR_DIR}/executables/nr-softmodem.c
   ${OPENAIR1_DIR}/SIMULATION/TOOLS/taus.c
-  ${OPENAIR_TARGETS}/COMMON/create_tasks.c
-  ${OPENAIR_TARGETS}/COMMON/create_nr_tasks.c
   ${OPENAIR_TARGETS}/ARCH/COMMON/common_lib.c
   ${OPENAIR2_DIR}/RRC/NAS/nas_config.c
   ${OPENAIR2_DIR}/RRC/NAS/rb_config.c
@@ -2399,8 +2396,7 @@ add_executable(nr-softmodem-nos1
   ${OPENAIR_DIR}/common/utils/utils.c
   ${OPENAIR_DIR}/common/utils/system.c
   ${GTPU_need_ITTI}
-  ${XFORMS_SOURCE}
-  ${XFORMS_SOURCE_SOFTMODEM}
+  ${XFORMS_SOURCE_NR}
   ${T_SOURCE}
   ${CONFIG_SOURCES}
   ${SHLIB_LOADER_SOURCES}
@@ -2410,7 +2406,7 @@ target_link_libraries (nr-softmodem-nos1
   -Wl,--start-group
   UTIL HASHTABLE SCTP_CLIENT UDP SCHED_LIB SCHED_RU_LIB SCHED_NR_LIB PHY_NR PHY PHY_COMMON PHY_RU LFDS GTPV1U SECU_CN SECU_OSA
   ${ITTI_LIB} ${FLPT_MSG_LIB} ${ASYNC_IF_LIB} ${FLEXRAN_AGENT_LIB} LFDS7 ${MSC_LIB} ${RAL_LIB} ${NAS_UE_LIB} ${MIH_LIB}
-  RRC_LIB NR_RRC_LIB S1AP_LIB S1AP_ENB L2 L2_NR
+  RRC_LIB NR_RRC_LIB S1AP_LIB S1AP_ENB L2 L2_NR MAC_NR_COMMON
   NFAPI_COMMON_LIB NFAPI_LIB NFAPI_VNF_LIB NFAPI_PNF_LIB NFAPI_USER_LIB
   -Wl,--end-group z dl)
 
@@ -2426,18 +2422,16 @@ add_executable(nr-uesoftmodem
   ${rrc_h}
   ${s1ap_h}
 #  ${OPENAIR_BIN_DIR}/messages_xml.h
-  ${OPENAIR_TARGETS}/RT/USER/rt_wrapper.c
-  ${OPENAIR_TARGETS}/RT/USER/nr-ue.c
-  ${OPENAIR_TARGETS}/RT/USER/nr-uesoftmodem.c
+  ${OPENAIR_DIR}/common/utils/threadPool/thread-pool.c
+  ${OPENAIR_DIR}/executables/nr-uesoftmodem.c
+  ${OPENAIR_DIR}/executables/nr-ue.c
   ${OPENAIR1_DIR}/SIMULATION/TOOLS/taus.c
-#  ${OPENAIR_TARGETS}/COMMON/create_tasks_ue.c
   ${OPENAIR_TARGETS}/ARCH/COMMON/common_lib.c
   ${OPENAIR1_DIR}/SIMULATION/ETH_TRANSPORT/netlink_init.c
   ${OPENAIR3_DIR}/NAS/UE/nas_ue_task.c
   ${OPENAIR_DIR}/common/utils/utils.c
   ${OPENAIR_DIR}/common/utils/system.c
   ${XFORMS_SOURCE_NR}
-  ${XFORMS_SOURCE_SOFTMODEM}
   ${T_SOURCE}
   ${CONFIG_SOURCES}
   ${SHLIB_LOADER_SOURCES}
@@ -2445,7 +2439,7 @@ add_executable(nr-uesoftmodem
 
 target_link_libraries (nr-uesoftmodem
   -Wl,--start-group
-  RRC_LIB NR_RRC_LIB SECU_CN SECU_OSA UTIL HASHTABLE SCTP_CLIENT UDP SCHED_RU_LIB SCHED_UE_LIB SCHED_NR_UE_LIB PHY_COMMON PHY_NR_UE PHY_RU LFDS NR_L2_UE #NR_LTE_UE_REUSE_LIB 
+  RRC_LIB NR_RRC_LIB SECU_CN SECU_OSA UTIL HASHTABLE SCTP_CLIENT UDP SCHED_RU_LIB SCHED_UE_LIB SCHED_NR_UE_LIB PHY_COMMON PHY_NR_UE PHY_RU LFDS NR_L2_UE  MAC_NR_COMMON
   ${MSC_LIB} ${RAL_LIB} ${NAS_UE_LIB} ${ITTI_LIB} ${FLPT_MSG_LIB} ${ASYNC_IF_LIB} LFDS7 ${ATLAS_LIBRARIES}
   -Wl,--end-group z dl)
 
@@ -2461,17 +2455,14 @@ add_executable(nr-uesoftmodem-nos1
   ${rrc_h}
   ${s1ap_h}
 #  ${OPENAIR_BIN_DIR}/messages_xml.h
-  ${OPENAIR_TARGETS}/RT/USER/rt_wrapper.c
-  ${OPENAIR_TARGETS}/RT/USER/nr-ue.c
-  ${OPENAIR_TARGETS}/RT/USER/nr-uesoftmodem.c
+  ${OPENAIR_DIR}/executables/nr-ue.c
+  ${OPENAIR_DIR}/executables/nr-uesoftmodem.c
   ${OPENAIR1_DIR}/SIMULATION/TOOLS/taus.c
-  #${OPENAIR_TARGETS}/COMMON/create_tasks_ue.c
   ${OPENAIR_TARGETS}/ARCH/COMMON/common_lib.c
   ${OPENAIR1_DIR}/SIMULATION/ETH_TRANSPORT/netlink_init.c
   ${OPENAIR_DIR}/common/utils/utils.c
   ${OPENAIR_DIR}/common/utils/system.c
   ${XFORMS_SOURCE_NR}
-  ${XFORMS_SOURCE_SOFTMODEM}
   ${T_SOURCE}
   ${CONFIG_SOURCES}
   ${SHLIB_LOADER_SOURCES}
@@ -2479,7 +2470,7 @@ add_executable(nr-uesoftmodem-nos1
 
 target_link_libraries (nr-uesoftmodem-nos1
   -Wl,--start-group
-  RRC_LIB NR_RRC_LIB S1AP_LIB S1AP_ENB GTPV1U SECU_CN SECU_OSA UTIL HASHTABLE SCTP_CLIENT UDP SCHED_RU_LIB SCHED_UE_LIB SCHED_NR_UE_LIB PHY_COMMON PHY_NR_UE PHY_UE PHY_RU LFDS NR_L2_UE 
+  RRC_LIB NR_RRC_LIB S1AP_LIB S1AP_ENB GTPV1U SECU_CN SECU_OSA UTIL HASHTABLE SCTP_CLIENT UDP SCHED_RU_LIB SCHED_UE_LIB SCHED_NR_UE_LIB PHY_COMMON PHY_NR_UE PHY_UE PHY_RU LFDS NR_L2_UE MAC_NR_COMMON
   ${MSC_LIB} ${RAL_LIB} ${ITTI_LIB} ${FLPT_MSG_LIB} ${ASYNC_IF_LIB} LFDS7 ${ATLAS_LIBRARIES}
   -Wl,--end-group z dl)
 
@@ -2523,6 +2514,7 @@ target_link_libraries (nr-uesoftmodem-nos1 ${T_LIB})
 add_executable(dlsim_tm4
   ${OPENAIR1_DIR}/SIMULATION/LTE_PHY/dlsim_tm4.c
   ${OPENAIR1_DIR}/PHY/TOOLS/lte_phy_scope_tm4.c
+  ${OPENAIR_DIR}/common/utils/system.c
   ${T_SOURCE}
   )
 target_link_libraries (dlsim_tm4
@@ -2535,6 +2527,12 @@ add_executable(polartest
   ${OPENAIR_DIR}/common/utils/backtrace.c)
 target_link_libraries(polartest SIMU PHY PHY_NR PHY_COMMON m ${ATLAS_LIBRARIES})
 
+
+add_executable(smallblocktest
+  ${OPENAIR1_DIR}/PHY/CODING/TESTBENCH/smallblocktest.c
+  ${OPENAIR_DIR}/common/utils/backtrace.c)
+target_link_libraries(smallblocktest SIMU PHY PHY_NR PHY_COMMON m ${ATLAS_LIBRARIES})
+
 add_executable(ldpctest  
   ${OPENAIR1_DIR}/PHY/CODING/TESTBENCH/ldpctest.c
   ${OPENAIR_DIR}/common/utils/backtrace.c)
@@ -2543,12 +2541,14 @@ target_link_libraries(ldpctest SIMU PHY PHY_NR m ${ATLAS_LIBRARIES})
 add_executable(nr_dlschsim  
   ${OPENAIR1_DIR}/SIMULATION/NR_PHY/dlschsim.c 
   ${OPENAIR_DIR}/common/utils/backtrace.c
+  ${OPENAIR_DIR}/common/utils/system.c
   ${T_SOURCE})
 target_link_libraries(nr_dlschsim -Wl,--start-group UTIL SIMU PHY_COMMON PHY_NR PHY_NR_UE SCHED_NR_LIB CONFIG_LIB -Wl,--end-group m pthread ${ATLAS_LIBRARIES} ${T_LIB} dl)
 
 add_executable(nr_pbchsim  
   ${OPENAIR1_DIR}/SIMULATION/NR_PHY/pbchsim.c 
   ${OPENAIR_DIR}/common/utils/backtrace.c
+  ${OPENAIR_DIR}/common/utils/system.c
   ${T_SOURCE})
 target_link_libraries(nr_pbchsim  -Wl,--start-group UTIL SIMU PHY_COMMON PHY_NR PHY_NR_UE SCHED_NR_LIB CONFIG_LIB -Wl,--end-group m pthread ${ATLAS_LIBRARIES} ${T_LIB} dl)
 
@@ -2563,8 +2563,15 @@ target_link_libraries(nr_pucchsim  -Wl,--start-group UTIL SIMU PHY_COMMON PHY_NR
 add_executable(nr_dlsim
   ${OPENAIR1_DIR}/SIMULATION/NR_PHY/dlsim.c 
   ${OPENAIR_DIR}/common/utils/backtrace.c
+  ${OPENAIR_DIR}/common/utils/system.c
   ${T_SOURCE})   
-target_link_libraries(nr_dlsim  -Wl,--start-group UTIL SIMU PHY_COMMON PHY_NR PHY_NR_UE SCHED_NR_LIB SCHED_NR_UE_LIB MAC_NR MAC_UE_NR RRC_LIB NR_RRC_LIB CONFIG_LIB L2_NR -Wl,--end-group m pthread ${ATLAS_LIBRARIES} ${T_LIB} dl)
+target_link_libraries(nr_dlsim  -Wl,--start-group UTIL SIMU PHY_COMMON PHY_NR PHY_NR_UE SCHED_NR_LIB SCHED_NR_UE_LIB MAC_NR MAC_UE_NR MAC_NR_COMMON RRC_LIB NR_RRC_LIB CONFIG_LIB L2_NR -Wl,--end-group m pthread ${ATLAS_LIBRARIES} ${T_LIB} dl)
+
+add_executable(nr_ulschsim
+  ${OPENAIR1_DIR}/SIMULATION/NR_PHY/ulschsim.c
+  ${OPENAIR_DIR}/common/utils/backtrace.c
+  ${T_SOURCE})
+target_link_libraries(nr_ulschsim -Wl,--start-group UTIL SIMU PHY_COMMON PHY_NR PHY_NR_UE SCHED_NR_LIB CONFIG_LIB -Wl,--end-group m pthread ${ATLAS_LIBRARIES} ${T_LIB} dl)
 
 
 foreach(myExe dlsim dlsim_tm7 ulsim pbchsim scansim mbmssim pdcchsim pucchsim prachsim syncsim)
@@ -2572,6 +2579,7 @@ foreach(myExe dlsim dlsim_tm7 ulsim pbchsim scansim mbmssim pdcchsim pucchsim pr
   add_executable(${myExe}
     ${OPENAIR1_DIR}/SIMULATION/LTE_PHY/${myExe}.c
     ${OPENAIR_DIR}/common/utils/backtrace.c
+  ${OPENAIR_DIR}/common/utils/system.c
     ${XFORMS_SOURCE}
     ${T_SOURCE}
     ${CONFIG_SOURCES}
@@ -2697,7 +2705,9 @@ L2
 L2_NR
 L2_UE
 NR_L2_UE
-NR_LTE_UE_REUSE_LIB
+MAC_NR_COMMON
+MAC_NR
+MAC_UE_NR
 CN_UTILS
 GTPV1U
 SCTP_CLIENT
diff --git a/cmake_targets/autotests/test_case_list.xml b/cmake_targets/autotests/test_case_list.xml
index 2c47513c34..792e46cec6 100644
--- a/cmake_targets/autotests/test_case_list.xml
+++ b/cmake_targets/autotests/test_case_list.xml
@@ -1116,7 +1116,50 @@
       <search_expr_false>segmentation fault|assertion|exiting|fatal</search_expr_false>
       <nruns>3</nruns>
     </testCase> 
+
+    <testCase id="015107">
+      <class>execution</class>
+      <desc>shortblocktest Test cases. (Test1: 3 bits),
+      (Test2: 6 bits),
+      (Test3: 7 bits),
+      (Test4: 11 bits)</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/smallblocktest.Rel15</main_exec>
+      <main_exec_args>-l 3 -s -4 -d 1 -i 10000
+      -l 6 -s -4 -d 1 -i 10000
+      -l 7 -s -4 -d 1 -i 10000
+      -l 11 -s -4 -d 1 -i 10000</main_exec_args>
+      <tags>smallblocktest.test1 smallblocktest.test2 smallblocktest.test3 smallblocktest.test4</tags>
+      <search_expr_true>BLER= 0.000000</search_expr_true>
+      <search_expr_false>segmentation fault|assertion|exiting|fatal</search_expr_false>
+      <nruns>3</nruns>
+    </testCase>
+
     
+    <testCase id="015108">
+      <class>execution</class>
+      <desc>nr_ulschsim Test cases. (Test1: 106 PRB),
+                                    (Test2: 217 PRB),
+                                    (Test3: 273 PRB)</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_ulschsim.Rel15</main_exec>
+      <main_exec_args>-R 106 -m9 -s13 -n100
+                      -R 217 -m15 -s15 -n100
+                      -R 273 -m19 -s20 -n100</main_exec_args>
+      <tags>nr_ulschsim.test1 nr_ulschsim.test2 nr_ulschsim.test3</tags>
+      <search_expr_true>PUSCH test OK</search_expr_true>
+      <search_expr_false>segmentation fault|assertion|exiting|fatal</search_expr_false>
+      <nruns>3</nruns>
+    </testCase>
+
     <testCase id="015110">
       <class>execution</class>
       <desc>dlsim_tm4 test cases (Test 1: 10 MHz, R2.FDD (MCS 5), EVA5, -1dB), 
diff --git a/cmake_targets/build_oai b/cmake_targets/build_oai
index 4ac63a376f..ecd53cc87c 100755
--- a/cmake_targets/build_oai
+++ b/cmake_targets/build_oai
@@ -80,8 +80,6 @@ function print_help() {
 This program installs OpenAirInterface Software
 You should have ubuntu 16.xx or 18.04 updated
 Options
--h
-   This help
 -c | --clean
    Erase all files to make a rebuild from start
 -C | --clean-all
@@ -422,11 +420,6 @@ function main() {
   
   CMAKE_CMD="$CMAKE_CMD .."
   echo_info "CMAKE_CMD=$CMAKE_CMD"
-  if [ "$eNB" = "1" -o "$gNB" = "1" ] && [ "$UE" = "1" -o "$nrUE" = "1" ]; then
-    echo_error "Cannot build UE/nrUE and eNB/gNB on one build_oai execution"
-    echo_error "use 2 build_oai invocations"
-    exit
-  fi
 
   #########################################################
   # check validity of HW and TP parameters for eNB / gNB
@@ -691,7 +684,7 @@ function main() {
     echo_info "Compiling unitary tests simulators"
     # TODO: fix: dlsim_tm4 pucchsim prachsim pdcchsim pbchsim mbmssim
     #simlist="dlsim_tm4 dlsim ulsim pucchsim prachsim pdcchsim pbchsim mbmssim"
-    simlist="nr_pucchsim dlsim ulsim polartest ldpctest nr_pbchsim nr_dlschsim nr_dlsim"
+    simlist="nr_pucchsim dlsim ulsim polartest ldpctest smallblocktest nr_pbchsim nr_dlschsim nr_dlsim nr_ulschsim"
     for f in $simlist ; do
       compilations \
       phy_simulators $f \
diff --git a/cmake_targets/tools/build_helper b/cmake_targets/tools/build_helper
index 8c5d33975c..1c4b291069 100755
--- a/cmake_targets/tools/build_helper
+++ b/cmake_targets/tools/build_helper
@@ -683,7 +683,7 @@ install_asn1c_from_source(){
     # better to use a given commit than a branch in case the branch
     # is updated and requires modifications in the source of OAI
     #git checkout velichkov_s1ap_plus_option_group
-    git checkout d3aed06bb2bec7df1b5c6d0333f8c7dfc5993372
+    git checkout f12568d617dbf48497588f8e227d70388fa217c9
     autoreconf -iv
     ./configure
     make -j`nproc`
diff --git a/common/utils/LOG/log.c b/common/utils/LOG/log.c
index a92bdf11e4..1124a26b72 100644
--- a/common/utils/LOG/log.c
+++ b/common/utils/LOG/log.c
@@ -40,7 +40,7 @@
 #include "assertions.h"
 
 #if defined(ENABLE_ITTI)
-# include "intertask_interface.h"
+  #include "intertask_interface.h"
 #endif
 
 # include <pthread.h>
@@ -75,16 +75,14 @@ char *log_level_highlight_start[] = {LOG_RED, LOG_ORANGE, "", LOG_BLUE, LOG_CYBL
 char *log_level_highlight_end[]   = {LOG_RESET,LOG_RESET,LOG_RESET, LOG_RESET,LOG_RESET};   /*!< \brief Optional end-format strings for highlighting */
 
 
-int write_file_matlab(const char *fname,const char *vname,void *data,int length,int dec,char format)
-{
-
+int write_file_matlab(const char *fname,const char *vname,void *data,int length,int dec,char format) {
   FILE *fp=NULL;
   int i;
 
   if (data == NULL)
-     return -1;
-  //printf("Writing %d elements of type %d to %s\n",length,format,fname);
+    return -1;
 
+  //printf("Writing %d elements of type %d to %s\n",length,format,fname);
 
   if (format == 10 || format ==11 || format == 12 || format == 13 || format == 14) {
     fp = fopen(fname,"a+");
@@ -92,8 +90,6 @@ int write_file_matlab(const char *fname,const char *vname,void *data,int length,
     fp = fopen(fname,"w+");
   }
 
-
-
   if (fp== NULL) {
     printf("[OPENAIR][FILE OUTPUT] Cannot open file %s\n",fname);
     return(-1);
@@ -102,121 +98,108 @@ int write_file_matlab(const char *fname,const char *vname,void *data,int length,
   if (format != 10 && format !=11  && format != 12 && format != 13 && format != 14)
     fprintf(fp,"%s = [",vname);
 
-
   switch (format) {
-  case 0:   // real 16-bit
+    case 0:   // real 16-bit
+      for (i=0; i<length; i+=dec) {
+        fprintf(fp,"%d\n",((short *)data)[i]);
+      }
 
-    for (i=0; i<length; i+=dec) {
-      fprintf(fp,"%d\n",((short *)data)[i]);
-    }
+      break;
 
-    break;
+    case 1:  // complex 16-bit
+    case 13:
+    case 14:
+    case 15:
+      for (i=0; i<length<<1; i+=(2*dec)) {
+        fprintf(fp,"%d + j*(%d)\n",((short *)data)[i],((short *)data)[i+1]);
+      }
 
-  case 1:  // complex 16-bit
-  case 13:
-  case 14:
-  case 15:
+      break;
 
-    for (i=0; i<length<<1; i+=(2*dec)) {
-      fprintf(fp,"%d + j*(%d)\n",((short *)data)[i],((short *)data)[i+1]);
+    case 2:  // real 32-bit
+      for (i=0; i<length; i+=dec) {
+        fprintf(fp,"%d\n",((int *)data)[i]);
+      }
 
-    }
+      break;
 
+    case 3: // complex 32-bit
+      for (i=0; i<length<<1; i+=(2*dec)) {
+        fprintf(fp,"%d + j*(%d)\n",((int *)data)[i],((int *)data)[i+1]);
+      }
 
-    break;
+      break;
 
-  case 2:  // real 32-bit
-    for (i=0; i<length; i+=dec) {
-      fprintf(fp,"%d\n",((int *)data)[i]);
-    }
+    case 4: // real 8-bit
+      for (i=0; i<length; i+=dec) {
+        fprintf(fp,"%d\n",((char *)data)[i]);
+      }
 
-    break;
+      break;
 
-  case 3: // complex 32-bit
-    for (i=0; i<length<<1; i+=(2*dec)) {
-      fprintf(fp,"%d + j*(%d)\n",((int *)data)[i],((int *)data)[i+1]);
-    }
+    case 5: // complex 8-bit
+      for (i=0; i<length<<1; i+=(2*dec)) {
+        fprintf(fp,"%d + j*(%d)\n",((char *)data)[i],((char *)data)[i+1]);
+      }
 
-    break;
+      break;
 
-  case 4: // real 8-bit
-    for (i=0; i<length; i+=dec) {
-      fprintf(fp,"%d\n",((char *)data)[i]);
-    }
+    case 6:  // real 64-bit
+      for (i=0; i<length; i+=dec) {
+        fprintf(fp,"%lld\n",((long long *)data)[i]);
+      }
 
-    break;
+      break;
 
-  case 5: // complex 8-bit
-    for (i=0; i<length<<1; i+=(2*dec)) {
-      fprintf(fp,"%d + j*(%d)\n",((char *)data)[i],((char *)data)[i+1]);
-    }
+    case 7: // real double
+      for (i=0; i<length; i+=dec) {
+        fprintf(fp,"%g\n",((double *)data)[i]);
+      }
 
-    break;
+      break;
 
-  case 6:  // real 64-bit
-    for (i=0; i<length; i+=dec) {
-      fprintf(fp,"%lld\n",((long long*)data)[i]);
-    }
+    case 8: // complex double
+      for (i=0; i<length<<1; i+=2*dec) {
+        fprintf(fp,"%g + j*(%g)\n",((double *)data)[i], ((double *)data)[i+1]);
+      }
 
-    break;
+      break;
 
-  case 7: // real double
-    for (i=0; i<length; i+=dec) {
-      fprintf(fp,"%g\n",((double *)data)[i]);
-    }
+    case 9: // real unsigned 8-bit
+      for (i=0; i<length; i+=dec) {
+        fprintf(fp,"%d\n",((unsigned char *)data)[i]);
+      }
 
-    break;
+      break;
 
-  case 8: // complex double
-    for (i=0; i<length<<1; i+=2*dec) {
-      fprintf(fp,"%g + j*(%g)\n",((double *)data)[i], ((double *)data)[i+1]);
-    }
+    case 10 : // case eren 16 bit complex :
+      for (i=0; i<length<<1; i+=(2*dec)) {
+        if((i < 2*(length-1)) && (i > 0))
+          fprintf(fp,"%d + j*(%d),",((short *)data)[i],((short *)data)[i+1]);
+        else if (i == 2*(length-1))
+          fprintf(fp,"%d + j*(%d);",((short *)data)[i],((short *)data)[i+1]);
+        else if (i == 0)
+          fprintf(fp,"\n%d + j*(%d),",((short *)data)[i],((short *)data)[i+1]);
+      }
 
-    break;
+      break;
 
-  case 9: // real unsigned 8-bit
-    for (i=0; i<length; i+=dec) {
-      fprintf(fp,"%d\n",((unsigned char *)data)[i]);
-    }
+    case 11 : //case eren 16 bit real for channel magnitudes:
+      for (i=0; i<length; i+=dec) {
+        if((i <(length-1))&& (i > 0))
+          fprintf(fp,"%d,",((short *)data)[i]);
+        else if (i == (length-1))
+          fprintf(fp,"%d;",((short *)data)[i]);
+        else if (i == 0)
+          fprintf(fp,"\n%d,",((short *)data)[i]);
+      }
 
-    break;
-
-
-  case 10 : // case eren 16 bit complex :
-
-    for (i=0; i<length<<1; i+=(2*dec)) {
-
-      if((i < 2*(length-1)) && (i > 0))
-        fprintf(fp,"%d + j*(%d),",((short *)data)[i],((short *)data)[i+1]);
-      else if (i == 2*(length-1))
-        fprintf(fp,"%d + j*(%d);",((short *)data)[i],((short *)data)[i+1]);
-      else if (i == 0)
-        fprintf(fp,"\n%d + j*(%d),",((short *)data)[i],((short *)data)[i+1]);
-
-
-
-    }
-
-    break;
-
-  case 11 : //case eren 16 bit real for channel magnitudes:
-    for (i=0; i<length; i+=dec) {
-
-      if((i <(length-1))&& (i > 0))
-        fprintf(fp,"%d,",((short *)data)[i]);
-      else if (i == (length-1))
-        fprintf(fp,"%d;",((short *)data)[i]);
-      else if (i == 0)
-        fprintf(fp,"\n%d,",((short *)data)[i]);
-    }
-
-    printf("\n eren: length :%d",length);
-    break;
-
-  case 12 : // case eren for log2_maxh real unsigned 8 bit
-    fprintf(fp,"%d \n",((unsigned char *)&data)[0]);
-    break;
+      printf("\n eren: length :%d",length);
+      break;
 
+    case 12 : // case eren for log2_maxh real unsigned 8 bit
+      fprintf(fp,"%d \n",((unsigned char *)&data)[0]);
+      break;
   }
 
   if (format != 10 && format !=11 && format !=12 && format != 13 && format != 15) {
@@ -235,131 +218,141 @@ int write_file_matlab(const char *fname,const char *vname,void *data,int length,
 void  log_getconfig(log_t *g_log) {
   char *gloglevel = NULL;
   int consolelog ;
-  
-  
   paramdef_t logparams_defaults[] = LOG_GLOBALPARAMS_DESC;
   paramdef_t logparams_level[MAX_LOG_PREDEF_COMPONENTS];
   paramdef_t logparams_logfile[MAX_LOG_PREDEF_COMPONENTS];
   paramdef_t logparams_debug[sizeof(log_maskmap)/sizeof(mapping)];
   paramdef_t logparams_dump[sizeof(log_maskmap)/sizeof(mapping)];
-
   int ret = config_get( logparams_defaults,sizeof(logparams_defaults)/sizeof(paramdef_t),CONFIG_STRING_LOG_PREFIX);
-  if (ret <0) {
-       fprintf(stderr,"[LOG] init aborted, configuration couldn't be performed");
-       return;
-  } 
 
-/* set LOG display options (enable/disable color, thread name, level ) */
+  if (ret <0) {
+    fprintf(stderr,"[LOG] init aborted, configuration couldn't be performed");
+    return;
+  }
+
+  /* set LOG display options (enable/disable color, thread name, level ) */
   for(int i=0; i<logparams_defaults[LOG_OPTIONS_IDX].numelt ; i++) {
-     for(int j=0; log_options[j].name != NULL ; j++) {
-        if (strcmp(logparams_defaults[LOG_OPTIONS_IDX].strlistptr[i],log_options[j].name) == 0) { 
-            g_log->flag = g_log->flag |  log_options[j].value;
-            break;
-        } else if (log_options[j+1].name == NULL){
-            fprintf(stderr,"Unknown log option: %s\n",logparams_defaults[LOG_OPTIONS_IDX].strlistptr[i]);
-            exit(-1);
-        }
-     } 
-  } 
-  
-/* build the parameter array for setting per component log level and infile options */  
+    for(int j=0; log_options[j].name != NULL ; j++) {
+      if (strcmp(logparams_defaults[LOG_OPTIONS_IDX].strlistptr[i],log_options[j].name) == 0) {
+        g_log->flag = g_log->flag |  log_options[j].value;
+        break;
+      } else if (log_options[j+1].name == NULL) {
+        fprintf(stderr,"Unknown log option: %s\n",logparams_defaults[LOG_OPTIONS_IDX].strlistptr[i]);
+        exit(-1);
+      }
+    }
+  }
+
+  /* build the parameter array for setting per component log level and infile options */
   memset(logparams_level,    0, sizeof(paramdef_t)*MAX_LOG_PREDEF_COMPONENTS);
   memset(logparams_logfile,  0, sizeof(paramdef_t)*MAX_LOG_PREDEF_COMPONENTS);
+
   for (int i=MIN_LOG_COMPONENTS; i < MAX_LOG_PREDEF_COMPONENTS; i++) {
     if(g_log->log_component[i].name == NULL) {
-       g_log->log_component[i].name = malloc(16);
-       sprintf((char *)g_log->log_component[i].name,"comp%i?",i);
-       logparams_logfile[i].paramflags = PARAMFLAG_DONOTREAD;
-       logparams_level[i].paramflags = PARAMFLAG_DONOTREAD;
+      g_log->log_component[i].name = malloc(16);
+      sprintf((char *)g_log->log_component[i].name,"comp%i?",i);
+      logparams_logfile[i].paramflags = PARAMFLAG_DONOTREAD;
+      logparams_level[i].paramflags = PARAMFLAG_DONOTREAD;
     }
+
     sprintf(logparams_level[i].optname,    LOG_CONFIG_LEVEL_FORMAT,       g_log->log_component[i].name);
     sprintf(logparams_logfile[i].optname,  LOG_CONFIG_LOGFILE_FORMAT,     g_log->log_component[i].name);
-/* workaround: all log options in existing configuration files use lower case component names
-   where component names include uppercase char in log.h....                                */ 
-    for (int j=0 ; j<strlen(logparams_level[i].optname); j++) 
-          logparams_level[i].optname[j] = tolower(logparams_level[i].optname[j]);
-    for (int j=0 ; j<strlen(logparams_level[i].optname); j++) 
-          logparams_logfile[i].optname[j] = tolower(logparams_logfile[i].optname[j]);
-/* */
+
+    /* workaround: all log options in existing configuration files use lower case component names
+       where component names include uppercase char in log.h....                                */
+    for (int j=0 ; j<strlen(logparams_level[i].optname); j++)
+      logparams_level[i].optname[j] = tolower(logparams_level[i].optname[j]);
+
+    for (int j=0 ; j<strlen(logparams_level[i].optname); j++)
+      logparams_logfile[i].optname[j] = tolower(logparams_logfile[i].optname[j]);
+
+    /* */
     logparams_level[i].defstrval     = gloglevel;
     logparams_logfile[i].defuintval  = 0;
     logparams_logfile[i].numelt      = 0;
     logparams_level[i].numelt        = 0;
     logparams_level[i].type          = TYPE_STRING;
     logparams_logfile[i].type        = TYPE_UINT;
-
     logparams_logfile[i].paramflags  = logparams_logfile[i].paramflags|PARAMFLAG_BOOL;
-    }
-/* read the per component parameters */
-  config_get( logparams_level,    MAX_LOG_PREDEF_COMPONENTS,CONFIG_STRING_LOG_PREFIX); 
-  config_get( logparams_logfile,  MAX_LOG_PREDEF_COMPONENTS,CONFIG_STRING_LOG_PREFIX); 
-/* now set the log levels and infile option, according to what we read */
+  }
+
+  /* read the per component parameters */
+  config_get( logparams_level,    MAX_LOG_PREDEF_COMPONENTS,CONFIG_STRING_LOG_PREFIX);
+  config_get( logparams_logfile,  MAX_LOG_PREDEF_COMPONENTS,CONFIG_STRING_LOG_PREFIX);
+
+  /* now set the log levels and infile option, according to what we read */
   for (int i=MIN_LOG_COMPONENTS; i < MAX_LOG_PREDEF_COMPONENTS; i++) {
     g_log->log_component[i].level = map_str_to_int(log_level_names,    *(logparams_level[i].strptr));
     set_log(i, g_log->log_component[i].level);
+
     if (*(logparams_logfile[i].uptr) == 1)
-        set_component_filelog(i);
+      set_component_filelog(i);
   }
 
-/* build then read the debug and dump parameter array */
-  for (int i=0;log_maskmap[i].name != NULL ; i++) {
-      sprintf(logparams_debug[i].optname,  LOG_CONFIG_DEBUG_FORMAT, log_maskmap[i].name);
-      sprintf(logparams_dump[i].optname,   LOG_CONFIG_DUMP_FORMAT, log_maskmap[i].name);
-      logparams_debug[i].defuintval  = 0;
-      logparams_debug[i].type        = TYPE_UINT;
-      logparams_debug[i].paramflags  = PARAMFLAG_BOOL;
-      logparams_debug[i].uptr        = NULL;
-      logparams_debug[i].chkPptr     = NULL;
-      logparams_debug[i].numelt      = 0;
-      logparams_dump[i].defuintval  = 0;
-      logparams_dump[i].type        = TYPE_UINT;
-      logparams_dump[i].paramflags  = PARAMFLAG_BOOL;
-      logparams_dump[i].uptr        = NULL;
-      logparams_dump[i].chkPptr     = NULL;
-      logparams_dump[i].numelt      = 0;
+  /* build then read the debug and dump parameter array */
+  for (int i=0; log_maskmap[i].name != NULL ; i++) {
+    sprintf(logparams_debug[i].optname,  LOG_CONFIG_DEBUG_FORMAT, log_maskmap[i].name);
+    sprintf(logparams_dump[i].optname,   LOG_CONFIG_DUMP_FORMAT, log_maskmap[i].name);
+    logparams_debug[i].defuintval  = 0;
+    logparams_debug[i].type        = TYPE_UINT;
+    logparams_debug[i].paramflags  = PARAMFLAG_BOOL;
+    logparams_debug[i].uptr        = NULL;
+    logparams_debug[i].chkPptr     = NULL;
+    logparams_debug[i].numelt      = 0;
+    logparams_dump[i].defuintval  = 0;
+    logparams_dump[i].type        = TYPE_UINT;
+    logparams_dump[i].paramflags  = PARAMFLAG_BOOL;
+    logparams_dump[i].uptr        = NULL;
+    logparams_dump[i].chkPptr     = NULL;
+    logparams_dump[i].numelt      = 0;
   }
-  config_get( logparams_debug,(sizeof(log_maskmap)/sizeof(mapping)) - 1 ,CONFIG_STRING_LOG_PREFIX);
-  config_get( logparams_dump,(sizeof(log_maskmap)/sizeof(mapping)) - 1 ,CONFIG_STRING_LOG_PREFIX);
-/* set the debug mask according to the debug parameters values */
+
+  config_get( logparams_debug,(sizeof(log_maskmap)/sizeof(mapping)) - 1,CONFIG_STRING_LOG_PREFIX);
+  config_get( logparams_dump,(sizeof(log_maskmap)/sizeof(mapping)) - 1,CONFIG_STRING_LOG_PREFIX);
+
+  /* set the debug mask according to the debug parameters values */
   for (int i=0; log_maskmap[i].name != NULL ; i++) {
     if (*(logparams_debug[i].uptr) )
-        g_log->debug_mask = g_log->debug_mask | log_maskmap[i].value;
+      g_log->debug_mask = g_log->debug_mask | log_maskmap[i].value;
+
     if (*(logparams_dump[i].uptr) )
-        g_log->dump_mask = g_log->dump_mask | log_maskmap[i].value;
-  } 
-/* log globally enabled/disabled */
+      g_log->dump_mask = g_log->dump_mask | log_maskmap[i].value;
+  }
+
+  /* log globally enabled/disabled */
   set_glog_onlinelog(consolelog);
 }
 
-int register_log_component(char *name, char *fext, int compidx)
-{
-int computed_compidx=compidx;
+int register_log_component(char *name, char *fext, int compidx) {
+  int computed_compidx=compidx;
 
   if (strlen(fext) > 3) {
-      fext[3]=0;  /* limit log file extension to 3 chars */
+    fext[3]=0;  /* limit log file extension to 3 chars */
   }
+
   if (compidx < 0) { /* this is not a pre-defined component */
-      for (int i = MAX_LOG_PREDEF_COMPONENTS; i< MAX_LOG_COMPONENTS; i++) {
-            if (g_log->log_component[i].name == NULL) {
-                computed_compidx=i;
-                break;
-            }
+    for (int i = MAX_LOG_PREDEF_COMPONENTS; i< MAX_LOG_COMPONENTS; i++) {
+      if (g_log->log_component[i].name == NULL) {
+        computed_compidx=i;
+        break;
       }
+    }
   }
+
   if (computed_compidx >= 0 && computed_compidx <MAX_LOG_COMPONENTS) {
-      g_log->log_component[computed_compidx].name = strdup(name);
-      g_log->log_component[computed_compidx].stream = stdout;
-      g_log->log_component[computed_compidx].filelog = 0;
-      g_log->log_component[computed_compidx].filelog_name = malloc(strlen(name)+16);/* /tmp/<name>.%s  */
-      sprintf(g_log->log_component[computed_compidx].filelog_name,"/tmp/%s.%s",name,fext);
+    g_log->log_component[computed_compidx].name = strdup(name);
+    g_log->log_component[computed_compidx].stream = stdout;
+    g_log->log_component[computed_compidx].filelog = 0;
+    g_log->log_component[computed_compidx].filelog_name = malloc(strlen(name)+16);/* /tmp/<name>.%s  */
+    sprintf(g_log->log_component[computed_compidx].filelog_name,"/tmp/%s.%s",name,fext);
   } else {
-      fprintf(stderr,"{LOG} %s %d Couldn't register componemt %s\n",__FILE__,__LINE__,name);
+    fprintf(stderr,"{LOG} %s %d Couldn't register componemt %s\n",__FILE__,__LINE__,name);
   }
-return computed_compidx;
+
+  return computed_compidx;
 }
 
-int logInit (void)
-{
+int logInit (void) {
   int i;
   g_log = calloc(1, sizeof(log_t));
 
@@ -367,10 +360,8 @@ int logInit (void)
     perror ("cannot allocated memory for log generation module \n");
     exit(EXIT_FAILURE);
   }
+
   memset(g_log,0,sizeof(log_t));
-
-
-
   register_log_component("PHY","log",PHY);
   register_log_component("MAC","log",MAC);
   register_log_component("OPT","log",OPT);
@@ -386,143 +377,121 @@ int logInit (void)
   register_log_component("OTG_JITTER","dat",OTG_JITTER);
   register_log_component("OCG","",OCG);
   register_log_component("PERF","",PERF);
-  register_log_component("OIP","",OIP); 
-  register_log_component("CLI","",CLI); 
-  register_log_component("MSC","log",MSC); 
-  register_log_component("OCM","log",OCM); 
-  register_log_component("HW","",HW); 
-  register_log_component("OSA","",OSA); 
-  register_log_component("eRAL","",RAL_ENB); 
-  register_log_component("mRAL","",RAL_UE); 
-  register_log_component("ENB_APP","log",ENB_APP); 
-  register_log_component("FLEXRAN_AGENT","log",FLEXRAN_AGENT); 
-  register_log_component("TMR","",TMR); 
-  register_log_component("USIM","txt",USIM);   
-  register_log_component("SIM","txt",SIM);  
-
+  register_log_component("OIP","",OIP);
+  register_log_component("CLI","",CLI);
+  register_log_component("MSC","log",MSC);
+  register_log_component("OCM","log",OCM);
+  register_log_component("HW","",HW);
+  register_log_component("OSA","",OSA);
+  register_log_component("eRAL","",RAL_ENB);
+  register_log_component("mRAL","",RAL_UE);
+  register_log_component("ENB_APP","log",ENB_APP);
+  register_log_component("FLEXRAN_AGENT","log",FLEXRAN_AGENT);
+  register_log_component("TMR","",TMR);
+  register_log_component("USIM","txt",USIM);
+  register_log_component("SIM","txt",SIM);
   /* following log component are used for the localization*/
   register_log_component("LOCALIZE","log",LOCALIZE);
   register_log_component("NAS","log",NAS);
   register_log_component("UDP","",UDP_);
-
-
   register_log_component("GTPV1U","",GTPU);
-
-
   register_log_component("S1AP","",S1AP);
   register_log_component("X2AP","",X2AP);
-
-
   register_log_component("SCTP","",SCTP);
   register_log_component("X2AP","",X2AP);
   register_log_component("LOADER","log",LOADER);
   register_log_component("ASN","log",ASN);
-  
-
 
   for (int i=0 ; log_level_names[i].name != NULL ; i++)
-      g_log->level2string[i]           = toupper(log_level_names[i].name[0]); // uppercased first letter of level name
-
-
- 
-
+    g_log->level2string[i]           = toupper(log_level_names[i].name[0]); // uppercased first letter of level name
 
   g_log->filelog_name = "/tmp/openair.log";
-
   log_getconfig(g_log);
 
-
-
   // set all unused component items to 0, they are for non predefined components
   for (i=MAX_LOG_PREDEF_COMPONENTS; i < MAX_LOG_COMPONENTS; i++) {
-        memset(&(g_log->log_component[i]),0,sizeof(log_component_t));
+    memset(&(g_log->log_component[i]),0,sizeof(log_component_t));
   }
-  printf("log init done\n");
 
+  printf("log init done\n");
   return 0;
 }
 
 
 char *log_getthreadname(char *threadname, int bufsize) {
+  int rt =   pthread_getname_np(pthread_self(), threadname,bufsize) ;
 
-int rt =   pthread_getname_np(pthread_self(), threadname,bufsize) ;  
-   if (rt == 0)
-   {
-     return threadname;
-   } else {
-     return "thread?";
-   }
+  if (rt == 0) {
+    return threadname;
+  } else {
+    return "thread?";
+  }
 }
 
 static int log_header(char *log_buffer, int buffsize, int comp, int level,const char *format) {
   char threadname[PR_SET_NAME];
-return  snprintf(log_buffer, buffsize , "%s%s[%s]%c %s %s%s",
-  	   log_level_highlight_end[level],
-  	   ( (g_log->flag & FLAG_NOCOLOR)?"":log_level_highlight_start[level]),
-  	   g_log->log_component[comp].name,
-  	   ( (g_log->flag & FLAG_LEVEL)?g_log->level2string[level]:' '),
-  	   ( (g_log->flag & FLAG_THREAD)?log_getthreadname(threadname,PR_SET_NAME+1):""),
-  	   format,
-           log_level_highlight_end[level]);
+  return  snprintf(log_buffer, buffsize, "%s%s[%s]%c %s %s%s",
+                   log_level_highlight_end[level],
+                   ( (g_log->flag & FLAG_NOCOLOR)?"":log_level_highlight_start[level]),
+                   g_log->log_component[comp].name,
+                   ( (g_log->flag & FLAG_LEVEL)?g_log->level2string[level]:' '),
+                   ( (g_log->flag & FLAG_THREAD)?log_getthreadname(threadname,PR_SET_NAME+1):""),
+                   format,
+                   log_level_highlight_end[level]);
 }
 
-void logRecord_mt(const char *file, const char *func, int line, int comp, int level, const char* format, ... )
-  {
-    char log_buffer[MAX_LOG_TOTAL]={0};
+void logRecord_mt(const char *file, const char *func, int line, int comp, int level, const char *format, ... ) {
+  char log_buffer[MAX_LOG_TOTAL]= {0};
   va_list args;
-
   va_start(args, format);
-
-
-
-
-  log_header(log_buffer,MAX_LOG_TOTAL ,comp, level,format);
+  log_header(log_buffer,MAX_LOG_TOTAL,comp, level,format);
   g_log->log_component[comp].vprint(g_log->log_component[comp].stream,log_buffer, args);
+  fflush(g_log->log_component[comp].stream);
   va_end(args);
-
-
 }
 
-void log_dump(int component, void *buffer, int buffsize,int datatype, const char* format, ... ) {
-va_list args;
-char *wbuf; 
+void log_dump(int component, void *buffer, int buffsize,int datatype, const char *format, ... ) {
+  va_list args;
+  char *wbuf;
 
+  switch(datatype) {
+    case LOG_DUMP_DOUBLE:
+      wbuf=malloc((buffsize * 10)  + 64 + MAX_LOG_TOTAL);
+      break;
 
-    switch(datatype) {
-       case LOG_DUMP_DOUBLE:
-            wbuf=malloc((buffsize * 10)  + 64 + MAX_LOG_TOTAL);
-       break;
-       case LOG_DUMP_CHAR:
-       default:
-            wbuf=malloc((buffsize * 3 ) + 64 + MAX_LOG_TOTAL);
-       break;
+    case LOG_DUMP_CHAR:
+    default:
+      wbuf=malloc((buffsize * 3 ) + 64 + MAX_LOG_TOTAL);
+      break;
+  }
+
+  if (wbuf != NULL) {
+    va_start(args, format);
+    int pos=log_header(wbuf,MAX_LOG_TOTAL,component, OAILOG_INFO,"");
+    int pos2=vsprintf(wbuf+pos,format, args);
+    pos=pos+pos2;
+    va_end(args);
+
+    for (int i=0; i<buffsize; i++) {
+      switch(datatype) {
+        case LOG_DUMP_DOUBLE:
+          pos = pos + sprintf(wbuf+pos,"%04.4lf ", (double)((double *)buffer)[i]);
+          break;
+
+        case LOG_DUMP_CHAR:
+        default:
+          pos = pos + sprintf(wbuf+pos,"%02x ", (unsigned char)((unsigned char *)buffer)[i]);
+          break;
+      }
     }
-    if (wbuf != NULL) {       
-       va_start(args, format);
-       int pos=log_header(wbuf,MAX_LOG_TOTAL ,component, OAILOG_INFO,"");
-       int pos2=vsprintf(wbuf+pos,format, args);
-       pos=pos+pos2;
-       va_end(args);
-      
-       for (int i=0; i<buffsize; i++) {
-            switch(datatype) {
-               case LOG_DUMP_DOUBLE:
-                    pos = pos + sprintf(wbuf+pos,"%04.4lf ", (double)((double *)buffer)[i]);
-               break;
-               case LOG_DUMP_CHAR:
-               default:
-                    pos = pos + sprintf(wbuf+pos,"%02x ", (unsigned char)((unsigned char *)buffer)[i]);
-               break;
-            }        
-       }
+
     sprintf(wbuf+pos,"\n");
     g_log->log_component[component].print(g_log->log_component[component].stream,wbuf);
     free(wbuf);
-    } 
+  }
 }
 
-int set_log(int component, int level)
-{
+int set_log(int component, int level) {
   /* Checking parameters */
   DevCheck((component >= MIN_LOG_COMPONENTS) && (component < MAX_LOG_COMPONENTS),
            component, MIN_LOG_COMPONENTS, MAX_LOG_COMPONENTS);
@@ -530,38 +499,34 @@ int set_log(int component, int level)
            OAILOG_ERR);
 
   if ( g_log->log_component[component].level != OAILOG_DISABLE )
-      g_log->log_component[component].savedlevel = g_log->log_component[component].level;
-  g_log->log_component[component].level = level;
+    g_log->log_component[component].savedlevel = g_log->log_component[component].level;
 
+  g_log->log_component[component].level = level;
   return 0;
 }
 
 
 
-void set_glog(int level)
-{
+void set_glog(int level) {
   for (int c=0; c< MAX_LOG_COMPONENTS; c++ ) {
-     set_log(c, level);
+    set_log(c, level);
   }
-  
 }
 
-void set_glog_onlinelog(int enable)
-{
+void set_glog_onlinelog(int enable) {
   for (int c=0; c< MAX_LOG_COMPONENTS; c++ ) {
-      if ( enable ) {
-        g_log->log_component[c].level = g_log->log_component[c].savedlevel;
-        g_log->log_component[c].vprint = vfprintf;
-        g_log->log_component[c].print = fprintf;
-        g_log->log_component[c].stream = stdout;
-      } else {
-        g_log->log_component[c].level = OAILOG_DISABLE;
-      }
-  }  
+    if ( enable ) {
+      g_log->log_component[c].level = g_log->log_component[c].savedlevel;
+      g_log->log_component[c].vprint = vfprintf;
+      g_log->log_component[c].print = fprintf;
+      g_log->log_component[c].stream = stdout;
+    } else {
+      g_log->log_component[c].level = OAILOG_DISABLE;
+    }
+  }
 }
-void set_glog_filelog(int enable)
-{
-static FILE *fptr;
+void set_glog_filelog(int enable) {
+  static FILE *fptr;
 
   if ( enable ) {
     fptr = fopen(g_log->filelog_name,"w");
@@ -574,33 +539,35 @@ static FILE *fptr;
   } else {
     for (int c=0; c< MAX_LOG_COMPONENTS; c++ ) {
       g_log->log_component[c].filelog =  0;
+
       if (fptr != NULL) {
         fclose(fptr);
       }
+
       g_log->log_component[c].stream = stdout;
-    }    
-  }  
+    }
+  }
 }
 
-void set_component_filelog(int comp)
-{
-    if (g_log->log_component[comp].stream == NULL || g_log->log_component[comp].stream == stdout) {
-      g_log->log_component[comp].stream = fopen(g_log->log_component[comp].filelog_name,"w");
-    }
-    g_log->log_component[comp].vprint = vfprintf;
-    g_log->log_component[comp].print = fprintf;
-    g_log->log_component[comp].filelog =  1;
+void set_component_filelog(int comp) {
+  if (g_log->log_component[comp].stream == NULL || g_log->log_component[comp].stream == stdout) {
+    g_log->log_component[comp].stream = fopen(g_log->log_component[comp].filelog_name,"w");
+  }
+
+  g_log->log_component[comp].vprint = vfprintf;
+  g_log->log_component[comp].print = fprintf;
+  g_log->log_component[comp].filelog =  1;
 }
-void close_component_filelog(int comp)
-{
-    g_log->log_component[comp].filelog =  0;
-    if (g_log->log_component[comp].stream != NULL && g_log->log_component[comp].stream != stdout ) {
-      fclose(g_log->log_component[comp].stream);
-      g_log->log_component[comp].stream = stdout;
-    }
-    g_log->log_component[comp].vprint = vfprintf;
-    g_log->log_component[comp].print = fprintf;
- 
+void close_component_filelog(int comp) {
+  g_log->log_component[comp].filelog =  0;
+
+  if (g_log->log_component[comp].stream != NULL && g_log->log_component[comp].stream != stdout ) {
+    fclose(g_log->log_component[comp].stream);
+    g_log->log_component[comp].stream = stdout;
+  }
+
+  g_log->log_component[comp].vprint = vfprintf;
+  g_log->log_component[comp].print = fprintf;
 }
 
 /*
@@ -608,8 +575,7 @@ void close_component_filelog(int comp)
  * with string value NULL
  */
 /* map a string to an int. Takes a mapping array and a string as arg */
-int map_str_to_int(mapping *map, const char *str)
-{
+int map_str_to_int(mapping *map, const char *str) {
   while (1) {
     if (map->name == NULL) {
       return(-1);
@@ -624,8 +590,7 @@ int map_str_to_int(mapping *map, const char *str)
 }
 
 /* map an int to a string. Takes a mapping array and a value */
-char *map_int_to_str(mapping *map, int val)
-{
+char *map_int_to_str(mapping *map, int val) {
   while (1) {
     if (map->name == NULL) {
       return NULL;
@@ -639,8 +604,7 @@ char *map_int_to_str(mapping *map, int val)
   }
 }
 
-int is_newline( char *str, int size)
-{
+int is_newline( char *str, int size) {
   int i;
 
   for (  i = 0; i < size; i++ ) {
@@ -653,85 +617,62 @@ int is_newline( char *str, int size)
   return 0;
 }
 
-void logClean (void)
-{
+void logClean (void) {
   int i;
   LOG_UI(PHY,"\n");
 
-
-
-
   for (i=MIN_LOG_COMPONENTS; i < MAX_LOG_COMPONENTS; i++) {
-     close_component_filelog(i);
+    close_component_filelog(i);
   }
 }
 
-  
+
 #ifdef LOG_TEST
 
-int main(int argc, char *argv[])
-{
-
+int main(int argc, char *argv[]) {
   logInit();
-
-
   test_log();
-
   return 1;
 }
 
-int test_log(void)
-{
+int test_log(void) {
   LOG_ENTER(MAC); // because the default level is DEBUG
   LOG_I(EMU, "1 Starting OAI logs version %s Build date: %s on %s\n",
         BUILD_VERSION, BUILD_DATE, BUILD_HOST);
   LOG_D(MAC, "1 debug  MAC \n");
   LOG_W(MAC, "1 warning MAC \n");
-
   set_log(EMU, OAILOG_INFO);
   set_log(MAC, OAILOG_WARNING);
-
   LOG_I(EMU, "2 Starting OAI logs version %s Build date: %s on %s\n",
         BUILD_VERSION, BUILD_DATE, BUILD_HOST);
   LOG_E(MAC, "2 error MAC\n");
   LOG_D(MAC, "2 debug  MAC \n");
   LOG_W(MAC, "2 warning MAC \n");
   LOG_I(MAC, "2 info MAC \n");
-
-
   set_log(MAC, OAILOG_NOTICE);
-
   LOG_ENTER(MAC);
   LOG_I(EMU, "3 Starting OAI logs version %s Build date: %s on %s\n",
         BUILD_VERSION, BUILD_DATE, BUILD_HOST);
   LOG_D(MAC, "3 debug  MAC \n");
   LOG_W(MAC, "3 warning MAC \n");
   LOG_I(MAC, "3 info MAC \n");
-
   set_log(MAC, LOG_DEBUG);
   set_log(EMU, LOG_DEBUG);
-
   LOG_ENTER(MAC);
   LOG_I(EMU, "4 Starting OAI logs version %s Build date: %s on %s\n",
         BUILD_VERSION, BUILD_DATE, BUILD_HOST);
   LOG_D(MAC, "4 debug  MAC \n");
   LOG_W(MAC, "4 warning MAC \n");
   LOG_I(MAC, "4 info MAC \n");
-
-
   set_log(MAC, LOG_DEBUG);
   set_log(EMU, LOG_DEBUG);
-
   LOG_I(LOG, "5 Starting OAI logs version %s Build date: %s on %s\n",
         BUILD_VERSION, BUILD_DATE, BUILD_HOST);
   LOG_D(MAC, "5 debug  MAC \n");
   LOG_W(MAC, "5 warning MAC \n");
   LOG_I(MAC, "5 info MAC \n");
-
-
   set_log(MAC, LOG_TRACE);
   set_log(EMU, LOG_TRACE);
-
   LOG_ENTER(MAC);
   LOG_I(LOG, "6 Starting OAI logs version %s Build date: %s on %s\n",
         BUILD_VERSION, BUILD_DATE, BUILD_HOST);
@@ -739,7 +680,6 @@ int test_log(void)
   LOG_W(MAC, "6 warning MAC \n");
   LOG_I(MAC, "6 info MAC \n");
   LOG_EXIT(MAC);
-
   return 0;
 }
 #endif
diff --git a/common/utils/LOG/log.h b/common/utils/LOG/log.h
index db73bd7f5b..b8a72ece7b 100644
--- a/common/utils/LOG/log.h
+++ b/common/utils/LOG/log.h
@@ -45,14 +45,15 @@
 #include <time.h>
 #include <stdint.h>
 #ifndef __STDC_FORMAT_MACROS
-#define __STDC_FORMAT_MACROS
+  #define __STDC_FORMAT_MACROS
 #endif
 #include <inttypes.h>
 #ifndef _GNU_SOURCE
-#define _GNU_SOURCE
+  #define _GNU_SOURCE
 #endif
 #include <pthread.h>
 #include "T.h"
+#include <common/utils/utils.h>
 /*----------------------------------------------------------------------------*/
 
 #ifdef __cplusplus
@@ -82,11 +83,11 @@ extern "C" {
  *  @brief LOG defines 9 levels of messages for users. Importance of these levels decrease gradually from 0 to 8
  * @{*/
 # define  OAILOG_DISABLE -1 /*!< \brief disable all LOG messages, cannot be used in LOG macros, use only in LOG module */
-# define  OAILOG_ERR      0 /*!< \brief critical error conditions, impact on "must have" fuctinalities */
+# define  OAILOG_ERR      0 /*!< \brief critical error conditions, impact on "must have" functionalities */
 # define  OAILOG_WARNING  1 /*!< \brief warning conditions, shouldn't happen but doesn't impact "must have" functionalities */
 # define  OAILOG_INFO     2 /*!< \brief informational messages most people don't need, shouldn't impact real-time behavior */
-# define  OAILOG_DEBUG    3 /*!< \brief first level debug-level messages, for developers , may impact real-time behavior */
-# define  OAILOG_TRACE    4 /*!< \brief  second level debug-level messages, for developers ,likely impact real-time behavior*/
+# define  OAILOG_DEBUG    3 /*!< \brief first level debug-level messages, for developers, may impact real-time behavior */
+# define  OAILOG_TRACE    4 /*!< \brief second level debug-level messages, for developers, likely impact real-time behavior*/
 
 #define NUM_LOG_LEVEL 5 /*!< \brief the number of message levels users have with LOG (OAILOG_DISABLE is not available to user as a level, so it is not included)*/
 /* @}*/
@@ -127,11 +128,11 @@ extern "C" {
 
 /** @defgroup macros to identify a debug entity
  *  @ingroup each macro is a bit mask where the unique bit set identifies an entity to be debugged
- *            it allows to dynamically activate or not blocks of code. The  LOG_MASKMAP_INIT macro 
+ *            it allows to dynamically activate or not blocks of code. The  LOG_MASKMAP_INIT macro
  *            is used to map a character string name to each debug bit, it allows to set or clear
  *            the corresponding bit via the defined name, from the configuration or from the telnet
  *            server.
- *  @brief 
+ *  @brief
  * @{*/
 #define DEBUG_PRACH        (1<<0)
 #define DEBUG_RU           (1<<1)
@@ -150,22 +151,22 @@ extern "C" {
 
 
 #define LOG_MASKMAP_INIT {\
-  {"PRACH",       DEBUG_PRACH},\
-  {"RU",          DEBUG_RU},\
-  {"UE_PHYPROC",  DEBUG_UE_PHYPROC},\
-  {"LTEESTIM",    DEBUG_LTEESTIM},\
-  {"DLCELLSPEC",  DEBUG_DLCELLSPEC},\
-  {"ULSCH",       DEBUG_ULSCH},\
-  {"RRC",         DEBUG_RRC},\
-  {"PDCP",        DEBUG_PDCP},\
-  {"DFT",         DEBUG_DFT},\
-  {"ASN1",        DEBUG_ASN1},\
-  {"CTRLSOCKET",  DEBUG_CTRLSOCKET},\
-  {"SECURITY",    DEBUG_SECURITY},\
-  {"NAS",         DEBUG_NAS},\
-  {"UE_TIMING",   UE_TIMING},\
-  {NULL,-1}\
-}
+    {"PRACH",       DEBUG_PRACH},\
+    {"RU",          DEBUG_RU},\
+    {"UE_PHYPROC",  DEBUG_UE_PHYPROC},\
+    {"LTEESTIM",    DEBUG_LTEESTIM},\
+    {"DLCELLSPEC",  DEBUG_DLCELLSPEC},\
+    {"ULSCH",       DEBUG_ULSCH},\
+    {"RRC",         DEBUG_RRC},\
+    {"PDCP",        DEBUG_PDCP},\
+    {"DFT",         DEBUG_DFT},\
+    {"ASN1",        DEBUG_ASN1},\
+    {"CTRLSOCKET",  DEBUG_CTRLSOCKET},\
+    {"SECURITY",    DEBUG_SECURITY},\
+    {"NAS",         DEBUG_NAS},\
+    {"UE_TIMING",   UE_TIMING},\
+    {NULL,-1}\
+  }
 
 
 
@@ -178,51 +179,51 @@ extern "C" {
 
 
 typedef enum {
-    MIN_LOG_COMPONENTS = 0,
-    PHY = MIN_LOG_COMPONENTS,
-    MAC,
-    EMU,
-    SIM,
-    OCG,
-    OMG,
-    OPT,
-    OTG,
-    OTG_LATENCY,
-    OTG_LATENCY_BG,
-    OTG_GP,
-    OTG_GP_BG,
-    OTG_JITTER,
-    RLC,
-    PDCP,
-    RRC,
-    NAS,
-    PERF,
-    OIP,
-    CLI,
-    MSC,
-    OCM,
-    UDP_,
-    GTPU,
-    SPGW,
-    S1AP,
-    SCTP,
-    HW,
-    OSA,
-    RAL_ENB,
-    RAL_UE,
-    ENB_APP,
-    FLEXRAN_AGENT,
-    TMR,
-    USIM,
-    LOCALIZE,
-    X2AP,
-    GNB_APP,
-    NR_RRC,
-    NR_MAC,
-    NR_PHY,
-    LOADER,
-    ASN,
-    MAX_LOG_PREDEF_COMPONENTS,
+  MIN_LOG_COMPONENTS = 0,
+  PHY = MIN_LOG_COMPONENTS,
+  MAC,
+  EMU,
+  SIM,
+  OCG,
+  OMG,
+  OPT,
+  OTG,
+  OTG_LATENCY,
+  OTG_LATENCY_BG,
+  OTG_GP,
+  OTG_GP_BG,
+  OTG_JITTER,
+  RLC,
+  PDCP,
+  RRC,
+  NAS,
+  PERF,
+  OIP,
+  CLI,
+  MSC,
+  OCM,
+  UDP_,
+  GTPU,
+  SPGW,
+  S1AP,
+  SCTP,
+  HW,
+  OSA,
+  RAL_ENB,
+  RAL_UE,
+  ENB_APP,
+  FLEXRAN_AGENT,
+  TMR,
+  USIM,
+  LOCALIZE,
+  X2AP,
+  GNB_APP,
+  NR_RRC,
+  NR_MAC,
+  NR_PHY,
+  LOADER,
+  ASN,
+  MAX_LOG_PREDEF_COMPONENTS,
 }
 comp_name_t;
 
@@ -231,42 +232,42 @@ comp_name_t;
 
 
 typedef struct {
-    char *name; /*!< \brief string name of item */
-    int value;  /*!< \brief integer value of mapping */
+  char *name; /*!< \brief string name of item */
+  int value;  /*!< \brief integer value of mapping */
 } mapping;
 
 typedef int(*log_vprint_func_t)(FILE *stream, const char *format, va_list ap );
 typedef int(*log_print_func_t)(FILE *stream, const char *format, ... );
 typedef struct  {
-    const char        *name;
-    int               level;
-    int               savedlevel;
-    int               flag;
-    int               filelog;
-    char              *filelog_name;
-    FILE              *stream;
-    log_vprint_func_t vprint;
-    log_print_func_t  print;
-    /* SR: make the log buffer component relative */
-    char             log_buffer[MAX_LOG_TOTAL];
+  const char        *name;
+  int               level;
+  int               savedlevel;
+  int               flag;
+  int               filelog;
+  char              *filelog_name;
+  FILE              *stream;
+  log_vprint_func_t vprint;
+  log_print_func_t  print;
+  /* SR: make the log buffer component relative */
+  char             log_buffer[MAX_LOG_TOTAL];
 } log_component_t;
 
 
 typedef struct {
-    log_component_t         log_component[MAX_LOG_COMPONENTS];
-    char                    level2string[NUM_LOG_LEVEL];
-    int                     flag;
-    char*                   filelog_name;
-    uint64_t                debug_mask;
-    uint64_t                dump_mask;
+  log_component_t         log_component[MAX_LOG_COMPONENTS];
+  char                    level2string[NUM_LOG_LEVEL];
+  int                     flag;
+  char                   *filelog_name;
+  uint64_t                debug_mask;
+  uint64_t                dump_mask;
 } log_t;
 
 
 #if defined(ENABLE_ITTI)
 typedef enum log_instance_type_e {
-    LOG_INSTANCE_UNKNOWN,
-    LOG_INSTANCE_ENB,
-    LOG_INSTANCE_UE,
+  LOG_INSTANCE_UNKNOWN,
+  LOG_INSTANCE_ENB,
+  LOG_INSTANCE_UE,
 } log_instance_type_t;
 
 void log_set_instance_type (log_instance_type_t instance);
@@ -277,9 +278,9 @@ void log_set_instance_type (log_instance_type_t instance);
 log_t *g_log;
 #else
 #ifdef __cplusplus
-   extern "C" {
+extern "C" {
 #endif
-extern log_t *g_log;
+  extern log_t *g_log;
 #ifdef __cplusplus
 }
 #endif
@@ -289,7 +290,7 @@ extern log_t *g_log;
 /*----------------------------------------------------------------------------*/
 int  logInit (void);
 void logRecord_mt(const char *file, const char *func, int line,int comp, int level, const char *format, ...) __attribute__ ((format (printf, 6, 7)));
-void log_dump(int component, void *buffer, int buffsize,int datatype, const char* format, ... );
+void log_dump(int component, void *buffer, int buffsize,int datatype, const char *format, ... );
 int  set_log(int component, int level);
 void set_glog(int level);
 
@@ -332,22 +333,22 @@ int32_t write_file_matlab(const char *fname, const char *vname, void *data, int
 #define LOG_CONFIG_DUMP_FORMAT                             "%s_dump"
 
 #define LOG_CONFIG_HELP_OPTIONS      " list of comma separated options to enable log module behavior. Available options: \n"\
-                                     " nocolor:   disable color usage in log messages\n"\
-				     " level:     add log level indication in log messages\n"\
-				     " thread:    add threads names in log messages\n"
-				     
+  " nocolor:   disable color usage in log messages\n"\
+  " level:     add log level indication in log messages\n"\
+  " thread:    add threads names in log messages\n"
+
+
 
 
-                   
 /*------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
-/*                                       LOG globalconfiguration parameters										                                                */
-/*   optname                            help                                                paramflags       XXXptr	                   defXXXval				      type	 numelt	*/
+/*                                       LOG globalconfiguration parameters                                                                   */
+/*   optname                            help                                                paramflags       XXXptr                    defXXXval              type   numelt */
 /*------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
 #define LOG_GLOBALPARAMS_DESC { \
-{LOG_CONFIG_STRING_GLOBAL_LOG_LEVEL,    "Default log level for all componemts\n",              0,  	      strptr:(char **)&gloglevel,    defstrval:log_level_names[2].name,    TYPE_STRING,    0}, \
-{LOG_CONFIG_STRING_GLOBAL_LOG_ONLINE,   "Default console output option, for all components\n", 0,  	      iptr:&(consolelog),            defintval:1,                          TYPE_INT,       0}, \
-{LOG_CONFIG_STRING_GLOBAL_LOG_OPTIONS,  LOG_CONFIG_HELP_OPTIONS,                               0,  	      strlistptr:NULL,               defstrlistval:NULL,                   TYPE_STRINGLIST,0} \
-}
+    {LOG_CONFIG_STRING_GLOBAL_LOG_LEVEL,    "Default log level for all componemts\n",              0,         strptr:(char **)&gloglevel,    defstrval:log_level_names[2].name,    TYPE_STRING,    0}, \
+    {LOG_CONFIG_STRING_GLOBAL_LOG_ONLINE,   "Default console output option, for all components\n", 0,         iptr:&(consolelog),            defintval:1,                          TYPE_INT,       0}, \
+    {LOG_CONFIG_STRING_GLOBAL_LOG_OPTIONS,  LOG_CONFIG_HELP_OPTIONS,                               0,         strlistptr:NULL,               defstrlistval:NULL,                   TYPE_STRINGLIST,0} \
+  }
 
 #define LOG_OPTIONS_IDX   2
 /*----------------------------------------------------------------------------------*/
@@ -359,23 +360,23 @@ int32_t write_file_matlab(const char *fname, const char *vname, void *data, int
 #define LOG_DUMP_DOUBLE     1
 // debugging macros
 #define LOG_F  LOG_I           /* because  LOG_F was originaly to dump a message or buffer but is also used as a regular level...., to dump use LOG_DUMPMSG */
-#  if T_TRACER 
-     /* per component, level dependant macros */
-#    define LOG_E(c, x...) do { if (T_stdout) { if( g_log->log_component[c].level >= OAILOG_ERR    ) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_ERR, x)     ;} else { T(T_LEGACY_ ## c ## _ERROR, T_PRINTF(x))   ;}} while (0) 
-#    define LOG_W(c, x...) do { if (T_stdout) { if( g_log->log_component[c].level >= OAILOG_WARNING) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_WARNING, x) ;} else { T(T_LEGACY_ ## c ## _WARNING, T_PRINTF(x)) ;}} while (0) 
-#    define LOG_I(c, x...) do { if (T_stdout) { if( g_log->log_component[c].level >= OAILOG_INFO   ) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_INFO, x)    ;} else { T(T_LEGACY_ ## c ## _INFO, T_PRINTF(x))    ;}} while (0) 
-#    define LOG_D(c, x...) do { if (T_stdout) { if( g_log->log_component[c].level >= OAILOG_DEBUG  ) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_DEBUG, x)   ;} else { T(T_LEGACY_ ## c ## _DEBUG, T_PRINTF(x))   ;}} while (0) 
-#    define LOG_T(c, x...) do { if (T_stdout) { if( g_log->log_component[c].level >= OAILOG_TRACE  ) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_TRACE, x)   ;} else { T(T_LEGACY_ ## c ## _TRACE, T_PRINTF(x))   ;}} while (0) 
-    /* macro used to dump a buffer or a message as in openair2/RRC/LTE/RRC_eNB.c, replaces LOG_F macro */
+#  if T_TRACER
+/* per component, level dependant macros */
+#    define LOG_E(c, x...) do { if (T_stdout) { if( g_log->log_component[c].level >= OAILOG_ERR    ) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_ERR, x)     ;} else { T(T_LEGACY_ ## c ## _ERROR, T_PRINTF(x))   ;}} while (0)
+#    define LOG_W(c, x...) do { if (T_stdout) { if( g_log->log_component[c].level >= OAILOG_WARNING) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_WARNING, x) ;} else { T(T_LEGACY_ ## c ## _WARNING, T_PRINTF(x)) ;}} while (0)
+#    define LOG_I(c, x...) do { if (T_stdout) { if( g_log->log_component[c].level >= OAILOG_INFO   ) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_INFO, x)    ;} else { T(T_LEGACY_ ## c ## _INFO, T_PRINTF(x))    ;}} while (0)
+#    define LOG_D(c, x...) do { if (T_stdout) { if( g_log->log_component[c].level >= OAILOG_DEBUG  ) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_DEBUG, x)   ;} else { T(T_LEGACY_ ## c ## _DEBUG, T_PRINTF(x))   ;}} while (0)
+#    define LOG_T(c, x...) do { if (T_stdout) { if( g_log->log_component[c].level >= OAILOG_TRACE  ) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_TRACE, x)   ;} else { T(T_LEGACY_ ## c ## _TRACE, T_PRINTF(x))   ;}} while (0)
+/* macro used to dump a buffer or a message as in openair2/RRC/LTE/RRC_eNB.c, replaces LOG_F macro */
 #    define LOG_DUMPMSG(c, f, b, s, x...) do {  if(g_log->dump_mask & f) log_dump(c, b, s, LOG_DUMP_CHAR, x)  ;}   while (0)  /* */
 #    define nfapi_log(FILE, FNC, LN, COMP, LVL, F...)  do { if (T_stdout) { logRecord_mt(__FILE__, __FUNCTION__, __LINE__,COMP, LVL, F)  ;}}   while (0)  /* */
-     /* bitmask dependant macros, to isolate debugging code */
+/* bitmask dependant macros, to isolate debugging code */
 #    define LOG_DEBUGFLAG(D) (g_log->debug_mask & D)
 
-     /* bitmask dependant macros, to generate debug file such as matlab file or message dump */
+/* bitmask dependant macros, to generate debug file such as matlab file or message dump */
 #    define LOG_DUMPFLAG(D) (g_log->dump_mask & D)
 #    define LOG_M(file, vector, data, len, dec, format) do { write_file_matlab(file, vector, data, len, dec, format);} while(0)/* */
-     /* define variable only used in LOG macro's */
+/* define variable only used in LOG macro's */
 #    define LOG_VAR(A,B) A B
 #  else /* T_TRACER: remove all debugging and tracing messages, except errors */
 #    define LOG_I(c, x...) do {logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_INFO, x) ; } while(0)/* */
@@ -385,15 +386,15 @@ int32_t write_file_matlab(const char *fname, const char *vname, void *data, int
 #    define LOG_T(c, x...) /* */
 
 #    define LOG_DUMPMSG(c, b, s, x...) /* */
-#    define nfapi_log(FILE, FNC, LN, COMP, LVL, FMT...) 
+#    define nfapi_log(FILE, FNC, LN, COMP, LVL, FMT...)
 #    define LOG_DEBUGFLAG(D)  ( 0 )
-#    define LOG_DUMPFLAG(D) ( 0 ) 
+#    define LOG_DUMPFLAG(D) ( 0 )
 #    define LOG_M(file, vector, data, len, dec, format) do { write_file_matlab(file, vector, data, len, dec, format);} while(0)
 #    define LOG_VAR(A,B)
 #  endif /* T_TRACER */
 /* avoid warnings for variables only used in LOG macro's but set outside debug section */
-#define	GCC_NOTUSED		__attribute__((unused))
-#define LOG_USEDINLOG_VAR(A,B) GCC_NOTUSED A B 
+#define GCC_NOTUSED   __attribute__((unused))
+#define LOG_USEDINLOG_VAR(A,B) GCC_NOTUSED A B
 
 /* unfiltered macros, usefull for simulators or messages at init time, before log is configured */
 #define LOG_UM(file, vector, data, len, dec, format) do { write_file_matlab(file, vector, data, len, dec, format);} while(0)
@@ -425,78 +426,82 @@ static __inline__ uint64_t rdtsc(void) {
 
 extern double cpuf;
 
-static inline uint64_t checkTCPU(int timeout, char * file, int line) {
-    static __thread uint64_t  lastCPUTime=0;
-    static __thread uint64_t  last=0;
-    uint64_t cur=rdtsc();
-    struct timespec CPUt;
-    clock_gettime(CLOCK_THREAD_CPUTIME_ID, &CPUt);
-    uint64_t CPUTime=CPUt.tv_sec*1000*1000+CPUt.tv_nsec/1000;
-    double microCycles=(double)(cpuf*1000);
-    int duration=(int)((cur-last)/microCycles);
-    if ( last!=0 && duration > timeout ) {
-      //struct timespec ts;
-      //clock_gettime(CLOCK_MONOTONIC, &ts);
-      printf("%s:%d lte-ue delay %d (exceed %d), CPU for this period: %lld\n", file, line,
-               duration, timeout, (long long)CPUTime-lastCPUTime );
-    }
-    last=cur;
-    lastCPUTime=CPUTime;
-    return cur;
+static inline uint64_t checkTCPU(int timeout, char *file, int line) {
+  static __thread uint64_t  lastCPUTime=0;
+  static __thread uint64_t  last=0;
+  uint64_t cur=rdtsc();
+  struct timespec CPUt;
+  clock_gettime(CLOCK_THREAD_CPUTIME_ID, &CPUt);
+  uint64_t CPUTime=CPUt.tv_sec*1000*1000+CPUt.tv_nsec/1000;
+  double microCycles=(double)(cpuf*1000);
+  int duration=(int)((cur-last)/microCycles);
+
+  if ( last!=0 && duration > timeout ) {
+    //struct timespec ts;
+    //clock_gettime(CLOCK_MONOTONIC, &ts);
+    printf("%s:%d lte-ue delay %d (exceed %d), CPU for this period: %lld\n", file, line,
+           duration, timeout, (long long)CPUTime-lastCPUTime );
+  }
+
+  last=cur;
+  lastCPUTime=CPUTime;
+  return cur;
 }
 
-static inline unsigned long long checkT(int timeout, char * file, int line) {
-    static __thread unsigned long long last=0;
-    unsigned long long cur=rdtsc();
-    int microCycles=(int)(cpuf*1000);
-    int duration=(int)((cur-last)/microCycles);
-    if ( last!=0 && duration > timeout )
-        printf("%s:%d lte-ue delay %d (exceed %d)\n", file, line,
-               duration, timeout);
-    last=cur;
-    return cur;
+static inline unsigned long long checkT(int timeout, char *file, int line) {
+  static __thread unsigned long long last=0;
+  unsigned long long cur=rdtsc();
+  int microCycles=(int)(cpuf*1000);
+  int duration=(int)((cur-last)/microCycles);
+
+  if ( last!=0 && duration > timeout )
+    printf("%s:%d lte-ue delay %d (exceed %d)\n", file, line,
+           duration, timeout);
+
+  last=cur;
+  return cur;
 }
 
 typedef struct m {
-    uint64_t iterations;
-    uint64_t sum;
-    uint64_t maxArray[11];
+  uint64_t iterations;
+  uint64_t sum;
+  uint64_t maxArray[11];
 } Meas;
 
-static inline void printMeas(char * txt, Meas *M, int period) {
-    if (M->iterations%period == 0 ) {
-        char txt2[512];
-        sprintf(txt2,"%s avg=%" PRIu64 " iterations=%" PRIu64 " max=%" 
-                PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 "\n",
-                txt,
-                M->sum/M->iterations,
-                M->iterations,
-                M->maxArray[1],M->maxArray[2], M->maxArray[3],M->maxArray[4], M->maxArray[5], 
-                M->maxArray[6],M->maxArray[7], M->maxArray[8],M->maxArray[9],M->maxArray[10]);
+static inline void printMeas(char *txt, Meas *M, int period) {
+  if (M->iterations%period == 0 ) {
+    char txt2[512];
+    sprintf(txt2,"%s avg=%" PRIu64 " iterations=%" PRIu64 " max=%"
+            PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 "\n",
+            txt,
+            M->sum/M->iterations,
+            M->iterations,
+            M->maxArray[1],M->maxArray[2], M->maxArray[3],M->maxArray[4], M->maxArray[5],
+            M->maxArray[6],M->maxArray[7], M->maxArray[8],M->maxArray[9],M->maxArray[10]);
 #if DISABLE_LOG_X
-        printf("%s",txt2);
+    printf("%s",txt2);
 #else
-        LOG_W(PHY, "%s",txt2);
+    LOG_W(PHY, "%s",txt2);
 #endif
-    }
+  }
 }
 
-static inline int cmpint(const void* a, const void* b) {
-    uint64_t* aa=(uint64_t*)a;
-    uint64_t* bb=(uint64_t*)b;
-    return (int)(*aa-*bb);
+static inline int cmpint(const void *a, const void *b) {
+  uint64_t *aa=(uint64_t *)a;
+  uint64_t *bb=(uint64_t *)b;
+  return (int)(*aa-*bb);
 }
 
-static inline void updateTimes(uint64_t start, Meas *M, int period, char * txt) {
-    if (start!=0) {
-        uint64_t end=rdtsc();
-        long long diff=(end-start)/(cpuf*1000);
-        M->maxArray[0]=diff;
-        M->sum+=diff;
-        M->iterations++;
-        qsort(M->maxArray, 11, sizeof(uint64_t), cmpint);
-        printMeas(txt,M,period);
-    }
+static inline void updateTimes(uint64_t start, Meas *M, int period, char *txt) {
+  if (start!=0) {
+    uint64_t end=rdtsc();
+    long long diff=(end-start)/(cpuf*1000);
+    M->maxArray[0]=diff;
+    M->sum+=diff;
+    M->iterations++;
+    qsort(M->maxArray, 11, sizeof(uint64_t), cmpint);
+    printMeas(txt,M,period);
+  }
 }
 
 #define check(a) do { checkT(a,__FILE__,__LINE__); } while (0)
diff --git a/common/utils/minimal_stub.c b/common/utils/minimal_stub.c
new file mode 100644
index 0000000000..86454fe53f
--- /dev/null
+++ b/common/utils/minimal_stub.c
@@ -0,0 +1,4 @@
+int T_stdout;
+
+void exit_function(const char *file, const char *function, const int line, const char *s) {
+}
diff --git a/common/utils/ocp_itti/intertask_interface.cpp b/common/utils/ocp_itti/intertask_interface.cpp
index 5b8d1a430e..3a1fff6e93 100644
--- a/common/utils/ocp_itti/intertask_interface.cpp
+++ b/common/utils/ocp_itti/intertask_interface.cpp
@@ -8,6 +8,7 @@
 
 
 #include <intertask_interface.h>
+#include <common/utils/system.h>
 
 typedef struct timer_elm_s {
   timer_type_t      type;     ///< Timer type
@@ -280,22 +281,8 @@ extern "C" {
 
   int itti_create_task(task_id_t task_id, void *(*start_routine)(void *), void *args_p) {
     task_list_t *t=&tasks[task_id];
-    AssertFatal ( pthread_create (&t->thread, NULL, start_routine, args_p) ==0,
-                  "Thread creation for task %d failed!\n", task_id);
-    pthread_setname_np( t->thread, itti_get_task_name(task_id) );
+    threadCreate (&t->thread, start_routine, args_p, (char*)itti_get_task_name(task_id),-1,OAI_PRIORITY_RT);
     LOG_I(TMR,"Created Posix thread %s\n",  itti_get_task_name(task_id) );
-#if 1 // BMC test RT prio
-    {
-      int policy;
-      struct sched_param sparam;
-      memset(&sparam, 0, sizeof(sparam));
-      sparam.sched_priority = sched_get_priority_max(SCHED_FIFO)-10;
-      policy = SCHED_FIFO ; 
-      if (pthread_setschedparam(t->thread, policy, &sparam) != 0) {
-	LOG_E(TMR,"task %s : Failed to set pthread priority\n",  itti_get_task_name(task_id) );
-      }
-    }
-#endif    
     return 0;
   }
 
diff --git a/common/utils/simple_executable.h b/common/utils/simple_executable.h
new file mode 100644
index 0000000000..98b75012df
--- /dev/null
+++ b/common/utils/simple_executable.h
@@ -0,0 +1,37 @@
+#ifndef __SIMPLE_EXE_H__
+#define __SIMPLE_EXE_H__
+#ifndef __USE_GNU
+#define __USE_GNU
+#endif
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+#include <stdio.h>
+#include <pthread.h>
+#include <sched.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/syscall.h>
+#include <sys/time.h>
+#include <stdint.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <stdbool.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <arpa/inet.h>
+#include <common/utils/assertions.h>
+#include <common/utils/LOG/log.h>
+#include "common_lib.h"
+
+#ifdef T
+  #undef T
+  #define T(...)
+#endif
+
+#endif
diff --git a/common/utils/system.c b/common/utils/system.c
index dcec681e2d..31c1035129 100644
--- a/common/utils/system.c
+++ b/common/utils/system.c
@@ -28,13 +28,23 @@
  * separate process solves this problem.
  */
 
+#define _GNU_SOURCE
 #include "system.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <pthread.h>
 #include <string.h>
-
+#include <stdint.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <string.h>
+#include <errno.h>
+#include <pthread.h>
+#include <common/utils/assertions.h>
+#include <common/utils/LOG/log.h>
 #define MAX_COMMAND 4096
 
 static int command_pipe_read;
@@ -50,37 +60,37 @@ static int module_initialized = 0;
 /* util functions                                                   */
 /********************************************************************/
 
-static void lock_system(void)
-{
+static void lock_system(void) {
   if (pthread_mutex_lock(&lock) != 0) {
     printf("pthread_mutex_lock fails\n");
     abort();
   }
 }
 
-static void unlock_system(void)
-{
+static void unlock_system(void) {
   if (pthread_mutex_unlock(&lock) != 0) {
     printf("pthread_mutex_unlock fails\n");
     abort();
   }
 }
 
-static void write_pipe(int p, char *b, int size)
-{
+static void write_pipe(int p, char *b, int size) {
   while (size) {
     int ret = write(p, b, size);
+
     if (ret <= 0) exit(0);
+
     b += ret;
     size -= ret;
   }
 }
 
-static void read_pipe(int p, char *b, int size)
-{
+static void read_pipe(int p, char *b, int size) {
   while (size) {
     int ret = read(p, b, size);
+
     if (ret <= 0) exit(0);
+
     b += ret;
     size -= ret;
   }
@@ -95,14 +105,13 @@ static void read_pipe(int p, char *b, int size)
  * when the main process exits, because then a "read" on the pipe
  * will return 0, in which case "read_pipe" exits.
  */
-static void background_system_process(void)
-{
+static void background_system_process(void) {
   int len;
   int ret;
   char command[MAX_COMMAND+1];
 
   while (1) {
-    read_pipe(command_pipe_read, (char*)&len, sizeof(int));
+    read_pipe(command_pipe_read, (char *)&len, sizeof(int));
     read_pipe(command_pipe_read, command, len);
     ret = system(command);
     write_pipe(result_pipe_write, (char *)&ret, sizeof(int));
@@ -114,8 +123,7 @@ static void background_system_process(void)
 /*     return -1 on error, 0 on success                             */
 /********************************************************************/
 
-int background_system(char *command)
-{
+int background_system(char *command) {
   int res;
   int len;
 
@@ -125,18 +133,22 @@ int background_system(char *command)
   }
 
   len = strlen(command)+1;
+
   if (len > MAX_COMMAND) {
     printf("FATAL: command too long. Increase MAX_COMMAND (%d).\n", MAX_COMMAND);
     printf("command was: '%s'\n", command);
     abort();
   }
+
   /* only one command can run at a time, so let's lock/unlock */
   lock_system();
-  write_pipe(command_pipe_write, (char*)&len, sizeof(int));
+  write_pipe(command_pipe_write, (char *)&len, sizeof(int));
   write_pipe(command_pipe_write, command, len);
-  read_pipe(result_pipe_read, (char*)&res, sizeof(int));
+  read_pipe(result_pipe_read, (char *)&res, sizeof(int));
   unlock_system();
+
   if (res == -1 || !WIFEXITED(res) || WEXITSTATUS(res) != 0) return -1;
+
   return 0;
 }
 
@@ -146,17 +158,16 @@ int background_system(char *command)
 /*     to be called very early by the main processing               */
 /********************************************************************/
 
-void start_background_system(void)
-{
+void start_background_system(void) {
   int p[2];
   pid_t son;
-
   module_initialized = 1;
 
   if (pipe(p) == -1) {
     perror("pipe");
     exit(1);
   }
+
   command_pipe_read  = p[0];
   command_pipe_write = p[1];
 
@@ -164,10 +175,11 @@ void start_background_system(void)
     perror("pipe");
     exit(1);
   }
+
   result_pipe_read  = p[0];
   result_pipe_write = p[1];
-
   son = fork();
+
   if (son == -1) {
     perror("fork");
     exit(1);
@@ -181,6 +193,56 @@ void start_background_system(void)
 
   close(result_pipe_read);
   close(command_pipe_write);
-
   background_system_process();
 }
+
+
+void threadCreate(pthread_t* t, void * (*func)(void*), void * param, char* name, int affinity, int priority){
+  pthread_attr_t attr;
+  pthread_attr_init(&attr);
+  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+  pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
+  pthread_attr_setschedpolicy(&attr, SCHED_FIFO);
+  struct sched_param sparam={0};
+  sparam.sched_priority = priority;
+  pthread_attr_setschedparam(&attr, &sparam);
+
+  pthread_create(t, &attr, func, param);
+
+  pthread_setname_np(*t, name);
+  if (affinity != -1 ) {
+    cpu_set_t cpuset;
+    CPU_ZERO(&cpuset);
+    CPU_SET(affinity, &cpuset);
+    AssertFatal( pthread_setaffinity_np(*t, sizeof(cpu_set_t), &cpuset) == 0, "Error setting processor affinity");
+  }
+
+  pthread_attr_destroy(&attr);
+}
+
+// Block CPU C-states deep sleep
+void configure_linux(void) {
+  int ret;
+  static int latency_target_fd=-1;
+  uint32_t latency_target_value=10; // in microseconds
+  if (latency_target_fd == -1) {
+    if ( (latency_target_fd = open("/dev/cpu_dma_latency", O_RDWR)) != -1 ) {
+      ret = write(latency_target_fd, &latency_target_value, sizeof(latency_target_value));
+      if (ret == 0) {
+	printf("# error setting cpu_dma_latency to %d!: %s\n", latency_target_value, strerror(errno));
+	close(latency_target_fd);
+	latency_target_fd=-1;
+	return;
+      }
+    }
+  }
+  if (latency_target_fd != -1) 
+    LOG_I(HW,"# /dev/cpu_dma_latency set to %dus\n", latency_target_value);
+  else
+    LOG_E(HW,"Can't set /dev/cpu_dma_latency to %dus\n", latency_target_value);
+
+  // Set CPU frequency to it's maximum
+  if ( 0 != system("for d in /sys/devices/system/cpu/cpu[0-9]*; do cat $d/cpufreq/cpuinfo_max_freq > $d/cpufreq/scaling_min_freq; done"))
+	  LOG_W(HW,"Can't set cpu frequency\n");
+  
+}
diff --git a/common/utils/system.h b/common/utils/system.h
index 658c17adc1..a89a6c5b17 100644
--- a/common/utils/system.h
+++ b/common/utils/system.h
@@ -21,6 +21,12 @@
 
 #ifndef _SYSTEM_H_OAI_
 #define _SYSTEM_H_OAI_
+#include <stdint.h>
+#include <pthread.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 
 /****************************************************
  * send a command to the background process
@@ -36,4 +42,23 @@ int background_system(char *command);
 
 void start_background_system(void);
 
+void set_latency_target(void);
+void configure_linux(void);
+
+void threadCreate(pthread_t* t, void * (*func)(void*), void * param, char* name, int affinity, int priority);
+#define OAI_PRIORITY_RT_LOW sched_get_priority_min(SCHED_FIFO)
+#define OAI_PRIORITY_RT sched_get_priority_max(SCHED_FIFO)-10
+#define OAI_PRIORITY_RT_MAX sched_get_priority_max(SCHED_FIFO)
+
+void thread_top_init(char *thread_name,
+                     int affinity,
+                     uint64_t runtime,
+                     uint64_t deadline,
+                     uint64_t period);
+
+#ifdef __cplusplus
+}
+#endif
+
+
 #endif /* _SYSTEM_H_OAI_ */
diff --git a/common/utils/threadPool/Makefile b/common/utils/threadPool/Makefile
new file mode 100644
index 0000000000..af0b44996c
--- /dev/null
+++ b/common/utils/threadPool/Makefile
@@ -0,0 +1,8 @@
+all: measurement_display thread-pool-test
+
+measurement_display: measurement_display.c thread-pool.h
+	gcc measurement_display.c -I ${OPENAIR_DIR}/ -I ${OPENAIR_DIR}/common/utils/  -I. ${OPENAIR_DIR}/common/utils/backtrace.c -lpthread -D TEST_THREAD_POOL -I../LOG -I../../utils/T -o measurement_display
+
+thread-pool-test: thread-pool.c thread-pool.h
+	gcc -g thread-pool.c -I ${OPENAIR_DIR}/ -I ${OPENAIR_DIR}/common/utils/  -I. ${OPENAIR_DIR}/common/utils/backtrace.c -I ${OPENAIR_DIR}/openair2/COMMON ${OPENAIR_DIR}/common/utils/LOG/log.c ${OPENAIR_DIR}/common/config/config_userapi.c ${OPENAIR_DIR}/common/config/config_load_configmodule.c ${OPENAIR_DIR}/common/config/config_cmdline.c -lpthread -ldl -D TEST_THREAD_POOL -I../LOG -I../../utils/T -o thread-pool-test
+
diff --git a/common/utils/threadPool/measurement_display.c b/common/utils/threadPool/measurement_display.c
new file mode 100644
index 0000000000..8f6e2c239a
--- /dev/null
+++ b/common/utils/threadPool/measurement_display.c
@@ -0,0 +1,47 @@
+/*
+  Author: Laurent THOMAS, Open Cells
+  copyleft: OpenAirInterface Software Alliance and it's licence
+*/
+#include <common/utils/simple_executable.h>
+
+#include "thread-pool.h"
+
+#define SEP "\t"
+
+uint64_t cpuCyclesMicroSec;
+
+int main(int argc, char *argv[]) {
+  if(argc != 2) {
+    printf("Need one parameter: the trace Linux pipe (fifo)");
+    exit(1);
+  }
+
+  mkfifo(argv[1],0666);
+  int fd=open(argv[1], O_RDONLY);
+
+  if ( fd == -1 ) {
+    perror("open read mode trace file:");
+    exit(1);
+  }
+
+  uint64_t deb=rdtsc();
+  usleep(100000);
+  cpuCyclesMicroSec=(rdtsc()-deb)/100000;
+  printf("Cycles per µs: %lu\n",cpuCyclesMicroSec);
+  printf("Key" SEP "delay to process" SEP "processing time" SEP "delay to be read answer\n");
+  notifiedFIFO_elt_t doneRequest;
+
+  while ( 1 ) {
+    if ( read(fd,&doneRequest, sizeof(doneRequest)) ==  sizeof(doneRequest)) {
+      printf("%lu" SEP "%lu" SEP "%lu" SEP "%lu" "\n",
+             doneRequest.key,
+             (doneRequest.startProcessingTime-doneRequest.creationTime)/cpuCyclesMicroSec,
+             (doneRequest.endProcessingTime-doneRequest.startProcessingTime)/cpuCyclesMicroSec,
+             (doneRequest.returnTime-doneRequest.endProcessingTime)/cpuCyclesMicroSec
+            );
+    } else {
+      printf("no measurements\n");
+      sleep(1);
+    }
+  }
+}
diff --git a/common/utils/threadPool/thread-pool.c b/common/utils/threadPool/thread-pool.c
new file mode 100644
index 0000000000..b45a8fa722
--- /dev/null
+++ b/common/utils/threadPool/thread-pool.c
@@ -0,0 +1,216 @@
+/*
+  Author: Laurent THOMAS, Open Cells
+  copyleft: OpenAirInterface Software Alliance and it's licence
+*/
+
+#define _GNU_SOURCE
+#include <sched.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <string.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <sys/sysinfo.h>
+#include <threadPool/thread-pool.h>
+
+void displayList(notifiedFIFO_t *nf) {
+  int n=0;
+  notifiedFIFO_elt_t *ptr=nf->outF;
+
+  while(ptr) {
+    printf("element: %d, key: %lu\n",++n,ptr->key);
+    ptr=ptr->next;
+  }
+
+  printf("End of list: %d elements\n",n);
+}
+
+static inline  notifiedFIFO_elt_t *pullNotifiedFifoRemember( notifiedFIFO_t *nf, struct one_thread *thr) {
+  mutexlock(nf->lockF);
+
+  while(!nf->outF)
+    condwait(nf->notifF, nf->lockF);
+
+  notifiedFIFO_elt_t *ret=nf->outF;
+  nf->outF=nf->outF->next;
+
+  if (nf->outF==NULL)
+    nf->inF=NULL;
+
+  // For abort feature
+  thr->runningOnKey=ret->key;
+  thr->abortFlag=false;
+  mutexunlock(nf->lockF);
+  return ret;
+}
+
+void *one_thread(void *arg) {
+  struct  one_thread *myThread=(struct  one_thread *) arg;
+  struct  thread_pool *tp=myThread->pool;
+
+  // Infinite loop to process requests
+  do {
+    notifiedFIFO_elt_t *elt=pullNotifiedFifoRemember(&tp->incomingFifo, myThread);
+
+    if (tp->measurePerf) elt->startProcessingTime=rdtsc();
+
+    elt->processingFunc(NotifiedFifoData(elt));
+
+    if (tp->measurePerf) elt->endProcessingTime=rdtsc();
+
+    if (elt->reponseFifo) {
+      // Check if the job is still alive, else it has been aborted
+      mutexlock(tp->incomingFifo.lockF);
+
+      if (myThread->abortFlag)
+        delNotifiedFIFO_elt(elt);
+      else
+        pushNotifiedFIFO(elt->reponseFifo, elt);
+
+      mutexunlock(tp->incomingFifo.lockF);
+    }
+  } while (true);
+}
+
+void initTpool(char *params,tpool_t *pool, bool performanceMeas) {
+  memset(pool,0,sizeof(*pool));
+  char *measr=getenv("threadPoolMeasurements");
+  pool->measurePerf=performanceMeas;
+  // force measurement if the output is defined
+  pool->measurePerf=measr!=NULL;
+
+  if (measr) {
+    mkfifo(measr,0666);
+    AssertFatal(-1 != (pool->dummyTraceFd=
+                         open(measr, O_RDONLY| O_NONBLOCK)),"");
+    AssertFatal(-1 != (pool->traceFd=
+                         open(measr, O_WRONLY|O_APPEND|O_NOATIME|O_NONBLOCK)),"");
+  } else
+    pool->traceFd=-1;
+
+  pool->activated=true;
+  initNotifiedFIFO(&pool->incomingFifo);
+  char *saveptr, * curptr;
+  pool->nbThreads=0;
+  pool->restrictRNTI=false;
+  curptr=strtok_r(params,",",&saveptr);
+
+  while ( curptr!=NULL ) {
+    int c=toupper(curptr[0]);
+
+    switch (c) {
+      case 'U':
+        pool->restrictRNTI=true;
+        break;
+
+      case 'N':
+        pool->activated=false;
+        break;
+
+      default:
+        pool->allthreads=(struct one_thread *)malloc(sizeof(struct one_thread));
+        pool->allthreads->next=pool->allthreads;
+        printf("create a thread for core %d\n", atoi(curptr));
+        pool->allthreads->coreID=atoi(curptr);
+        pool->allthreads->id=pool->nbThreads;
+        pool->allthreads->pool=pool;
+        //Configure the thread scheduler policy for Linux
+        // set the thread name for debugging
+        sprintf(pool->allthreads->name,"Tpool_%d",pool->allthreads->coreID);
+        threadCreate(&pool->allthreads->threadID, one_thread, (void *)pool->allthreads,
+                     pool->allthreads->name, pool->allthreads->coreID, OAI_PRIORITY_RT);
+        pool->nbThreads++;
+    }
+
+    curptr=strtok_r(NULL,",",&saveptr);
+  }
+
+  if (pool->activated && pool->nbThreads==0) {
+    printf("No servers created in the thread pool, exit\n");
+    exit(1);
+  }
+}
+
+#ifdef TEST_THREAD_POOL
+
+void exit_function(const char *file, const char *function, const int line, const char *s) {
+}
+
+struct testData {
+  int id;
+  char txt[30];
+};
+
+void processing(void *arg) {
+  struct testData *in=(struct testData *)arg;
+  printf("doing: %d, %s, in thr %ld\n",in->id, in->txt,pthread_self() );
+  sprintf(in->txt,"Done by %ld, job %d", pthread_self(), in->id);
+  usleep(rand()%100);
+  printf("done: %d, %s, in thr %ld\n",in->id, in->txt,pthread_self() );
+}
+
+int main() {
+  notifiedFIFO_t myFifo;
+  initNotifiedFIFO(&myFifo);
+  pushNotifiedFIFO(&myFifo,newNotifiedFIFO_elt(sizeof(struct testData), 1234,NULL,NULL));
+
+  for(int i=10; i>1; i--) {
+    pushNotifiedFIFO(&myFifo,newNotifiedFIFO_elt(sizeof(struct testData), 1000+i,NULL,NULL));
+  }
+
+  displayList(&myFifo);
+  notifiedFIFO_elt_t *tmp=pullNotifiedFIFO(&myFifo);
+  printf("pulled: %lu\n", tmp->key);
+  displayList(&myFifo);
+  tmp=pullNotifiedFIFO(&myFifo);
+  printf("pulled: %lu\n", tmp->key);
+  displayList(&myFifo);
+  abortNotifiedFIFO(&myFifo,1005);
+  printf("aborted 1005\n");
+  displayList(&myFifo);
+  pushNotifiedFIFO(&myFifo,newNotifiedFIFO_elt(sizeof(struct testData), 12345678, NULL, NULL));
+  displayList(&myFifo);
+  abortNotifiedFIFO(&myFifo,12345678);
+  printf("aborted 12345678\n");
+  displayList(&myFifo);
+
+  do {
+    tmp=pollNotifiedFIFO(&myFifo);
+
+    if (tmp) {
+      printf("pulled: %lu\n", tmp->key);
+      displayList(&myFifo);
+    } else
+      printf("Empty list \n");
+  } while(tmp);
+
+  tpool_t  pool;
+  char params[]="1,2,3,u";
+  initTpool(params,&pool, true);
+  notifiedFIFO_t worker_back;
+  initNotifiedFIFO(&worker_back);
+
+  for (int i=0; i <1000 ; i++) {
+    notifiedFIFO_elt_t *work=newNotifiedFIFO_elt(sizeof(struct testData), i, &worker_back, processing);
+    struct testData *x=(struct testData *)NotifiedFifoData(work);
+    x->id=i;
+    pushTpool(&pool, work);
+  }
+
+  do {
+    tmp=pullTpool(&worker_back,&pool);
+
+    if (tmp) {
+      struct testData *dd=NotifiedFifoData(tmp);
+      printf("Result: %s\n",dd->txt);
+      delNotifiedFIFO_elt(tmp);
+    } else
+      printf("Empty list \n");
+
+    abortTpool(&pool,510);
+  } while(tmp);
+
+  return 0;
+}
+#endif
diff --git a/common/utils/threadPool/thread-pool.h b/common/utils/threadPool/thread-pool.h
new file mode 100644
index 0000000000..d6dc332c5a
--- /dev/null
+++ b/common/utils/threadPool/thread-pool.h
@@ -0,0 +1,257 @@
+/*
+  Author: Laurent THOMAS, Open Cells
+  copyleft: OpenAirInterface Software Alliance and it's licence
+*/
+
+#ifndef THREAD_POOL_H
+#define THREAD_POOL_H
+#include <stdbool.h>
+#include <stdint.h>
+#include <pthread.h>
+#include <sys/syscall.h>
+#include <assertions.h>
+#include <LOG/log.h>
+#include <common/utils/system.h>
+
+#ifdef DEBUG
+  #define THREADINIT   PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP
+#else
+  #define THREADINIT   PTHREAD_MUTEX_INITIALIZER
+#endif
+#define mutexinit(mutex)   AssertFatal(pthread_mutex_init(&mutex,NULL)==0,"");
+#define condinit(signal)   AssertFatal(pthread_cond_init(&signal,NULL)==0,"");
+#define mutexlock(mutex)   AssertFatal(pthread_mutex_lock(&mutex)==0,"");
+#define mutextrylock(mutex)   pthread_mutex_trylock(&mutex)
+#define mutexunlock(mutex) AssertFatal(pthread_mutex_unlock(&mutex)==0,"");
+#define condwait(condition, mutex) AssertFatal(pthread_cond_wait(&condition, &mutex)==0,"");
+#define condbroadcast(signal) AssertFatal(pthread_cond_broadcast(&signal)==0,"");
+#define condsignal(signal)    AssertFatal(pthread_cond_broadcast(&signal)==0,"");
+
+typedef struct notifiedFIFO_elt_s {
+  struct notifiedFIFO_elt_s *next;
+  uint64_t key; //To filter out elements
+  struct notifiedFIFO_s *reponseFifo;
+  void (*processingFunc)(void *);
+  bool malloced;
+  uint64_t creationTime;
+  uint64_t startProcessingTime;
+  uint64_t endProcessingTime;
+  uint64_t returnTime;
+  void *msgData;
+}  notifiedFIFO_elt_t;
+
+typedef struct notifiedFIFO_s {
+  notifiedFIFO_elt_t *outF;
+  notifiedFIFO_elt_t *inF;
+  pthread_mutex_t lockF;
+  pthread_cond_t  notifF;
+} notifiedFIFO_t;
+
+// You can use this allocator or use any piece of memory
+static inline notifiedFIFO_elt_t *newNotifiedFIFO_elt(int size,
+    uint64_t key,
+    notifiedFIFO_t *reponseFifo,
+    void (*processingFunc)(void *)) {
+  notifiedFIFO_elt_t *ret;
+  AssertFatal( NULL != (ret=(notifiedFIFO_elt_t *) malloc(sizeof(notifiedFIFO_elt_t)+size+32)), "");
+  ret->next=NULL;
+  ret->key=key;
+  ret->reponseFifo=reponseFifo;
+  ret->processingFunc=processingFunc;
+  // We set user data piece aligend 32 bytes to be able to process it with SIMD
+  ret->msgData=(void *)ret+(sizeof(notifiedFIFO_elt_t)/32+1)*32;
+  ret->malloced=true;
+  return ret;
+}
+
+static inline void *NotifiedFifoData(notifiedFIFO_elt_t *elt) {
+  return elt->msgData;
+}
+
+static inline void delNotifiedFIFO_elt(notifiedFIFO_elt_t *elt) {
+  if (elt->malloced) {
+    elt->malloced=false;
+    free(elt);
+  } else
+    printf("delNotifiedFIFO on something not allocated by newNotifiedFIFO\n");
+
+  //LOG_W(UTIL,"delNotifiedFIFO on something not allocated by newNotifiedFIFO\n");
+}
+
+static inline void initNotifiedFIFO_nothreadSafe(notifiedFIFO_t *nf) {
+  nf->inF=NULL;
+  nf->outF=NULL;
+}
+static inline void initNotifiedFIFO(notifiedFIFO_t *nf) {
+  mutexinit(nf->lockF);
+  condinit (nf->notifF);
+  initNotifiedFIFO_nothreadSafe(nf);
+  // No delete function: the creator has only to free the memory
+}
+
+static inline void pushNotifiedFIFO_nothreadSafe(notifiedFIFO_t *nf, notifiedFIFO_elt_t *msg) {
+  msg->next=NULL;
+
+  if (nf->outF == NULL)
+    nf->outF = msg;
+
+  if (nf->inF != NULL)
+    nf->inF->next = msg;
+
+  nf->inF = msg;
+}
+
+static inline void pushNotifiedFIFO(notifiedFIFO_t *nf, notifiedFIFO_elt_t *msg) {
+  mutexlock(nf->lockF);
+  pushNotifiedFIFO_nothreadSafe(nf,msg);
+  condbroadcast(nf->notifF);
+  mutexunlock(nf->lockF);
+}
+
+static inline  notifiedFIFO_elt_t *pullNotifiedFIFO_nothreadSafe(notifiedFIFO_t *nf) {
+  if (nf->outF == NULL)
+    return NULL;
+
+  notifiedFIFO_elt_t *ret=nf->outF;
+
+  if (nf->outF==nf->outF->next)
+    LOG_E(TMR,"Circular list in thread pool: push several times the same buffer is forbidden\n");
+
+  nf->outF=nf->outF->next;
+
+  if (nf->outF==NULL)
+    nf->inF=NULL;
+
+  return ret;
+}
+
+static inline  notifiedFIFO_elt_t *pullNotifiedFIFO(notifiedFIFO_t *nf) {
+  mutexlock(nf->lockF);
+  notifiedFIFO_elt_t *ret;
+
+  while((ret=pullNotifiedFIFO_nothreadSafe(nf)) == NULL)
+    condwait(nf->notifF, nf->lockF);
+
+  mutexunlock(nf->lockF);
+  return ret;
+}
+
+static inline  notifiedFIFO_elt_t *pollNotifiedFIFO(notifiedFIFO_t *nf) {
+  int tmp=mutextrylock(nf->lockF);
+
+  if (tmp != 0 )
+    return NULL;
+
+  notifiedFIFO_elt_t *ret=pullNotifiedFIFO_nothreadSafe(nf);
+  mutexunlock(nf->lockF);
+  return ret;
+}
+
+// This function aborts all messages matching the key
+// If the queue is used in thread pools, it doesn't cancels already running processing
+// because the message has already been picked
+static inline void abortNotifiedFIFO(notifiedFIFO_t *nf, uint64_t key) {
+  mutexlock(nf->lockF);
+  notifiedFIFO_elt_t **start=&nf->outF;
+
+  while(*start!=NULL) {
+    if ( (*start)->key == key ) {
+      notifiedFIFO_elt_t *request=*start;
+      *start=(*start)->next;
+      delNotifiedFIFO_elt(request);
+    }
+
+    if (*start != NULL)
+      start=&(*start)->next;
+  }
+
+  mutexunlock(nf->lockF);
+}
+
+struct one_thread {
+  pthread_t  threadID;
+  int id;
+  int coreID;
+  char name[256];
+  uint64_t runningOnKey;
+  bool abortFlag;
+  struct thread_pool *pool;
+  struct one_thread *next;
+};
+
+typedef struct thread_pool {
+  int activated;
+  bool measurePerf;
+  int traceFd;
+  int dummyTraceFd;
+  uint64_t cpuCyclesMicroSec;
+  uint64_t startProcessingUE;
+  int nbThreads;
+  bool restrictRNTI;
+  notifiedFIFO_t incomingFifo;
+  struct one_thread *allthreads;
+} tpool_t;
+
+static inline void pushTpool(tpool_t *t, notifiedFIFO_elt_t *msg) {
+  if (t->measurePerf) msg->creationTime=rdtsc();
+
+  pushNotifiedFIFO(&t->incomingFifo, msg);
+}
+
+static inline notifiedFIFO_elt_t *pullTpool(notifiedFIFO_t *responseFifo, tpool_t *t) {
+  notifiedFIFO_elt_t *msg= pullNotifiedFIFO(responseFifo);
+
+  if (t->measurePerf)
+    msg->returnTime=rdtsc();
+
+  if (t->traceFd >= 0)
+    if(write(t->traceFd, msg, sizeof(*msg)));
+
+  return msg;
+}
+
+static inline notifiedFIFO_elt_t *tryPullTpool(notifiedFIFO_t *responseFifo, tpool_t *t) {
+  notifiedFIFO_elt_t *msg= pollNotifiedFIFO(responseFifo);
+
+  if (msg == NULL)
+    return NULL;
+
+  if (t->measurePerf)
+    msg->returnTime=rdtsc();
+
+  if (t->traceFd)
+    if(write(t->traceFd, msg, sizeof(*msg)));
+
+  return msg;
+}
+
+static inline void abortTpool(tpool_t *t, uint64_t key) {
+  notifiedFIFO_t *nf=&t->incomingFifo;
+  mutexlock(nf->lockF);
+  notifiedFIFO_elt_t **start=&nf->outF;
+
+  while(*start!=NULL) {
+    if ( (*start)->key == key ) {
+      notifiedFIFO_elt_t *request=*start;
+      *start=(*start)->next;
+      delNotifiedFIFO_elt(request);
+    }
+
+    if (*start != NULL)
+      start=&(*start)->next;
+  }
+
+  struct one_thread *ptr=t->allthreads;
+
+  while(ptr!=NULL) {
+    if (ptr->runningOnKey==key)
+      ptr->abortFlag=true;
+
+    ptr=ptr->next;
+  }
+
+  mutexunlock(nf->lockF);
+}
+void initTpool(char *params,tpool_t *pool, bool performanceMeas);
+
+#endif
diff --git a/common/utils/threadPool/thread-pool.md b/common/utils/threadPool/thread-pool.md
new file mode 100644
index 0000000000..2b6336fb60
--- /dev/null
+++ b/common/utils/threadPool/thread-pool.md
@@ -0,0 +1,71 @@
+# Thread pool
+
+The thread pool is a working server, made of a set of worker threads that can be mapped on CPU cores.
+
+Each worker loop on pick from the same input queue jobs to do.
+When a job is done, the worker sends a return if a return is defined.
+
+A selective abort allows to cancel parallel jobs (usage: a client pushed jobs, but from a response of one job, the other linked jobs becomes useless).
+
+All the thread pool functions are thread safe, nevertheless the working functions are implemented by the thread pool client, so the client has to tackle the parallel execution of his functions called "processingFunc" hereafter.
+
+## license
+Author: Laurent Thomas, Open cells project 
+The owner share this piece code to Openairsoftware alliance as per OSA license terms
+
+# jobs
+
+A job is a message (notifiedFIFO_elt_t):
+next: internal FIFO chain, do not set it
+key:  a long int that the client can use to identify a message or a group of messages
+responseFifo: if the client defines a response FIFO, the message will be posted back after processing
+processingFunc: any funtion (type void processingFunc(void *)) that the worker will launch
+msgData: the data passed to processingFunc. It can be added automatically, or you can set it to a buffer you are managing
+malloced: a boolean that enable internal free in these cases: no return Fifo or Abort feature
+
+The job messages can be created with newNotifiedFIFO_elt() and delNotifiedFIFO_elt() or managed by the client.
+
+# Queues of jobs
+
+Queues are type of: notifiedFIFO_t that must be initialized by init_notifiedFIFO()
+No delete function is required, the creator has only to free the data of type notifiedFIFO_t
+
+push_notifiedFIFO() add a job in the queue
+pull_notifiedFIFO() is blocking, poll_notifiedFIFO() is non blocking
+
+abort_notifiedFIFO() allows the customer to delete all waiting jobs that match with the key (see key in jobs definition)
+
+# Thread pools
+
+## initialization
+The clients can create one or more thread pools with init_tpool()
+the params string structure: describes a list of cores, separated by "," that run a worker thread
+
+If the core exists on the CPU, the thread pool initialization sets the affinity between this thread and the related code (use negative values is allowed, so the thread will never be mapped on a specific core).
+
+The threads are all Linux real time scheduler, their name is set automatically is "Tpool_<core id>"
+
+## adding jobs
+The client create their jobs messages as a notifiedFIFO_elt_t, then they push it with pushTpool() (that internally calls push_notifiedFIFO())
+
+If they need a return, they have to create response queues with init_notifiedFIFO() and set this FIFO pointer in the notifiedFIFO_elt_t before pushing the job.
+
+## abort
+
+A abort service abortTpool() allows to abort all jobs that match a key (see jobs "key"). When the abort returns, it garanties no job (matching the key) response will be posted on response queues.
+
+Nevertheless, jobs already performed before the return of abortTpool() are pushed in the response Fifo queue.
+
+## Performance measurements
+
+A performance measurement is integrated: the pool will automacillay fill timestamps:
+
+* creationTime: time the request is push to the pool;
+* startProcessingTime: time a worker start to run on the job
+* endProcessingTime: time the worker finished the job
+* returnTime: time the client reads the result
+
+if you set the environement variable: thread-pool-measurements to a valid file name
+These measurements will be wrote to this Linux pipe.
+
+A tool to read the linux fifo and display it in ascii is provided: see the local directory Makefile for this tool and to compile the thread pool unitary tests.
diff --git a/common/utils/utils.h b/common/utils/utils.h
index cfe3df34b9..11db07056e 100644
--- a/common/utils/utils.h
+++ b/common/utils/utils.h
@@ -3,6 +3,9 @@
 
 #include <stdint.h>
 #include <sys/types.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 void *calloc_or_fail(size_t size);
 void *malloc_or_fail(size_t size);
@@ -14,4 +17,17 @@ int hex_string_to_hex_value (uint8_t *hex_value, const char *hex_string, int siz
 
 char *itoa(int i);
 
+#define findInList(keY, result, list, element_type) {\
+    int i;\
+    for (i=0; i<sizeof(list)/sizeof(element_type) ; i++)\
+      if (list[i].key==keY) {\
+        result=list[i].val;\
+        break;\
+      }\
+    AssertFatal(i < sizeof(list)/sizeof(element_type), "List %s doesn't contain %s\n",#list, #keY); \
+  }
+#ifdef __cplusplus
+}
+#endif
+
 #endif
diff --git a/executables/nr-gnb.c b/executables/nr-gnb.c
new file mode 100644
index 0000000000..c0571f2bc5
--- /dev/null
+++ b/executables/nr-gnb.c
@@ -0,0 +1,941 @@
+/*
+ * 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
+ */
+
+/*! \file lte-enb.c
+ * \brief Top-level threads for gNodeB
+ * \author R. Knopp, F. Kaltenberger, Navid Nikaein
+ * \date 2012
+ * \version 0.1
+ * \company Eurecom
+ * \email: knopp@eurecom.fr,florian.kaltenberger@eurecom.fr, navid.nikaein@eurecom.fr
+ * \note
+ * \warning
+ */
+
+#define _GNU_SOURCE
+#include <pthread.h>
+
+#include "time_utils.h"
+
+#undef MALLOC //there are two conflicting definitions, so we better make sure we don't use it at all
+
+#include "assertions.h"
+#include <common/utils/LOG/log.h>
+#include <common/utils/system.h>
+
+#include "PHY/types.h"
+
+#include "PHY/INIT/phy_init.h"
+
+#include "PHY/defs_gNB.h"
+#include "SCHED/sched_eNB.h"
+#include "SCHED_NR/sched_nr.h"
+#include "SCHED_NR/fapi_nr_l1.h"
+#include "PHY/LTE_TRANSPORT/transport_proto.h"
+
+#undef MALLOC //there are two conflicting definitions, so we better make sure we don't use it at all
+//#undef FRAME_LENGTH_COMPLEX_SAMPLES //there are two conflicting definitions, so we better make sure we don't use it at all
+
+#include "../../ARCH/COMMON/common_lib.h"
+
+//#undef FRAME_LENGTH_COMPLEX_SAMPLES //there are two conflicting definitions, so we better make sure we don't use it at all
+
+#include "PHY/LTE_TRANSPORT/if4_tools.h"
+#include "PHY/LTE_TRANSPORT/if5_tools.h"
+
+#include "PHY/phy_extern.h"
+
+
+#include "LAYER2/MAC/mac.h"
+#include "LAYER2/MAC/mac_extern.h"
+#include "LAYER2/MAC/mac_proto.h"
+#include "RRC/LTE/rrc_extern.h"
+#include "PHY_INTERFACE/phy_interface.h"
+#include "common/utils/LOG/log_extern.h"
+#include "UTIL/OTG/otg_tx.h"
+#include "UTIL/OTG/otg_externs.h"
+#include "UTIL/MATH/oml.h"
+#include "common/utils/LOG/vcd_signal_dumper.h"
+#include "UTIL/OPT/opt.h"
+#include "enb_config.h"
+
+
+#ifndef OPENAIR2
+  #include "UTIL/OTG/otg_extern.h"
+#endif
+
+#if defined(ENABLE_ITTI)
+  #if defined(ENABLE_USE_MME)
+    #include "s1ap_eNB.h"
+    #ifdef PDCP_USE_NETLINK
+      #include "SIMULATION/ETH_TRANSPORT/proto.h"
+    #endif
+  #endif
+#endif
+
+#include "T.h"
+
+//#define DEBUG_THREADS 1
+
+//#define USRP_DEBUG 1
+// Fix per CC openair rf/if device update
+// extern openair0_device openair0;
+
+
+#if defined(ENABLE_ITTI)
+  extern volatile int             start_gNB;
+  extern volatile int             start_UE;
+#endif
+extern volatile int                    oai_exit;
+
+extern openair0_config_t openair0_cfg[MAX_CARDS];
+
+extern int transmission_mode;
+
+uint16_t sl_ahead=4;
+uint16_t sf_ahead=4;
+//pthread_t                       main_gNB_thread;
+
+time_stats_t softmodem_stats_mt; // main thread
+time_stats_t softmodem_stats_hw; //  hw acquisition
+time_stats_t softmodem_stats_rxtx_sf; // total tx time
+time_stats_t nfapi_meas; // total tx time
+time_stats_t softmodem_stats_rx_sf; // total rx time
+
+/* mutex, cond and variable to serialize phy proc TX calls
+ * (this mechanism may be relaxed in the future for better
+ * performances)
+ */
+static struct {
+  pthread_mutex_t  mutex_phy_proc_tx;
+  pthread_cond_t   cond_phy_proc_tx;
+  volatile uint8_t phy_proc_CC_id;
+} sync_phy_proc;
+
+extern double cpuf;
+
+void init_gNB(int,int);
+void stop_gNB(int nb_inst);
+
+int wakeup_txfh(gNB_L1_rxtx_proc_t *proc,PHY_VARS_gNB *gNB);
+int wakeup_tx(PHY_VARS_gNB *gNB);
+extern PARALLEL_CONF_t get_thread_parallel_conf(void);
+extern WORKER_CONF_t   get_thread_worker_conf(void);
+
+
+void wakeup_prach_gNB(PHY_VARS_gNB *gNB,RU_t *ru,int frame,int subframe);
+
+extern uint8_t nfapi_mode;
+extern void oai_subframe_ind(uint16_t sfn, uint16_t sf);
+extern void add_subframe(uint16_t *frameP, uint16_t *subframeP, int offset);
+
+//#define TICK_TO_US(ts) (ts.diff)
+#define TICK_TO_US(ts) (ts.trials==0?0:ts.diff/ts.trials)
+
+
+static inline int rxtx(PHY_VARS_gNB *gNB,gNB_L1_rxtx_proc_t *proc, char *thread_name) {
+  start_meas(&softmodem_stats_rxtx_sf);
+
+  // *******************************************************************
+
+  if (nfapi_mode == 1) {
+    // I am a PNF and I need to let nFAPI know that we have a (sub)frame tick
+    uint16_t frame = proc->frame_rx;
+    uint16_t slot  = proc->slot_rx;
+    //add_subframe(&frame, &subframe, 4);
+    //oai_subframe_ind(proc->frame_tx, proc->subframe_tx);
+    //LOG_D(PHY, "oai_subframe_ind(frame:%u, subframe:%d) - NOT CALLED ********\n", frame, subframe);
+    start_meas(&nfapi_meas);
+    oai_subframe_ind(frame, slot);
+    stop_meas(&nfapi_meas);
+
+    if (gNB->UL_INFO.rx_ind.rx_indication_body.number_of_pdus||
+        gNB->UL_INFO.harq_ind.harq_indication_body.number_of_harqs ||
+        gNB->UL_INFO.crc_ind.crc_indication_body.number_of_crcs ||
+        gNB->UL_INFO.rach_ind.rach_indication_body.number_of_preambles ||
+        gNB->UL_INFO.cqi_ind.number_of_cqis
+       ) {
+      LOG_D(PHY, "UL_info[rx_ind:%05d:%d harqs:%05d:%d crcs:%05d:%d preambles:%05d:%d cqis:%d] RX:%04d%d TX:%04d%d \n",
+            NFAPI_SFNSF2DEC(gNB->UL_INFO.rx_ind.sfn_sf),   gNB->UL_INFO.rx_ind.rx_indication_body.number_of_pdus,
+            NFAPI_SFNSF2DEC(gNB->UL_INFO.harq_ind.sfn_sf), gNB->UL_INFO.harq_ind.harq_indication_body.number_of_harqs,
+            NFAPI_SFNSF2DEC(gNB->UL_INFO.crc_ind.sfn_sf),  gNB->UL_INFO.crc_ind.crc_indication_body.number_of_crcs,
+            NFAPI_SFNSF2DEC(gNB->UL_INFO.rach_ind.sfn_sf), gNB->UL_INFO.rach_ind.rach_indication_body.number_of_preambles,
+            gNB->UL_INFO.cqi_ind.number_of_cqis,
+            proc->frame_rx, proc->slot_rx,
+            proc->frame_tx, proc->slot_tx);
+    }
+  }
+
+  /// NR disabling
+  // ****************************************
+  // Common RX procedures subframe n
+  T(T_GNB_PHY_DL_TICK, T_INT(gNB->Mod_id), T_INT(proc->frame_tx), T_INT(proc->slot_tx));
+  /*
+    // if this is IF5 or 3GPP_gNB
+    if (gNB && gNB->RU_list && gNB->RU_list[0] && gNB->RU_list[0]->function < NGFI_RAU_IF4p5) {
+      wakeup_prach_gNB(gNB,NULL,proc->frame_rx,proc->slot_rx);
+    }
+
+    // UE-specific RX processing for subframe n
+    if (nfapi_mode == 0 || nfapi_mode == 1) {
+      phy_procedures_gNB_uespec_RX(gNB, proc, no_relay );
+    }
+  */
+  pthread_mutex_lock(&gNB->UL_INFO_mutex);
+  gNB->UL_INFO.frame     = proc->frame_rx;
+  gNB->UL_INFO.slot      = proc->slot_rx;
+  gNB->UL_INFO.module_id = gNB->Mod_id;
+  gNB->UL_INFO.CC_id     = gNB->CC_id;
+  gNB->if_inst->NR_UL_indication(&gNB->UL_INFO);
+  pthread_mutex_unlock(&gNB->UL_INFO_mutex);
+
+  /// end
+  // *****************************************
+  // TX processing for subframe n+sl_ahead
+  // run PHY TX procedures the one after the other for all CCs to avoid race conditions
+  // (may be relaxed in the future for performance reasons)
+  // *****************************************
+  //if (wait_CCs(proc)<0) return(-1);
+
+  if (oai_exit) return(-1);
+
+  if(get_thread_parallel_conf() == PARALLEL_SINGLE_THREAD) {
+    phy_procedures_gNB_TX(gNB, proc, 1);
+  }
+
+  stop_meas( &softmodem_stats_rxtx_sf );
+  LOG_D(PHY,"%s() Exit proc[rx:%d%d tx:%d%d]\n", __FUNCTION__, proc->frame_rx, proc->slot_rx, proc->frame_tx, proc->slot_tx);
+#if 0
+  LOG_D(PHY, "rxtx:%lld nfapi:%lld phy:%lld tx:%lld rx:%lld prach:%lld ofdm:%lld ",
+        softmodem_stats_rxtx_sf.diff_now, nfapi_meas.diff_now,
+        TICK_TO_US(gNB->phy_proc),
+        TICK_TO_US(gNB->phy_proc_tx),
+        TICK_TO_US(gNB->phy_proc_rx),
+        TICK_TO_US(gNB->rx_prach),
+        TICK_TO_US(gNB->ofdm_mod_stats),
+        softmodem_stats_rxtx_sf.diff_now, nfapi_meas.diff_now);
+  LOG_D(PHY,
+        "dlsch[enc:%lld mod:%lld scr:%lld rm:%lld t:%lld i:%lld] rx_dft:%lld ",
+        TICK_TO_US(gNB->dlsch_encoding_stats),
+        TICK_TO_US(gNB->dlsch_modulation_stats),
+        TICK_TO_US(gNB->dlsch_scrambling_stats),
+        TICK_TO_US(gNB->dlsch_rate_matching_stats),
+        TICK_TO_US(gNB->dlsch_turbo_encoding_stats),
+        TICK_TO_US(gNB->dlsch_interleaving_stats),
+        TICK_TO_US(gNB->rx_dft_stats));
+  LOG_D(PHY," ulsch[ch:%lld freq:%lld dec:%lld demod:%lld ru:%lld ",
+        TICK_TO_US(gNB->ulsch_channel_estimation_stats),
+        TICK_TO_US(gNB->ulsch_freq_offset_estimation_stats),
+        TICK_TO_US(gNB->ulsch_decoding_stats),
+        TICK_TO_US(gNB->ulsch_demodulation_stats),
+        TICK_TO_US(gNB->ulsch_rate_unmatching_stats));
+  LOG_D(PHY, "td:%lld dei:%lld dem:%lld llr:%lld tci:%lld ",
+        TICK_TO_US(gNB->ulsch_turbo_decoding_stats),
+        TICK_TO_US(gNB->ulsch_deinterleaving_stats),
+        TICK_TO_US(gNB->ulsch_demultiplexing_stats),
+        TICK_TO_US(gNB->ulsch_llr_stats),
+        TICK_TO_US(gNB->ulsch_tc_init_stats));
+  LOG_D(PHY, "tca:%lld tcb:%lld tcg:%lld tce:%lld l1:%lld l2:%lld]\n\n",
+        TICK_TO_US(gNB->ulsch_tc_alpha_stats),
+        TICK_TO_US(gNB->ulsch_tc_beta_stats),
+        TICK_TO_US(gNB->ulsch_tc_gamma_stats),
+        TICK_TO_US(gNB->ulsch_tc_ext_stats),
+        TICK_TO_US(gNB->ulsch_tc_intl1_stats),
+        TICK_TO_US(gNB->ulsch_tc_intl2_stats)
+       );
+#endif
+  return(0);
+}
+
+static void *gNB_L1_thread_tx(void *param) {
+  PHY_VARS_gNB *gNB        = (PHY_VARS_gNB *)param;
+  gNB_L1_proc_t *gNB_proc  = &gNB->proc;
+  gNB_L1_rxtx_proc_t *proc = &gNB_proc->L1_proc_tx;
+  //PHY_VARS_gNB *gNB = RC.gNB[0][proc->CC_id];
+  char thread_name[100];
+  sprintf(thread_name,"TXnp4_%d\n",&gNB->proc.L1_proc == proc ? 0 : 1);
+
+  //wait_sync("tx_thread");
+
+  while (!oai_exit) {
+    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_gNB_PROC_RXTX1, 0 );
+
+    if (wait_on_condition(&proc->mutex,&proc->cond,&proc->instance_cnt,thread_name)<0) break;
+
+    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_gNB_PROC_RXTX1, 1 );
+
+    if (oai_exit) break;
+
+    // *****************************************
+    // TX processing for subframe n+4
+    // run PHY TX procedures the one after the other for all CCs to avoid race conditions
+    // (may be relaxed in the future for performance reasons)
+    // *****************************************
+    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_SLOT_NUMBER_TX1_GNB,proc->slot_tx);
+    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_SLOT_NUMBER_RX1_GNB,proc->slot_rx);
+    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_TX1_GNB,proc->frame_tx);
+    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_RX1_GNB,proc->frame_rx);
+    phy_procedures_gNB_TX(gNB, proc, 1);
+    pthread_mutex_lock( &proc->mutex );
+    proc->instance_cnt = -1;
+
+    // the thread can now be woken up
+    if (pthread_cond_signal(&proc->cond) != 0) {
+      LOG_E( PHY, "[gNB] ERROR pthread_cond_signal for gNB TXnp4 thread\n");
+      exit_fun( "ERROR pthread_cond_signal" );
+    }
+
+    pthread_mutex_unlock( &proc->mutex );
+    wakeup_txfh(proc,gNB);
+  }
+
+  return 0;
+}
+
+/*!
+ * \brief The RX UE-specific and TX thread of gNB.
+ * \param param is a \ref gNB_L1_proc_t structure which contains the info what to process.
+ * \returns a pointer to an int. The storage is not on the heap and must not be freed.
+ */
+
+static void *gNB_L1_thread( void *param ) {
+  static int gNB_thread_rxtx_status;
+  PHY_VARS_gNB *gNB        = (PHY_VARS_gNB *)param;
+  gNB_L1_proc_t *gNB_proc  = &gNB->proc;
+  gNB_L1_rxtx_proc_t *proc = &gNB_proc->L1_proc;
+  //PHY_VARS_gNB *gNB = RC.gNB[0][proc->CC_id];
+  char thread_name[100];
+  // set default return value
+  gNB_thread_rxtx_status = 0;
+  sprintf(thread_name,"RXn_TXnp4_%d",&gNB->proc.L1_proc == proc ? 0 : 1);
+
+  while (!oai_exit) {
+    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_gNB_PROC_RXTX0, 0 );
+
+    if (wait_on_condition(&proc->mutex,&proc->cond,&proc->instance_cnt,thread_name)<0) break;
+
+    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_gNB_PROC_RXTX0, 1 );
+    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_SLOT_NUMBER_TX0_GNB,proc->slot_tx);
+    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_SLOT_NUMBER_RX0_GNB,proc->slot_rx);
+    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_TX0_GNB,proc->frame_tx);
+    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_RX0_GNB,proc->frame_rx);
+
+    if (oai_exit) break;
+
+    if (gNB->CC_id==0) {
+      if (rxtx(gNB,proc,thread_name) < 0) break;
+    }
+
+    if(get_thread_parallel_conf() == PARALLEL_RU_L1_SPLIT) {
+      phy_procedures_gNB_TX(gNB, proc, 1);
+    }
+
+    if (release_thread(&proc->mutex,&proc->instance_cnt,thread_name)<0) break;
+
+    if(get_thread_parallel_conf() == PARALLEL_RU_L1_TRX_SPLIT) {
+      wakeup_tx(gNB);
+    } else if(get_thread_parallel_conf() == PARALLEL_RU_L1_SPLIT) {
+      wakeup_txfh(proc,gNB);
+    }
+  } // while !oai_exit
+
+  LOG_D(PHY, " *** Exiting gNB thread RXn_TXnp4\n");
+  gNB_thread_rxtx_status = 0;
+  return &gNB_thread_rxtx_status;
+}
+
+
+#if 0 //defined(ENABLE_ITTI) && defined(ENABLE_USE_MME)
+// Wait for gNB application initialization to be complete (gNB registration to MME)
+static void wait_system_ready (char *message, volatile int *start_flag) {
+  static char *indicator[] = {".    ", "..   ", "...  ", ".... ", ".....",
+                              " ....", "  ...", "   ..", "    .", "     "
+                             };
+  int i = 0;
+
+  while ((!oai_exit) && (*start_flag == 0)) {
+    LOG_N(EMU, message, indicator[i]);
+    fflush(stdout);
+    i = (i + 1) % (sizeof(indicator) / sizeof(indicator[0]));
+    usleep(200000);
+  }
+
+  LOG_D(EMU,"\n");
+}
+#endif
+
+
+
+
+
+void gNB_top(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx, char *string, struct RU_t_s *ru) {
+  gNB_L1_proc_t *proc           = &gNB->proc;
+  gNB_L1_rxtx_proc_t *L1_proc = &proc->L1_proc;
+  NR_DL_FRAME_PARMS *fp = ru->nr_frame_parms;
+  RU_proc_t *ru_proc=&ru->proc;
+  proc->frame_rx    = frame_rx;
+  proc->slot_rx = slot_rx;
+
+  if (!oai_exit) {
+    T(T_ENB_MASTER_TICK, T_INT(0), T_INT(proc->frame_rx), T_INT(proc->slot_rx));
+    L1_proc->timestamp_tx = ru_proc->timestamp_rx + (sl_ahead*fp->samples_per_slot);
+    L1_proc->frame_rx     = ru_proc->frame_rx;
+    L1_proc->slot_rx      = ru_proc->tti_rx;
+    L1_proc->frame_tx     = (L1_proc->slot_rx > (fp->slots_per_frame-1-sl_ahead)) ? (L1_proc->frame_rx+1)&1023 : L1_proc->frame_rx;
+    L1_proc->slot_tx      = (L1_proc->slot_rx + sl_ahead)%fp->slots_per_frame;
+
+    if (rxtx(gNB,L1_proc,string) < 0) LOG_E(PHY,"gNB %d CC_id %d failed during execution\n",gNB->Mod_id,gNB->CC_id);
+
+    ru_proc->timestamp_tx = L1_proc->timestamp_tx;
+    ru_proc->tti_tx       = L1_proc->slot_tx;
+    ru_proc->frame_tx     = L1_proc->frame_tx;
+  }
+}
+
+int wakeup_txfh(gNB_L1_rxtx_proc_t *proc,PHY_VARS_gNB *gNB) {
+  RU_t *ru;
+  RU_proc_t *ru_proc;
+  struct timespec wait;
+  wait.tv_sec=0;
+  wait.tv_nsec=5000000L;
+  //printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~inside wakeup_txfh %d.%d IC_RU = %d\n", proc->frame_tx, proc->slot_tx, proc->instance_cnt_RUs);
+
+  if(wait_on_condition(&proc->mutex_RUs,&proc->cond_RUs,&proc->instance_cnt_RUs,"wakeup_txfh")<0) {
+    LOG_E(PHY,"Frame %d, subframe %d: TX FH not ready\n", proc->frame_tx, proc->slot_tx);
+    return(-1);
+  }
+
+  pthread_mutex_lock(&gNB->proc.mutex_RU_tx);
+  gNB->proc.RU_mask_tx = 0;
+  pthread_mutex_unlock(&gNB->proc.mutex_RU_tx);
+
+  if (release_thread(&proc->mutex_RUs,&proc->instance_cnt_RUs,"wakeup_txfh")<0) return(-1);
+
+  for(int i=0; i<gNB->num_RU; i++) {
+    ru      = gNB->RU_list[i];
+    ru_proc = &ru->proc;
+
+    if (ru_proc->instance_cnt_gNBs == 0) {
+      LOG_E(PHY,"Frame %d, subframe %d: TX FH thread busy, dropping Frame %d, subframe %d\n", ru_proc->frame_tx, ru_proc->tti_tx, proc->frame_rx, proc->slot_rx);
+      return(-1);
+    }
+
+    if (pthread_mutex_timedlock(&ru_proc->mutex_gNBs,&wait) != 0) {
+      LOG_E( PHY, "[eNB] ERROR pthread_mutex_lock for eNB TX1 thread %d (IC %d)\n", ru_proc->tti_rx&1,ru_proc->instance_cnt_gNBs );
+      exit_fun( "error locking mutex_gNB" );
+      return(-1);
+    }
+
+    ru_proc->instance_cnt_gNBs = 0;
+    ru_proc->timestamp_tx = proc->timestamp_tx;
+    ru_proc->tti_tx       = proc->slot_tx;
+    ru_proc->frame_tx     = proc->frame_tx;
+    LOG_I(PHY,"Signaling tx_thread_fh for %d.%d\n",ru_proc->frame_tx,ru_proc->tti_tx);
+
+    // the thread can now be woken up
+    if (pthread_cond_signal(&ru_proc->cond_gNBs) != 0) {
+      LOG_E( PHY, "[gNB] ERROR pthread_cond_signal for gNB TXnp4 thread\n");
+      exit_fun( "ERROR pthread_cond_signal" );
+      return(-1);
+    }
+
+    pthread_mutex_unlock( &ru_proc->mutex_gNBs );
+  }
+
+  return(0);
+}
+
+int wakeup_tx(PHY_VARS_gNB *gNB) {
+  gNB_L1_proc_t *proc=&gNB->proc;
+  gNB_L1_rxtx_proc_t *L1_proc_tx = &proc->L1_proc_tx;
+  gNB_L1_rxtx_proc_t *L1_proc    = &proc->L1_proc;
+  struct timespec wait;
+  wait.tv_sec=0;
+  wait.tv_nsec=5000000L;
+
+  if (pthread_mutex_timedlock(&L1_proc_tx->mutex,&wait) != 0) {
+    LOG_E(PHY, "[SCHED][eNB] ERROR locking mutex for eNB L1_thread_tx\n");
+    exit_fun("ERROR pthread_lock");
+    return(-1);
+  }
+
+  while(L1_proc_tx->instance_cnt == 0) {
+    pthread_cond_wait(&L1_proc_tx->cond,&L1_proc_tx->mutex);
+  }
+
+  L1_proc_tx->instance_cnt = 0;
+  L1_proc_tx->slot_rx   = L1_proc->slot_rx;
+  L1_proc_tx->frame_rx      = L1_proc->frame_rx;
+  L1_proc_tx->slot_tx   = L1_proc->slot_tx;
+  L1_proc_tx->frame_tx      = L1_proc->frame_tx;
+  L1_proc_tx->timestamp_tx  = L1_proc->timestamp_tx;
+
+  // the thread can now be woken up
+  if (pthread_cond_signal(&L1_proc_tx->cond) != 0) {
+    LOG_E( PHY, "[eNB] ERROR pthread_cond_signal for eNB TXnp4 thread\n");
+    exit_fun( "ERROR pthread_cond_signal" );
+    return(-1);
+  }
+
+  pthread_mutex_unlock( &L1_proc_tx->mutex);
+  return(0);
+}
+
+int wakeup_rxtx(PHY_VARS_gNB *gNB,RU_t *ru) {
+  gNB_L1_proc_t *proc=&gNB->proc;
+  gNB_L1_rxtx_proc_t *L1_proc=&proc->L1_proc;
+  NR_DL_FRAME_PARMS *fp = &gNB->frame_parms;
+  RU_proc_t *ru_proc=&ru->proc;
+  int i;
+  struct timespec wait;
+  pthread_mutex_lock(&proc->mutex_RU);
+
+  for (i=0; i<gNB->num_RU; i++) {
+    if (ru == gNB->RU_list[i]) {
+      if ((proc->RU_mask&(1<<i)) > 0)
+        LOG_E(PHY,"gNB %d frame %d, subframe %d : previous information from RU %d (num_RU %d,mask %x) has not been served yet!\n",
+              gNB->Mod_id,proc->frame_rx,proc->slot_rx,ru->idx,gNB->num_RU,proc->RU_mask);
+
+      proc->RU_mask |= (1<<i);
+    }
+  }
+
+  if (proc->RU_mask != (1<<gNB->num_RU)-1) {  // not all RUs have provided their information so return
+    LOG_E(PHY,"Not all RUs have provided their info\n");
+    pthread_mutex_unlock(&proc->mutex_RU);
+    return(0);
+  } else { // all RUs have provided their information so continue on and wakeup gNB processing
+    proc->RU_mask = 0;
+    pthread_mutex_unlock(&proc->mutex_RU);
+  }
+
+  wait.tv_sec=0;
+  wait.tv_nsec=5000000L;
+
+  /* accept some delay in processing - up to 5ms */
+  for (i = 0; i < fp->slots_per_frame && L1_proc->instance_cnt == 0; i++) {
+    LOG_W( PHY,"[gNB] SFN.SL %d.%d, gNB RXn-TXnp4 thread busy!! (i %d, cnt %i)\n", L1_proc->frame_tx, L1_proc->slot_tx, i,L1_proc->instance_cnt);
+    usleep(100);
+  }
+
+  if (L1_proc->instance_cnt == 0) {
+    exit_fun( "TX thread busy" );
+    return(-1);
+  }
+
+  // wake up TX for subframe n+sl_ahead
+  // lock the TX mutex and make sure the thread is ready
+  if (pthread_mutex_timedlock(&L1_proc->mutex,&wait) != 0) {
+    LOG_E( PHY, "[gNB] ERROR pthread_mutex_lock for gNB RXTX thread %d (IC %d)\n", L1_proc->slot_rx&1,L1_proc->instance_cnt );
+    exit_fun( "error locking mutex" );
+    return(-1);
+  }
+
+  ++L1_proc->instance_cnt;
+  // We have just received and processed the common part of a subframe, say n.
+  // TS_rx is the last received timestamp (start of 1st slot), TS_tx is the desired
+  // transmitted timestamp of the next TX slot (first).
+  // The last (TS_rx mod samples_per_frame) was n*samples_per_tti,
+  // we want to generate subframe (n+sl_ahead), so TS_tx = TX_rx+sl_ahead*samples_per_tti,
+  // and proc->slot_tx = proc->slot_rx+sl_ahead
+  L1_proc->timestamp_tx = ru_proc->timestamp_rx + (sl_ahead*fp->samples_per_slot);
+  L1_proc->frame_rx     = ru_proc->frame_rx;
+  L1_proc->slot_rx  = ru_proc->tti_rx;
+  L1_proc->frame_tx     = (L1_proc->slot_rx > (fp->slots_per_frame-1-sl_ahead)) ? (L1_proc->frame_rx+1)&1023 : L1_proc->frame_rx;
+  L1_proc->slot_tx  = (L1_proc->slot_rx + sl_ahead)%fp->slots_per_frame;
+  LOG_I(PHY,"wakeupL1: passing parameter IC = %d, RX: %d.%d, TX: %d.%d to L1 sl_ahead = %d\n", L1_proc->instance_cnt, L1_proc->frame_rx, L1_proc->slot_rx, L1_proc->frame_tx, L1_proc->slot_tx, sl_ahead);
+
+  // the thread can now be woken up
+  if (pthread_cond_signal(&L1_proc->cond) != 0) {
+    LOG_E( PHY, "[gNB] ERROR pthread_cond_signal for gNB RXn-TXnp4 thread\n");
+    exit_fun( "ERROR pthread_cond_signal" );
+    return(-1);
+  }
+
+  pthread_mutex_unlock( &L1_proc->mutex );
+  return(0);
+}
+/*
+void wakeup_prach_gNB(PHY_VARS_gNB *gNB,RU_t *ru,int frame,int subframe) {
+
+  gNB_L1_proc_t *proc = &gNB->proc;
+  LTE_DL_FRAME_PARMS *fp=&gNB->frame_parms;
+  int i;
+
+  if (ru!=NULL) {
+    pthread_mutex_lock(&proc->mutex_RU_PRACH);
+    for (i=0;i<gNB->num_RU;i++) {
+      if (ru == gNB->RU_list[i]) {
+  LOG_D(PHY,"frame %d, subframe %d: RU %d for gNB %d signals PRACH (mask %x, num_RU %d)\n",frame,subframe,i,gNB->Mod_id,proc->RU_mask_prach,gNB->num_RU);
+  if ((proc->RU_mask_prach&(1<<i)) > 0)
+    LOG_E(PHY,"gNB %d frame %d, subframe %d : previous information (PRACH) from RU %d (num_RU %d, mask %x) has not been served yet!\n",
+    gNB->Mod_id,frame,subframe,ru->idx,gNB->num_RU,proc->RU_mask_prach);
+  proc->RU_mask_prach |= (1<<i);
+      }
+    }
+    if (proc->RU_mask_prach != (1<<gNB->num_RU)-1) {  // not all RUs have provided their information so return
+      pthread_mutex_unlock(&proc->mutex_RU_PRACH);
+      return;
+    }
+    else { // all RUs have provided their information so continue on and wakeup gNB processing
+      proc->RU_mask_prach = 0;
+      pthread_mutex_unlock(&proc->mutex_RU_PRACH);
+    }
+  }
+
+  // check if we have to detect PRACH first
+  if (is_prach_subframe(fp,frame,subframe)>0) {
+    LOG_D(PHY,"Triggering prach processing, frame %d, subframe %d\n",frame,subframe);
+    if (proc->instance_cnt_prach == 0) {
+      LOG_W(PHY,"[gNB] Frame %d Subframe %d, dropping PRACH\n", frame,subframe);
+      return;
+    }
+
+    // wake up thread for PRACH RX
+    if (pthread_mutex_lock(&proc->mutex_prach) != 0) {
+      LOG_E( PHY, "[gNB] ERROR pthread_mutex_lock for gNB PRACH thread %d (IC %d)\n", proc->thread_index, proc->instance_cnt_prach);
+      exit_fun( "error locking mutex_prach" );
+      return;
+    }
+
+    ++proc->instance_cnt_prach;
+    // set timing for prach thread
+    proc->frame_prach = frame;
+    proc->subframe_prach = subframe;
+
+    // the thread can now be woken up
+    if (pthread_cond_signal(&proc->cond_prach) != 0) {
+      LOG_E( PHY, "[gNB] ERROR pthread_cond_signal for gNB PRACH thread %d\n", proc->thread_index);
+      exit_fun( "ERROR pthread_cond_signal" );
+      return;
+    }
+
+    pthread_mutex_unlock( &proc->mutex_prach );
+  }
+
+}*/
+
+/*!
+ * \brief The prach receive thread of gNB.
+ * \param param is a \ref gNB_L1_proc_t structure which contains the info what to process.
+ * \returns a pointer to an int. The storage is not on the heap and must not be freed.
+ */
+/*
+static void* gNB_thread_prach( void* param ) {
+ static int gNB_thread_prach_status;
+
+
+ PHY_VARS_gNB *gNB= (PHY_VARS_gNB *)param;
+ gNB_L1_proc_t *proc = &gNB->proc;
+
+ // set default return value
+ gNB_thread_prach_status = 0;
+
+
+
+ while (!oai_exit) {
+
+   if (oai_exit) break;
+
+
+   if (wait_on_condition(&proc->mutex_prach,&proc->cond_prach,&proc->instance_cnt_prach,"gNB_prach_thread") < 0) break;
+
+   LOG_D(PHY,"Running gNB prach procedures\n");
+   prach_procedures(gNB
+#if (RRC_VERSION >= MAKE_VERSION(14, 0, 0))
+      ,0
+#endif
+      );
+
+   if (release_thread(&proc->mutex_prach,&proc->instance_cnt_prach,"gNB_prach_thread") < 0) break;
+ }
+
+ LOG_I(PHY, "Exiting gNB thread PRACH\n");
+
+ gNB_thread_prach_status = 0;
+ return &gNB_thread_prach_status;
+}
+*/
+
+extern void init_td_thread(PHY_VARS_gNB *);
+extern void init_te_thread(PHY_VARS_gNB *);
+
+void init_gNB_proc(int inst) {
+  int i=0;
+  int CC_id;
+  PHY_VARS_gNB *gNB;
+  gNB_L1_proc_t *proc;
+  gNB_L1_rxtx_proc_t *L1_proc,*L1_proc_tx;
+  LOG_I(PHY,"%s(inst:%d) RC.nb_nr_CC[inst]:%d \n",__FUNCTION__,inst,RC.nb_nr_CC[inst]);
+
+  for (CC_id=0; CC_id<RC.nb_nr_CC[inst]; CC_id++) {
+    gNB = RC.gNB[inst][CC_id];
+#ifndef OCP_FRAMEWORK
+    LOG_I(PHY,"Initializing gNB processes instance:%d CC_id %d \n",inst,CC_id);
+#endif
+    proc = &gNB->proc;
+    L1_proc                        = &proc->L1_proc;
+    L1_proc_tx                     = &proc->L1_proc_tx;
+    L1_proc->instance_cnt          = -1;
+    L1_proc_tx->instance_cnt       = -1;
+    L1_proc->instance_cnt_RUs      = 0;
+    L1_proc_tx->instance_cnt_RUs   = 0;
+    proc->instance_cnt_prach       = -1;
+    proc->instance_cnt_asynch_rxtx = -1;
+    proc->CC_id                    = CC_id;
+    proc->first_rx                 =1;
+    proc->first_tx                 =1;
+    proc->RU_mask                  =0;
+    proc->RU_mask_tx               = (1<<gNB->num_RU)-1;
+    proc->RU_mask_prach            =0;
+    pthread_mutex_init( &gNB->UL_INFO_mutex, NULL);
+    pthread_mutex_init( &L1_proc->mutex, NULL);
+    pthread_mutex_init( &L1_proc_tx->mutex, NULL);
+    pthread_cond_init( &L1_proc->cond, NULL);
+    pthread_cond_init( &L1_proc_tx->cond, NULL);
+    pthread_mutex_init( &proc->mutex_prach, NULL);
+    pthread_mutex_init( &proc->mutex_asynch_rxtx, NULL);
+    pthread_mutex_init( &proc->mutex_RU,NULL);
+    pthread_mutex_init( &proc->mutex_RU_tx,NULL);
+    pthread_mutex_init( &proc->mutex_RU_PRACH,NULL);
+    pthread_cond_init( &proc->cond_prach, NULL);
+    pthread_cond_init( &proc->cond_asynch_rxtx, NULL);
+    LOG_I(PHY,"gNB->single_thread_flag:%d\n", gNB->single_thread_flag);
+
+    if (get_thread_parallel_conf() == PARALLEL_RU_L1_SPLIT || get_thread_parallel_conf() == PARALLEL_RU_L1_TRX_SPLIT) {
+      threadCreate( &L1_proc->pthread, gNB_L1_thread, gNB, "L1_proc", -1, OAI_PRIORITY_RT );
+      threadCreate( &L1_proc_tx->pthread, gNB_L1_thread_tx, gNB,"L1_proc_tx", -1, OAI_PRIORITY_RT);
+    }
+
+    //pthread_create( &proc->pthread_prach, attr_prach, gNB_thread_prach, gNB );
+    char name[16];
+
+    if (gNB->single_thread_flag==0) {
+      snprintf( name, sizeof(name), "L1 %d", i );
+      pthread_setname_np( L1_proc->pthread, name );
+      snprintf( name, sizeof(name), "L1TX %d", i );
+      pthread_setname_np( L1_proc_tx->pthread, name );
+    }
+
+    AssertFatal(proc->instance_cnt_prach == -1,"instance_cnt_prach = %d\n",proc->instance_cnt_prach);
+  }
+
+  /* setup PHY proc TX sync mechanism */
+  pthread_mutex_init(&sync_phy_proc.mutex_phy_proc_tx, NULL);
+  pthread_cond_init(&sync_phy_proc.cond_phy_proc_tx, NULL);
+  sync_phy_proc.phy_proc_CC_id = 0;
+}
+
+
+
+/*!
+ * \brief Terminate gNB TX and RX threads.
+ */
+void kill_gNB_proc(int inst) {
+  int *status;
+  PHY_VARS_gNB *gNB;
+  gNB_L1_proc_t *proc;
+  gNB_L1_rxtx_proc_t *L1_proc, *L1_proc_tx;
+
+  for (int CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
+    gNB=RC.gNB[inst][CC_id];
+    proc = &gNB->proc;
+    L1_proc     = &proc->L1_proc;
+    L1_proc_tx  = &proc->L1_proc_tx;
+    LOG_I(PHY, "Killing TX CC_id %d inst %d\n", CC_id, inst );
+
+    if (get_thread_parallel_conf() == PARALLEL_RU_L1_SPLIT || get_thread_parallel_conf() == PARALLEL_RU_L1_TRX_SPLIT) {
+      pthread_mutex_lock(&L1_proc->mutex);
+      L1_proc->instance_cnt = 0;
+      pthread_cond_signal(&L1_proc->cond);
+      pthread_mutex_unlock(&L1_proc->mutex);
+      pthread_mutex_lock(&L1_proc_tx->mutex);
+      L1_proc_tx->instance_cnt = 0;
+      pthread_cond_signal(&L1_proc_tx->cond);
+      pthread_mutex_unlock(&L1_proc_tx->mutex);
+    }
+
+    proc->instance_cnt_prach = 0;
+    pthread_cond_signal( &proc->cond_prach );
+    pthread_cond_signal( &proc->cond_asynch_rxtx );
+    pthread_cond_broadcast(&sync_phy_proc.cond_phy_proc_tx);
+    //    LOG_D(PHY, "joining pthread_prach\n");
+    //    pthread_join( proc->pthread_prach, (void**)&status );
+    LOG_I(PHY, "Destroying prach mutex/cond\n");
+    pthread_mutex_destroy( &proc->mutex_prach );
+    pthread_cond_destroy( &proc->cond_prach );
+    LOG_I(PHY, "Destroying UL_INFO mutex\n");
+    pthread_mutex_destroy(&gNB->UL_INFO_mutex);
+
+    if (get_thread_parallel_conf() == PARALLEL_RU_L1_SPLIT || get_thread_parallel_conf() == PARALLEL_RU_L1_TRX_SPLIT) {
+      LOG_I(PHY, "Joining L1_proc mutex/cond\n");
+      pthread_join( L1_proc->pthread, (void **)&status );
+      LOG_I(PHY, "Joining L1_proc_tx mutex/cond\n");
+      pthread_join( L1_proc_tx->pthread, (void **)&status );
+    }
+
+    LOG_I(PHY, "Destroying L1_proc mutex/cond\n");
+    pthread_mutex_destroy( &L1_proc->mutex );
+    pthread_cond_destroy( &L1_proc->cond );
+    LOG_I(PHY, "Destroying L1_proc_tx mutex/cond\n");
+    pthread_mutex_destroy( &L1_proc_tx->mutex );
+    pthread_cond_destroy( &L1_proc_tx->cond );
+    pthread_mutex_destroy( &proc->mutex_RU );
+    pthread_mutex_destroy( &proc->mutex_RU_tx );
+  }
+}
+
+
+
+
+void reset_opp_meas(void) {
+  int sfn;
+  reset_meas(&softmodem_stats_mt);
+  reset_meas(&softmodem_stats_hw);
+
+  for (sfn=0; sfn < 10; sfn++) {
+    reset_meas(&softmodem_stats_rxtx_sf);
+    reset_meas(&softmodem_stats_rx_sf);
+  }
+}
+
+
+void print_opp_meas(void) {
+  int sfn=0;
+  print_meas(&softmodem_stats_mt, "Main gNB Thread", NULL, NULL);
+  print_meas(&softmodem_stats_hw, "HW Acquisation", NULL, NULL);
+
+  for (sfn=0; sfn < 10; sfn++) {
+    print_meas(&softmodem_stats_rxtx_sf,"[gNB][total_phy_proc_rxtx]",NULL, NULL);
+    print_meas(&softmodem_stats_rx_sf,"[gNB][total_phy_proc_rx]",NULL,NULL);
+  }
+}
+
+
+/// eNB kept in function name for nffapi calls, TO FIX
+void init_eNB_afterRU(void) {
+  int inst,CC_id,ru_id,i,aa;
+  PHY_VARS_gNB *gNB;
+  LOG_I(PHY,"%s() RC.nb_nr_inst:%d\n", __FUNCTION__, RC.nb_nr_inst);
+
+  for (inst=0; inst<RC.nb_nr_inst; inst++) {
+    LOG_I(PHY,"RC.nb_nr_CC[inst]:%d\n", RC.nb_nr_CC[inst]);
+
+    for (CC_id=0; CC_id<RC.nb_nr_CC[inst]; CC_id++) {
+      LOG_I(PHY,"RC.nb_nr_CC[inst:%d][CC_id:%d]:%p\n", inst, CC_id, RC.gNB[inst][CC_id]);
+      gNB                                  =  RC.gNB[inst][CC_id];
+      phy_init_nr_gNB(gNB,0,0);
+
+      // map antennas and PRACH signals to gNB RX
+      if (0) AssertFatal(gNB->num_RU>0,"Number of RU attached to gNB %d is zero\n",gNB->Mod_id);
+
+      LOG_I(PHY,"Mapping RX ports from %d RUs to gNB %d\n",gNB->num_RU,gNB->Mod_id);
+      //LOG_I(PHY,"Overwriting gNB->prach_vars.rxsigF[0]:%p\n", gNB->prach_vars.rxsigF[0]);
+      gNB->prach_vars.rxsigF[0] = (int16_t **)malloc16(64*sizeof(int16_t *));
+      LOG_I(PHY,"gNB->num_RU:%d\n", gNB->num_RU);
+
+      for (ru_id=0,aa=0; ru_id<gNB->num_RU; ru_id++) {
+        AssertFatal(gNB->RU_list[ru_id]->common.rxdataF!=NULL,
+                    "RU %d : common.rxdataF is NULL\n",
+                    gNB->RU_list[ru_id]->idx);
+        AssertFatal(gNB->RU_list[ru_id]->prach_rxsigF!=NULL,
+                    "RU %d : prach_rxsigF is NULL\n",
+                    gNB->RU_list[ru_id]->idx);
+
+        for (i=0; i<gNB->RU_list[ru_id]->nb_rx; aa++,i++) {
+          LOG_I(PHY,"Attaching RU %d antenna %d to gNB antenna %d\n",gNB->RU_list[ru_id]->idx,i,aa);
+          gNB->prach_vars.rxsigF[0][aa]    =  gNB->RU_list[ru_id]->prach_rxsigF[i];
+          gNB->common_vars.rxdataF[aa]     =  gNB->RU_list[ru_id]->common.rxdataF[i];
+        }
+      }
+
+      /* TODO: review this code, there is something wrong.
+       * In monolithic mode, we come here with nb_antennas_rx == 0
+       * (not tested in other modes).
+       */
+      //init_precoding_weights(RC.gNB[inst][CC_id]);
+    }
+
+    init_gNB_proc(inst);
+  }
+
+  for (ru_id=0; ru_id<RC.nb_RU; ru_id++) {
+    AssertFatal(RC.ru[ru_id]!=NULL,"ru_id %d is null\n",ru_id);
+    RC.ru[ru_id]->nr_wakeup_rxtx         = wakeup_rxtx;
+    //    RC.ru[ru_id]->wakeup_prach_eNB    = wakeup_prach_gNB;
+    RC.ru[ru_id]->gNB_top             = gNB_top;
+  }
+}
+
+void init_gNB(int single_thread_flag,int wait_for_sync) {
+  int CC_id;
+  int inst;
+  PHY_VARS_gNB *gNB;
+  LOG_I(PHY,"[nr-softmodem.c] gNB structure about to allocated RC.nb_nr_L1_inst:%d RC.nb_nr_L1_CC[0]:%d\n",RC.nb_nr_L1_inst,RC.nb_nr_L1_CC[0]);
+
+  if (RC.gNB == NULL) RC.gNB = (PHY_VARS_gNB ***) malloc(RC.nb_nr_L1_inst*sizeof(PHY_VARS_gNB **));
+
+  LOG_I(PHY,"[lte-softmodem.c] gNB structure RC.gNB allocated\n");
+
+  for (inst=0; inst<RC.nb_nr_L1_inst; inst++) {
+    if (RC.gNB[inst] == NULL) RC.gNB[inst] = (PHY_VARS_gNB **) malloc(RC.nb_nr_CC[inst]*sizeof(PHY_VARS_gNB *));
+
+    for (CC_id=0; CC_id<RC.nb_nr_L1_CC[inst]; CC_id++) {
+      if (RC.gNB[inst][CC_id] == NULL) RC.gNB[inst][CC_id] = (PHY_VARS_gNB *) malloc(sizeof(PHY_VARS_gNB));
+
+      gNB                     = RC.gNB[inst][CC_id];
+      gNB->abstraction_flag   = 0;
+      gNB->single_thread_flag = single_thread_flag;
+      /*nr_polar_init(&gNB->nrPolar_params,
+                NR_POLAR_PBCH_MESSAGE_TYPE,
+          NR_POLAR_PBCH_PAYLOAD_BITS,
+          NR_POLAR_PBCH_AGGREGATION_LEVEL);*/
+      LOG_I(PHY,"Initializing gNB %d CC_id %d single_thread_flag:%d\n",inst,CC_id,single_thread_flag);
+#ifndef OCP_FRAMEWORK
+      LOG_I(PHY,"Initializing gNB %d CC_id %d\n",inst,CC_id);
+#endif
+      LOG_I(PHY,"Registering with MAC interface module\n");
+      AssertFatal((gNB->if_inst         = NR_IF_Module_init(inst))!=NULL,"Cannot register interface");
+      gNB->if_inst->NR_Schedule_response   = nr_schedule_response;
+      gNB->if_inst->NR_PHY_config_req      = nr_phy_config_request;
+      memset((void *)&gNB->UL_INFO,0,sizeof(gNB->UL_INFO));
+      memset((void *)&gNB->Sched_INFO,0,sizeof(gNB->Sched_INFO));
+      LOG_I(PHY,"Setting indication lists\n");
+      gNB->UL_INFO.rx_ind.rx_indication_body.rx_pdu_list   = gNB->rx_pdu_list;
+      gNB->UL_INFO.crc_ind.crc_indication_body.crc_pdu_list = gNB->crc_pdu_list;
+      gNB->UL_INFO.sr_ind.sr_indication_body.sr_pdu_list = gNB->sr_pdu_list;
+      gNB->UL_INFO.harq_ind.harq_indication_body.harq_pdu_list = gNB->harq_pdu_list;
+      gNB->UL_INFO.cqi_ind.cqi_pdu_list = gNB->cqi_pdu_list;
+      gNB->UL_INFO.cqi_ind.cqi_raw_pdu_list = gNB->cqi_raw_pdu_list;
+      gNB->prach_energy_counter = 0;
+    }
+  }
+
+  LOG_I(PHY,"[nr-softmodem.c] gNB structure allocated\n");
+}
+
+
+void stop_gNB(int nb_inst) {
+  for (int inst=0; inst<nb_inst; inst++) {
+    LOG_I(PHY,"Killing gNB %d processing threads\n",inst);
+    kill_gNB_proc(inst);
+  }
+}
diff --git a/executables/nr-ru.c b/executables/nr-ru.c
new file mode 100644
index 0000000000..e6e62ad553
--- /dev/null
+++ b/executables/nr-ru.c
@@ -0,0 +1,2280 @@
+/*******************************************************************************
+    OpenAirInterface
+    Copyright(c) 1999 - 2014 Eurecom
+
+    OpenAirInterface is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenAirInterface is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenAirInterface.The full GNU General Public License is
+    included in this distribution in the file called "COPYING". If not,
+    see <http://www.gnu.org/licenses/>.
+
+   Contact Information
+   OpenAirInterface Admin: openair_admin@eurecom.fr
+   OpenAirInterface Tech : openair_tech@eurecom.fr
+   OpenAirInterface Dev  : openair4g-devel@lists.eurecom.fr
+
+   Address      : Eurecom, Campus SophiaTech, 450 Route des Chappes, CS 50193 - 06904 Biot Sophia Antipolis cedex, FRANCE
+
+*******************************************************************************/
+
+/*! \file lte-enb.c
+ * \brief Top-level threads for eNodeB
+ * \author R. Knopp, F. Kaltenberger, Navid Nikaein
+ * \date 2012
+ * \version 0.1
+ * \company Eurecom
+ * \email: knopp@eurecom.fr,florian.kaltenberger@eurecom.fr, navid.nikaein@eurecom.fr
+ * \note
+ * \warning
+ */
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/mman.h>
+#include <sched.h>
+#include <linux/sched.h>
+#include <signal.h>
+#include <execinfo.h>
+#include <getopt.h>
+#include <sys/sysinfo.h>
+
+#undef MALLOC //there are two conflicting definitions, so we better make sure we don't use it at all
+
+#include "common/utils/assertions.h"
+#include "common/utils/system.h"
+#include "msc.h"
+
+#include "../../ARCH/COMMON/common_lib.h"
+#include "../../ARCH/ETHERNET/USERSPACE/LIB/ethernet_lib.h"
+
+#include "PHY/LTE_TRANSPORT/if4_tools.h"
+#include "PHY/LTE_TRANSPORT/if5_tools.h"
+
+#include "PHY/types.h"
+#include "PHY/defs_nr_common.h"
+#include "PHY/phy_extern.h"
+#include "PHY/LTE_TRANSPORT/transport_proto.h"
+#include "PHY/INIT/phy_init.h"
+#include "SCHED/sched_eNB.h"
+#include "SCHED_NR/sched_nr.h"
+
+#include "LAYER2/MAC/mac.h"
+#include "LAYER2/MAC/mac_extern.h"
+#include "LAYER2/MAC/mac_proto.h"
+#include "RRC/LTE/rrc_extern.h"
+#include "PHY_INTERFACE/phy_interface.h"
+
+#include "common/utils/LOG/log.h"
+#include "common/utils/LOG/vcd_signal_dumper.h"
+
+#include "enb_config.h"
+
+#ifdef SMBV
+#include "PHY/TOOLS/smbv.h"
+unsigned short config_frames[4] = {2,9,11,13};
+#endif
+
+/* these variables have to be defined before including ENB_APP/enb_paramdef.h */
+static int DEFBANDS[] = {7};
+static int DEFENBS[] = {0};
+
+#include "ENB_APP/enb_paramdef.h"
+#include "common/config/config_userapi.h"
+
+#ifndef OPENAIR2
+  #include "UTIL/OTG/otg_extern.h"
+#endif
+
+#if defined(ENABLE_ITTI)
+  #if defined(ENABLE_USE_MME)
+    #include "s1ap_eNB.h"
+    #ifdef PDCP_USE_NETLINK
+      #include "SIMULATION/ETH_TRANSPORT/proto.h"
+    #endif
+  #endif
+#endif
+
+#include "T.h"
+#include "nfapi_interface.h"
+
+extern volatile int                    oai_exit;
+
+
+extern void  nr_phy_free_RU(RU_t *);
+extern void  nr_phy_config_request(NR_PHY_Config_t *gNB);
+
+extern PARALLEL_CONF_t get_thread_parallel_conf(void);
+extern WORKER_CONF_t   get_thread_worker_conf(void);
+
+void init_RU(char *);
+void stop_RU(int nb_ru);
+void do_ru_sync(RU_t *ru);
+
+void configure_ru(int idx,
+                  void *arg);
+
+void configure_rru(int idx,
+                   void *arg);
+
+int attach_rru(RU_t *ru);
+
+int connect_rau(RU_t *ru);
+
+extern uint16_t sl_ahead;
+
+extern int emulate_rf;
+extern int numerology;
+
+/*************************************************************/
+/* Functions to attach and configure RRU                     */
+
+extern void wait_gNBs(void);
+
+int attach_rru(RU_t *ru) {
+  ssize_t      msg_len,len;
+  RRU_CONFIG_msg_t rru_config_msg;
+  int received_capabilities=0;
+  wait_gNBs();
+
+  // Wait for capabilities
+  while (received_capabilities==0) {
+    memset((void *)&rru_config_msg,0,sizeof(rru_config_msg));
+    rru_config_msg.type = RAU_tick;
+    rru_config_msg.len  = sizeof(RRU_CONFIG_msg_t)-MAX_RRU_CONFIG_SIZE;
+    LOG_I(PHY,"Sending RAU tick to RRU %d\n",ru->idx);
+    AssertFatal((ru->ifdevice.trx_ctlsend_func(&ru->ifdevice,&rru_config_msg,rru_config_msg.len)!=-1),
+                "RU %d cannot access remote radio\n",ru->idx);
+    msg_len  = sizeof(RRU_CONFIG_msg_t)-MAX_RRU_CONFIG_SIZE+sizeof(RRU_capabilities_t);
+
+    // wait for answer with timeout
+    if ((len = ru->ifdevice.trx_ctlrecv_func(&ru->ifdevice,
+               &rru_config_msg,
+               msg_len))<0) {
+      LOG_I(PHY,"Waiting for RRU %d\n",ru->idx);
+    } else if (rru_config_msg.type == RRU_capabilities) {
+      AssertFatal(rru_config_msg.len==msg_len,"Received capabilities with incorrect length (%d!=%d)\n",(int)rru_config_msg.len,(int)msg_len);
+      LOG_I(PHY,"Received capabilities from RRU %d (len %d/%d, num_bands %d,max_pdschReferenceSignalPower %d, max_rxgain %d, nb_tx %d, nb_rx %d)\n",ru->idx,
+            (int)rru_config_msg.len,(int)msg_len,
+            ((RRU_capabilities_t *)&rru_config_msg.msg[0])->num_bands,
+            ((RRU_capabilities_t *)&rru_config_msg.msg[0])->max_pdschReferenceSignalPower[0],
+            ((RRU_capabilities_t *)&rru_config_msg.msg[0])->max_rxgain[0],
+            ((RRU_capabilities_t *)&rru_config_msg.msg[0])->nb_tx[0],
+            ((RRU_capabilities_t *)&rru_config_msg.msg[0])->nb_rx[0]);
+      received_capabilities=1;
+    } else {
+      LOG_E(PHY,"Received incorrect message %d from RRU %d\n",rru_config_msg.type,ru->idx);
+    }
+  }
+
+  configure_ru(ru->idx,
+               (RRU_capabilities_t *)&rru_config_msg.msg[0]);
+  rru_config_msg.type = RRU_config;
+  rru_config_msg.len  = sizeof(RRU_CONFIG_msg_t)-MAX_RRU_CONFIG_SIZE+sizeof(RRU_config_t);
+  LOG_I(PHY,"Sending Configuration to RRU %d (num_bands %d,band0 %d,txfreq %u,rxfreq %u,att_tx %d,att_rx %d,N_RB_DL %d,N_RB_UL %d,3/4FS %d, prach_FO %d, prach_CI %d)\n",ru->idx,
+        ((RRU_config_t *)&rru_config_msg.msg[0])->num_bands,
+        ((RRU_config_t *)&rru_config_msg.msg[0])->band_list[0],
+        ((RRU_config_t *)&rru_config_msg.msg[0])->tx_freq[0],
+        ((RRU_config_t *)&rru_config_msg.msg[0])->rx_freq[0],
+        ((RRU_config_t *)&rru_config_msg.msg[0])->att_tx[0],
+        ((RRU_config_t *)&rru_config_msg.msg[0])->att_rx[0],
+        ((RRU_config_t *)&rru_config_msg.msg[0])->N_RB_DL[0],
+        ((RRU_config_t *)&rru_config_msg.msg[0])->N_RB_UL[0],
+        ((RRU_config_t *)&rru_config_msg.msg[0])->threequarter_fs[0],
+        ((RRU_config_t *)&rru_config_msg.msg[0])->prach_FreqOffset[0],
+        ((RRU_config_t *)&rru_config_msg.msg[0])->prach_ConfigIndex[0]);
+  AssertFatal((ru->ifdevice.trx_ctlsend_func(&ru->ifdevice,&rru_config_msg,rru_config_msg.len)!=-1),
+              "RU %d failed send configuration to remote radio\n",ru->idx);
+  return 0;
+}
+
+int connect_rau(RU_t *ru) {
+  RRU_CONFIG_msg_t   rru_config_msg;
+  ssize_t      msg_len;
+  int                tick_received          = 0;
+  int                configuration_received = 0;
+  RRU_capabilities_t *cap;
+  int                i;
+  int                len;
+
+  // wait for RAU_tick
+  while (tick_received == 0) {
+    msg_len  = sizeof(RRU_CONFIG_msg_t)-MAX_RRU_CONFIG_SIZE;
+
+    if ((len = ru->ifdevice.trx_ctlrecv_func(&ru->ifdevice,
+               &rru_config_msg,
+               msg_len))<0) {
+      LOG_I(PHY,"Waiting for RAU\n");
+    } else {
+      if (rru_config_msg.type == RAU_tick) {
+        LOG_I(PHY,"Tick received from RAU\n");
+        tick_received = 1;
+      } else LOG_E(PHY,"Received erroneous message (%d)from RAU, expected RAU_tick\n",rru_config_msg.type);
+    }
+  }
+
+  // send capabilities
+  rru_config_msg.type = RRU_capabilities;
+  rru_config_msg.len  = sizeof(RRU_CONFIG_msg_t)-MAX_RRU_CONFIG_SIZE+sizeof(RRU_capabilities_t);
+  cap                 = (RRU_capabilities_t *)&rru_config_msg.msg[0];
+  LOG_I(PHY,"Sending Capabilities (len %d, num_bands %d,max_pdschReferenceSignalPower %d, max_rxgain %d, nb_tx %d, nb_rx %d)\n",
+        (int)rru_config_msg.len,ru->num_bands,ru->max_pdschReferenceSignalPower,ru->max_rxgain,ru->nb_tx,ru->nb_rx);
+
+  switch (ru->function) {
+    case NGFI_RRU_IF4p5:
+      cap->FH_fmt                                   = OAI_IF4p5_only;
+      break;
+
+    case NGFI_RRU_IF5:
+      cap->FH_fmt                                   = OAI_IF5_only;
+      break;
+
+    case MBP_RRU_IF5:
+      cap->FH_fmt                                   = MBP_IF5;
+      break;
+
+    default:
+      AssertFatal(1==0,"RU_function is unknown %d\n",RC.ru[0]->function);
+      break;
+  }
+
+  cap->num_bands                                  = ru->num_bands;
+
+  for (i=0; i<ru->num_bands; i++) {
+    LOG_I(PHY,"Band %d: nb_rx %d nb_tx %d pdschReferenceSignalPower %d rxgain %d\n",
+          ru->band[i],ru->nb_rx,ru->nb_tx,ru->max_pdschReferenceSignalPower,ru->max_rxgain);
+    cap->band_list[i]                             = ru->band[i];
+    cap->nb_rx[i]                                 = ru->nb_rx;
+    cap->nb_tx[i]                                 = ru->nb_tx;
+    cap->max_pdschReferenceSignalPower[i]         = ru->max_pdschReferenceSignalPower;
+    cap->max_rxgain[i]                            = ru->max_rxgain;
+  }
+
+  AssertFatal((ru->ifdevice.trx_ctlsend_func(&ru->ifdevice,&rru_config_msg,rru_config_msg.len)!=-1),
+              "RU %d failed send capabilities to RAU\n",ru->idx);
+  // wait for configuration
+  rru_config_msg.len  = sizeof(RRU_CONFIG_msg_t)-MAX_RRU_CONFIG_SIZE+sizeof(RRU_config_t);
+
+  while (configuration_received == 0) {
+    if ((len = ru->ifdevice.trx_ctlrecv_func(&ru->ifdevice,
+               &rru_config_msg,
+               rru_config_msg.len))<0) {
+      LOG_I(PHY,"Waiting for configuration from RAU\n");
+    } else {
+      LOG_I(PHY,"Configuration received from RAU  (num_bands %d,band0 %d,txfreq %u,rxfreq %u,att_tx %d,att_rx %d,N_RB_DL %d,N_RB_UL %d,3/4FS %d, prach_FO %d, prach_CI %d)\n",
+            ((RRU_config_t *)&rru_config_msg.msg[0])->num_bands,
+            ((RRU_config_t *)&rru_config_msg.msg[0])->band_list[0],
+            ((RRU_config_t *)&rru_config_msg.msg[0])->tx_freq[0],
+            ((RRU_config_t *)&rru_config_msg.msg[0])->rx_freq[0],
+            ((RRU_config_t *)&rru_config_msg.msg[0])->att_tx[0],
+            ((RRU_config_t *)&rru_config_msg.msg[0])->att_rx[0],
+            ((RRU_config_t *)&rru_config_msg.msg[0])->N_RB_DL[0],
+            ((RRU_config_t *)&rru_config_msg.msg[0])->N_RB_UL[0],
+            ((RRU_config_t *)&rru_config_msg.msg[0])->threequarter_fs[0],
+            ((RRU_config_t *)&rru_config_msg.msg[0])->prach_FreqOffset[0],
+            ((RRU_config_t *)&rru_config_msg.msg[0])->prach_ConfigIndex[0]);
+      configure_rru(ru->idx,
+                    (void *)&rru_config_msg.msg[0]);
+      configuration_received = 1;
+    }
+  }
+
+  return 0;
+}
+/*************************************************************/
+/* Southbound Fronthaul functions, RCC/RAU                   */
+
+// southbound IF5 fronthaul for 16-bit OAI format
+static inline void fh_if5_south_out(RU_t *ru) {
+  if (ru == RC.ru[0]) VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_TRX_TST, ru->proc.timestamp_tx&0xffffffff );
+
+  send_IF5(ru, ru->proc.timestamp_tx, ru->proc.tti_tx, &ru->seqno, IF5_RRH_GW_DL);
+}
+
+// southbound IF5 fronthaul for Mobipass packet format
+static inline void fh_if5_mobipass_south_out(RU_t *ru) {
+  if (ru == RC.ru[0]) VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_TRX_TST, ru->proc.timestamp_tx&0xffffffff );
+
+  send_IF5(ru, ru->proc.timestamp_tx, ru->proc.tti_tx, &ru->seqno, IF5_MOBIPASS);
+}
+
+// southbound IF4p5 fronthaul
+static inline void fh_if4p5_south_out(RU_t *ru) {
+  if (ru == RC.ru[0]) VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_TRX_TST, ru->proc.timestamp_tx&0xffffffff );
+
+  LOG_D(PHY,"Sending IF4p5 for frame %d subframe %d\n",ru->proc.frame_tx,ru->proc.tti_tx);
+
+  if (nr_slot_select(&ru->gNB_list[0]->gNB_config,ru->proc.tti_tx)!=SF_UL)
+    send_IF4p5(ru,ru->proc.frame_tx, ru->proc.tti_tx, IF4p5_PDLFFT);
+}
+
+/*************************************************************/
+/* Input Fronthaul from south RCC/RAU                        */
+
+// Synchronous if5 from south
+void fh_if5_south_in(RU_t *ru,int *frame, int *tti) {
+  NR_DL_FRAME_PARMS *fp = ru->nr_frame_parms;
+  RU_proc_t *proc = &ru->proc;
+  recv_IF5(ru, &proc->timestamp_rx, *tti, IF5_RRH_GW_UL);
+  proc->frame_rx    = (proc->timestamp_rx / (fp->samples_per_slot*20))&1023;
+  proc->tti_rx = (proc->timestamp_rx / fp->samples_per_slot)%20;
+
+  if (proc->first_rx == 0) {
+    if (proc->tti_rx != *tti) {
+      LOG_E(PHY,"Received Timestamp doesn't correspond to the time we think it is (proc->tti_rx %d, subframe %d)\n",proc->tti_rx,*tti);
+      exit_fun("Exiting");
+    }
+
+    if (proc->frame_rx != *frame) {
+      LOG_E(PHY,"Received Timestamp doesn't correspond to the time we think it is (proc->frame_rx %d frame %d)\n",proc->frame_rx,*frame);
+      exit_fun("Exiting");
+    }
+  } else {
+    proc->first_rx = 0;
+    *frame = proc->frame_rx;
+    *tti = proc->tti_rx;
+  }
+
+  VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_TRX_TS, proc->timestamp_rx&0xffffffff );
+}
+
+// Synchronous if4p5 from south
+void fh_if4p5_south_in(RU_t *ru,int *frame,int *slot) {
+  NR_DL_FRAME_PARMS *fp = ru->nr_frame_parms;
+  RU_proc_t *proc = &ru->proc;
+  int f,sl;
+  uint16_t packet_type;
+  uint32_t symbol_number=0;
+  uint32_t symbol_mask_full=0;
+
+  /*
+    if ((fp->frame_type == TDD) && (subframe_select(fp,*slot)==SF_S))
+      symbol_mask_full = (1<<fp->ul_symbols_in_S_subframe)-1;
+    else
+      symbol_mask_full = (1<<fp->symbols_per_slot)-1;
+
+    AssertFatal(proc->symbol_mask[*slot]==0,"rx_fh_if4p5: proc->symbol_mask[%d] = %x\n",*slot,proc->symbol_mask[*slot]);*/
+  do {   // Blocking, we need a timeout on this !!!!!!!!!!!!!!!!!!!!!!!
+    recv_IF4p5(ru, &f, &sl, &packet_type, &symbol_number);
+
+    if (packet_type == IF4p5_PULFFT) proc->symbol_mask[sl] = proc->symbol_mask[sl] | (1<<symbol_number);
+    else if (packet_type == IF4p5_PULTICK) {
+      if ((proc->first_rx==0) && (f!=*frame)) LOG_E(PHY,"rx_fh_if4p5: PULTICK received frame %d != expected %d\n",f,*frame);
+
+      if ((proc->first_rx==0) && (sl!=*slot)) LOG_E(PHY,"rx_fh_if4p5: PULTICK received subframe %d != expected %d (first_rx %d)\n",sl,*slot,proc->first_rx);
+
+      break;
+    } else if (packet_type == IF4p5_PRACH) {
+      // nothing in RU for RAU
+    }
+
+    LOG_D(PHY,"rx_fh_if4p5: subframe %d symbol mask %x\n",*slot,proc->symbol_mask[sl]);
+  } while(proc->symbol_mask[sl] != symbol_mask_full);
+
+  //caculate timestamp_rx, timestamp_tx based on frame and subframe
+  proc->tti_rx  = sl;
+  proc->frame_rx     = f;
+  proc->timestamp_rx = ((proc->frame_rx * fp->slots_per_frame)  + proc->tti_rx ) * fp->samples_per_slot ;
+  //  proc->timestamp_tx = proc->timestamp_rx +  (4*fp->samples_per_subframe);
+  proc->tti_tx  = (sl+sl_ahead)%fp->slots_per_frame;
+  proc->frame_tx     = (sl>(fp->slots_per_frame-sl_ahead)) ? (f+1)&1023 : f;
+
+  if (proc->first_rx == 0) {
+    if (proc->tti_rx != *slot) {
+      LOG_E(PHY,"Received Timestamp (IF4p5) doesn't correspond to the time we think it is (proc->tti_rx %d, subframe %d)\n",proc->tti_rx,*slot);
+      exit_fun("Exiting");
+    }
+
+    if (proc->frame_rx != *frame) {
+      LOG_E(PHY,"Received Timestamp (IF4p5) doesn't correspond to the time we think it is (proc->frame_rx %d frame %d)\n",proc->frame_rx,*frame);
+      exit_fun("Exiting");
+    }
+  } else {
+    proc->first_rx = 0;
+    *frame = proc->frame_rx;
+    *slot = proc->tti_rx;
+  }
+
+  if (ru == RC.ru[0]) {
+    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_RX0_RU, f );
+    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_TTI_NUMBER_RX0_RU,  sl);
+    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_TX0_RU, proc->frame_tx );
+    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_TTI_NUMBER_TX0_RU, proc->tti_tx );
+  }
+
+  proc->symbol_mask[proc->tti_rx] = 0;
+  VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_TRX_TS, proc->timestamp_rx&0xffffffff );
+  LOG_D(PHY,"RU %d: fh_if4p5_south_in sleeping ...\n",ru->idx);
+}
+
+// asynchronous inbound if4p5 fronthaul from south
+void fh_if4p5_south_asynch_in(RU_t *ru,int *frame,int *slot) {
+  NR_DL_FRAME_PARMS *fp = ru->nr_frame_parms;
+  RU_proc_t *proc       = &ru->proc;
+  uint16_t packet_type;
+  uint32_t symbol_number,symbol_mask,prach_rx;
+  //  uint32_t got_prach_info=0;
+  symbol_number = 0;
+  symbol_mask   = (1<<(fp->symbols_per_slot))-1;
+  prach_rx      = 0;
+
+  do {   // Blocking, we need a timeout on this !!!!!!!!!!!!!!!!!!!!!!!
+    recv_IF4p5(ru, &proc->frame_rx, &proc->tti_rx, &packet_type, &symbol_number);
+
+    // grab first prach information for this new subframe
+    /*if (got_prach_info==0) {
+      prach_rx       = is_prach_subframe(fp, proc->frame_rx, proc->tti_rx);
+      got_prach_info = 1;
+    }*/
+    if (proc->first_rx != 0) {
+      *frame = proc->frame_rx;
+      *slot = proc->tti_rx;
+      proc->first_rx = 0;
+    } else {
+      if (proc->frame_rx != *frame) {
+        LOG_E(PHY,"frame_rx %d is not what we expect %d\n",proc->frame_rx,*frame);
+        exit_fun("Exiting");
+      }
+
+      if (proc->tti_rx != *slot) {
+        LOG_E(PHY,"tti_rx %d is not what we expect %d\n",proc->tti_rx,*slot);
+        exit_fun("Exiting");
+      }
+    }
+
+    if      (packet_type == IF4p5_PULFFT)       symbol_mask &= (~(1<<symbol_number));
+    else if (packet_type == IF4p5_PRACH)        prach_rx    &= (~0x1);
+  } while( (symbol_mask > 0) || (prach_rx >0));   // haven't received all PUSCH symbols and PRACH information
+}
+
+
+
+
+
+/*************************************************************/
+/* Input Fronthaul from North RRU                            */
+
+// RRU IF4p5 TX fronthaul receiver. Assumes an if_device on input and if or rf device on output
+// receives one subframe's worth of IF4p5 OFDM symbols and OFDM modulates
+void fh_if4p5_north_in(RU_t *ru,int *frame,int *slot) {
+  uint32_t symbol_number=0;
+  uint32_t symbol_mask, symbol_mask_full;
+  uint16_t packet_type;
+  /// **** incoming IF4p5 from remote RCC/RAU **** ///
+  symbol_number = 0;
+  symbol_mask = 0;
+  symbol_mask_full = (1<<(ru->nr_frame_parms->symbols_per_slot))-1;
+
+  do {
+    recv_IF4p5(ru, frame, slot, &packet_type, &symbol_number);
+    symbol_mask = symbol_mask | (1<<symbol_number);
+  } while (symbol_mask != symbol_mask_full);
+
+  // dump VCD output for first RU in list
+  if (ru == RC.ru[0]) {
+    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_TX0_RU, *frame );
+    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_TTI_NUMBER_TX0_RU, *slot );
+  }
+}
+
+void fh_if5_north_asynch_in(RU_t *ru,int *frame,int *slot) {
+  NR_DL_FRAME_PARMS *fp = ru->nr_frame_parms;
+  RU_proc_t *proc        = &ru->proc;
+  int tti_tx,frame_tx;
+  openair0_timestamp timestamp_tx;
+  recv_IF5(ru, &timestamp_tx, *slot, IF5_RRH_GW_DL);
+  //      printf("Received subframe %d (TS %llu) from RCC\n",tti_tx,timestamp_tx);
+  tti_tx = (timestamp_tx/fp->samples_per_slot)%fp->slots_per_frame;
+  frame_tx    = (timestamp_tx/(fp->samples_per_slot*fp->slots_per_frame))&1023;
+
+  if (proc->first_tx != 0) {
+    *slot = tti_tx;
+    *frame    = frame_tx;
+    proc->first_tx = 0;
+  } else {
+    AssertFatal(tti_tx == *slot,
+                "tti_tx %d is not what we expect %d\n",tti_tx,*slot);
+    AssertFatal(frame_tx == *frame,
+                "frame_tx %d is not what we expect %d\n",frame_tx,*frame);
+  }
+}
+
+void fh_if4p5_north_asynch_in(RU_t *ru,int *frame,int *slot) {
+  NR_DL_FRAME_PARMS *fp = ru->nr_frame_parms;
+  nfapi_nr_config_request_t *cfg = &ru->gNB_list[0]->gNB_config;
+  RU_proc_t *proc        = &ru->proc;
+  uint16_t packet_type;
+  uint32_t symbol_number,symbol_mask,symbol_mask_full=0;
+  int slot_tx,frame_tx;
+  LOG_D(PHY, "%s(ru:%p frame, subframe)\n", __FUNCTION__, ru);
+  symbol_number = 0;
+  symbol_mask = 0;
+
+  //  symbol_mask_full = ((subframe_select(fp,*slot) == SF_S) ? (1<<fp->dl_symbols_in_S_subframe) : (1<<fp->symbols_per_slot))-1;
+  do {
+    recv_IF4p5(ru, &frame_tx, &slot_tx, &packet_type, &symbol_number);
+
+    if ((nr_slot_select(cfg,slot_tx) == SF_DL) && (symbol_number == 0)) start_meas(&ru->rx_fhaul);
+
+    LOG_D(PHY,"subframe %d (%d): frame %d, subframe %d, symbol %d\n",
+          *slot,nr_slot_select(cfg,*slot),frame_tx,slot_tx,symbol_number);
+
+    if (proc->first_tx != 0) {
+      *frame         = frame_tx;
+      *slot          = slot_tx;
+      proc->first_tx = 0;
+      //symbol_mask_full = ((subframe_select(fp,*slot) == SF_S) ? (1<<fp->dl_symbols_in_S_subframe) : (1<<fp->symbols_per_slot))-1;
+    } else {
+      AssertFatal(frame_tx == *frame,
+                  "frame_tx %d is not what we expect %d\n",frame_tx,*frame);
+      AssertFatal(slot_tx == *slot,
+                  "slot_tx %d is not what we expect %d\n",slot_tx,*slot);
+    }
+
+    if (packet_type == IF4p5_PDLFFT) {
+      symbol_mask = symbol_mask | (1<<symbol_number);
+    } else AssertFatal(1==0,"Illegal IF4p5 packet type (should only be IF4p5_PDLFFT%d\n",packet_type);
+  } while (symbol_mask != symbol_mask_full);
+
+  if (nr_slot_select(cfg,slot_tx) == SF_DL) stop_meas(&ru->rx_fhaul);
+
+  proc->tti_tx  = slot_tx;
+  proc->frame_tx     = frame_tx;
+
+  if ((frame_tx == 0)&&(slot_tx == 0)) proc->frame_tx_unwrap += 1024;
+
+  proc->timestamp_tx = ((((uint64_t)frame_tx + (uint64_t)proc->frame_tx_unwrap) * fp->slots_per_frame) + (uint64_t)slot_tx) * (uint64_t)fp->samples_per_slot;
+  LOG_D(PHY,"RU %d/%d TST %llu, frame %d, subframe %d\n",ru->idx,0,(long long unsigned int)proc->timestamp_tx,frame_tx,slot_tx);
+
+  // dump VCD output for first RU in list
+  if (ru == RC.ru[0]) {
+    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_TX0_RU, frame_tx );
+    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_TTI_NUMBER_TX0_RU, slot_tx );
+  }
+
+  if (ru->feptx_ofdm) ru->feptx_ofdm(ru);
+
+  if (ru->fh_south_out) ru->fh_south_out(ru);
+}
+
+void fh_if5_north_out(RU_t *ru) {
+  RU_proc_t *proc=&ru->proc;
+  uint8_t seqno=0;
+  /// **** send_IF5 of rxdata to BBU **** ///
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_SEND_IF5, 1 );
+  send_IF5(ru, proc->timestamp_rx, proc->tti_rx, &seqno, IF5_RRH_GW_UL);
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_SEND_IF5, 0 );
+}
+
+// RRU IF4p5 northbound interface (RX)
+void fh_if4p5_north_out(RU_t *ru) {
+  RU_proc_t *proc=&ru->proc;
+
+  //NR_DL_FRAME_PARMS *fp = ru->nr_frame_parms;
+  //const int subframe     = proc->tti_rx;
+  if (ru->idx==0) VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_TTI_NUMBER_RX0_RU, proc->tti_rx );
+
+  /*
+    if ((fp->frame_type == TDD) && (subframe_select(fp,subframe)!=SF_UL)) {
+      /// **** in TDD during DL send_IF4 of ULTICK to RCC **** ///
+      send_IF4p5(ru, proc->frame_rx, proc->tti_rx, IF4p5_PULTICK);
+      return;
+    }*/
+  start_meas(&ru->tx_fhaul);
+  send_IF4p5(ru, proc->frame_rx, proc->tti_rx, IF4p5_PULFFT);
+  stop_meas(&ru->tx_fhaul);
+}
+
+static void *emulatedRF_thread(void *param) {
+  RU_proc_t *proc = (RU_proc_t *) param;
+  int microsec = 500; // length of time to sleep, in miliseconds
+  struct timespec req = {0};
+  req.tv_sec = 0;
+  req.tv_nsec = (numerology>0)? ((microsec * 1000L)/numerology):(microsec * 1000L)*2;
+  wait_sync("emulatedRF_thread");
+
+  while(!oai_exit) {
+    nanosleep(&req, (struct timespec *)NULL);
+    pthread_mutex_lock(&proc->mutex_emulateRF);
+    ++proc->instance_cnt_emulateRF;
+    pthread_mutex_unlock(&proc->mutex_emulateRF);
+    pthread_cond_signal(&proc->cond_emulateRF);
+  }
+
+  return 0;
+}
+
+void rx_rf(RU_t *ru,int *frame,int *slot) {
+  RU_proc_t *proc = &ru->proc;
+  NR_DL_FRAME_PARMS *fp = ru->nr_frame_parms;
+  void *rxp[ru->nb_rx];
+  unsigned int rxs;
+  int i;
+  openair0_timestamp ts,old_ts;
+  AssertFatal(*slot<fp->slots_per_frame && *slot>=0, "slot %d is illegal (%d)\n",*slot,fp->slots_per_frame);
+
+  for (i=0; i<ru->nb_rx; i++)
+    rxp[i] = (void *)&ru->common.rxdata[i][*slot*fp->samples_per_slot];
+
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_READ, 1 );
+  old_ts = proc->timestamp_rx;
+  LOG_D(PHY,"Reading %d samples for slot %d (%p)\n",fp->samples_per_slot,*slot,rxp[0]);
+
+  if(emulate_rf) {
+    wait_on_condition(&proc->mutex_emulateRF,&proc->cond_emulateRF,&proc->instance_cnt_emulateRF,"emulatedRF_thread");
+    release_thread(&proc->mutex_emulateRF,&proc->instance_cnt_emulateRF,"emulatedRF_thread");
+    rxs = fp->samples_per_slot;
+    ts = old_ts + rxs;
+  } else {
+    rxs = ru->rfdevice.trx_read_func(&ru->rfdevice,
+                                     &ts,
+                                     rxp,
+                                     fp->samples_per_slot,
+                                     ru->nb_rx);
+  }
+
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_READ, 0 );
+  proc->timestamp_rx = ts-ru->ts_offset;
+
+  //AssertFatal(rxs == fp->samples_per_subframe,
+  //"rx_rf: Asked for %d samples, got %d from USRP\n",fp->samples_per_subframe,rxs);
+  if (rxs != fp->samples_per_slot) LOG_E(PHY, "rx_rf: Asked for %d samples, got %d from USRP\n",fp->samples_per_slot,rxs);
+
+  if (proc->first_rx == 1) {
+    ru->ts_offset = proc->timestamp_rx;
+    proc->timestamp_rx = 0;
+  } else {
+    if (proc->timestamp_rx - old_ts != fp->samples_per_slot) {
+      LOG_I(PHY,"rx_rf: rfdevice timing drift of %"PRId64" samples (ts_off %"PRId64")\n",proc->timestamp_rx - old_ts - fp->samples_per_slot,ru->ts_offset);
+      ru->ts_offset += (proc->timestamp_rx - old_ts - fp->samples_per_slot);
+      proc->timestamp_rx = ts-ru->ts_offset;
+    }
+  }
+
+  proc->frame_rx     = (proc->timestamp_rx / (fp->samples_per_slot*fp->slots_per_frame))&1023;
+  proc->tti_rx       = (proc->timestamp_rx / fp->samples_per_slot)%fp->slots_per_frame;
+  // synchronize first reception to frame 0 subframe 0
+  proc->timestamp_tx = proc->timestamp_rx+(sl_ahead*fp->samples_per_slot);
+  proc->tti_tx  = (proc->tti_rx+sl_ahead)%fp->slots_per_frame;
+  proc->frame_tx     = (proc->tti_rx>(fp->slots_per_frame-1-sl_ahead)) ? (proc->frame_rx+1)&1023 : proc->frame_rx;
+  LOG_I(PHY,"RU %d/%d TS %llu (off %d), frame %d, slot %d.%d / %d\n",
+        ru->idx,
+        0,
+        (unsigned long long int)proc->timestamp_rx,
+        (int)ru->ts_offset,proc->frame_rx,proc->tti_rx,proc->tti_tx,fp->slots_per_frame);
+
+  // dump VCD output for first RU in list
+  if (ru == RC.ru[0]) {
+    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_RX0_RU, proc->frame_rx );
+    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_TTI_NUMBER_RX0_RU, proc->tti_rx );
+  }
+
+  if (proc->first_rx == 0) {
+    if (proc->tti_rx != *slot) {
+      LOG_E(PHY,"Received Timestamp (%llu) doesn't correspond to the time we think it is (proc->tti_rx %d, subframe %d)\n",(long long unsigned int)proc->timestamp_rx,proc->tti_rx,*slot);
+      exit_fun("Exiting");
+    }
+
+    if (proc->frame_rx != *frame) {
+      LOG_E(PHY,"Received Timestamp (%llu) doesn't correspond to the time we think it is (proc->frame_rx %d frame %d)\n",(long long unsigned int)proc->timestamp_rx,proc->frame_rx,*frame);
+      exit_fun("Exiting");
+    }
+  } else {
+    proc->first_rx = 0;
+    *frame = proc->frame_rx;
+    *slot  = proc->tti_rx;
+  }
+
+  //printf("timestamp_rx %lu, frame %d(%d), subframe %d(%d)\n",ru->timestamp_rx,proc->frame_rx,frame,proc->tti_rx,subframe);
+  VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_TRX_TS, proc->timestamp_rx&0xffffffff );
+
+  if (rxs != fp->samples_per_slot) {
+    //exit_fun( "problem receiving samples" );
+    LOG_E(PHY, "problem receiving samples\n");
+  }
+}
+
+
+void tx_rf(RU_t *ru) {
+  RU_proc_t *proc = &ru->proc;
+  NR_DL_FRAME_PARMS *fp = ru->nr_frame_parms;
+  nfapi_nr_config_request_t *cfg = &ru->gNB_list[0]->gNB_config;
+  void *txp[ru->nb_tx];
+  unsigned int txs;
+  int i;
+  T(T_ENB_PHY_OUTPUT_SIGNAL, T_INT(0), T_INT(0), T_INT(proc->frame_tx), T_INT(proc->tti_tx),
+    T_INT(0), T_BUFFER(&ru->common.txdata[0][proc->tti_tx * fp->samples_per_slot], fp->samples_per_slot * 4));
+  nr_subframe_t SF_type     = nr_slot_select(cfg,proc->tti_tx%fp->slots_per_frame);
+  int sf_extension = 0;
+
+  if ((SF_type == SF_DL) ||
+      (SF_type == SF_S)) {
+    int siglen=fp->samples_per_slot,flags=1;
+    /*
+        if (SF_type == SF_S) {
+          siglen = fp->dl_symbols_in_S_subframe*(fp->ofdm_symbol_size+fp->nb_prefix_samples0);
+          flags=3; // end of burst
+        }
+        if ((fp->frame_type == TDD) &&
+      (SF_type == SF_DL)&&
+      (prevSF_type == SF_UL) &&
+      (nextSF_type == SF_DL)) {
+          flags = 2; // start of burst
+          sf_extension = ru->N_TA_offset<<1;
+        }
+
+        if ((cfg->subframe_config.duplex_mode == TDD) &&
+      (SF_type == SF_DL)&&
+      (prevSF_type == SF_UL) &&
+      (nextSF_type == SF_UL)) {
+          flags = 4; // start of burst and end of burst (only one DL SF between two UL)
+          sf_extension = ru->N_TA_offset<<1;
+        } */
+    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_TX0_RU, proc->frame_tx );
+    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_TTI_NUMBER_TX0_RU, proc->tti_tx );
+
+    for (i=0; i<ru->nb_tx; i++)
+      txp[i] = (void *)&ru->common.txdata[i][(proc->tti_tx*fp->samples_per_slot)-sf_extension];
+
+    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_TRX_TST, (proc->timestamp_tx-ru->openair0_cfg.tx_sample_advance)&0xffffffff );
+    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE, 1 );
+    // prepare tx buffer pointers
+    txs = ru->rfdevice.trx_write_func(&ru->rfdevice,
+                                      proc->timestamp_tx+ru->ts_offset-ru->openair0_cfg.tx_sample_advance-sf_extension,
+                                      txp,
+                                      siglen+sf_extension,
+                                      ru->nb_tx,
+                                      flags);
+    LOG_D(PHY,"[TXPATH] RU %d tx_rf, writing to TS %llu, frame %d, unwrapped_frame %d, subframe %d\n",ru->idx,
+          (long long unsigned int)proc->timestamp_tx,proc->frame_tx,proc->frame_tx_unwrap,proc->tti_tx);
+    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE, 0 );
+    AssertFatal(txs ==  siglen+sf_extension,"TX : Timeout (sent %d/%d)\n",txs, siglen);
+  }
+}
+
+
+/*!
+ * \brief The Asynchronous RX/TX FH thread of RAU/RCC/gNB/RRU.
+ * This handles the RX FH for an asynchronous RRU/UE
+ * \param param is a \ref gNB_L1_proc_t structure which contains the info what to process.
+ * \returns a pointer to an int. The storage is not on the heap and must not be freed.
+ */
+static void *ru_thread_asynch_rxtx( void *param ) {
+  static int ru_thread_asynch_rxtx_status;
+  RU_t *ru         = (RU_t *)param;
+  RU_proc_t *proc  = &ru->proc;
+  int subframe=0, frame=0;
+  // wait for top-level synchronization and do one acquisition to get timestamp for setting frame/subframe
+  wait_sync("ru_thread_asynch_rxtx");
+  // wait for top-level synchronization and do one acquisition to get timestamp for setting frame/subframe
+  printf( "waiting for devices (ru_thread_asynch_rx)\n");
+  wait_on_condition(&proc->mutex_asynch_rxtx,&proc->cond_asynch_rxtx,&proc->instance_cnt_asynch_rxtx,"thread_asynch");
+  printf( "devices ok (ru_thread_asynch_rx)\n");
+
+  while (!oai_exit) {
+    if (oai_exit) break;
+
+    if (subframe==9) {
+      subframe=0;
+      frame++;
+      frame&=1023;
+    } else {
+      subframe++;
+    }
+
+    LOG_D(PHY,"ru_thread_asynch_rxtx: Waiting on incoming fronthaul\n");
+
+    // asynchronous receive from south (Mobipass)
+    if (ru->fh_south_asynch_in) ru->fh_south_asynch_in(ru,&frame,&subframe);
+    // asynchronous receive from north (RRU IF4/IF5)
+    else if (ru->fh_north_asynch_in) {
+      if (nr_slot_select(&ru->gNB_list[0]->gNB_config,subframe)!=SF_UL)
+        ru->fh_north_asynch_in(ru,&frame,&subframe);
+    } else AssertFatal(1==0,"Unknown function in ru_thread_asynch_rxtx\n");
+  }
+
+  ru_thread_asynch_rxtx_status=0;
+  return(&ru_thread_asynch_rxtx_status);
+}
+
+
+
+
+/*!
+ * \brief The prach receive thread of RU.
+ * \param param is a \ref RU_proc_t structure which contains the info what to process.
+ * \returns a pointer to an int. The storage is not on the heap and must not be freed.
+ */
+static void *ru_thread_prach( void *param ) {
+  static int ru_thread_prach_status;
+  RU_t *ru        = (RU_t *)param;
+  RU_proc_t *proc = (RU_proc_t *)&ru->proc;
+  // set default return value
+  ru_thread_prach_status = 0;
+
+  while (RC.ru_mask>0) {
+    usleep(1e6);
+    LOG_I(PHY,"%s() RACH waiting for RU to be configured\n", __FUNCTION__);
+  }
+
+  LOG_I(PHY,"%s() RU configured - RACH processing thread running\n", __FUNCTION__);
+
+  while (!oai_exit) {
+    if (oai_exit) break;
+
+    if (wait_on_condition(&proc->mutex_prach,&proc->cond_prach,&proc->instance_cnt_prach,"ru_prach_thread") < 0) break;
+
+    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_RU_PRACH_RX, 1 );
+
+    /*if (ru->gNB_list[0]){
+      prach_procedures(
+        ru->gNB_list[0]
+    #if (RRC_VERSION >= MAKE_VERSION(14, 0, 0))
+        ,0
+    #endif
+        );
+    }
+    else {
+       rx_prach(NULL,
+            ru,
+          NULL,
+                NULL,
+                NULL,
+                proc->frame_prach,
+                0
+    #if (RRC_VERSION >= MAKE_VERSION(14, 0, 0))
+          ,0
+    #endif
+          );
+    }
+    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_RU_PRACH_RX, 0 ); */
+    if (release_thread(&proc->mutex_prach,&proc->instance_cnt_prach,"ru_prach_thread") < 0) break;
+  }
+
+  LOG_I(PHY, "Exiting RU thread PRACH\n");
+  ru_thread_prach_status = 0;
+  return &ru_thread_prach_status;
+}
+
+
+int wakeup_synch(RU_t *ru) {
+  struct timespec wait;
+  wait.tv_sec=0;
+  wait.tv_nsec=5000000L;
+
+  // wake up synch thread
+  // lock the synch mutex and make sure the thread is ready
+  if (pthread_mutex_timedlock(&ru->proc.mutex_synch,&wait) != 0) {
+    LOG_E( PHY, "[RU] ERROR pthread_mutex_lock for RU synch thread (IC %d)\n", ru->proc.instance_cnt_synch );
+    exit_fun( "error locking mutex_synch" );
+    return(-1);
+  }
+
+  ++ru->proc.instance_cnt_synch;
+
+  // the thread can now be woken up
+  if (pthread_cond_signal(&ru->proc.cond_synch) != 0) {
+    LOG_E( PHY, "[RU] ERROR pthread_cond_signal for RU synch thread\n");
+    exit_fun( "ERROR pthread_cond_signal" );
+    return(-1);
+  }
+
+  pthread_mutex_unlock( &ru->proc.mutex_synch );
+  return(0);
+}
+
+void do_ru_synch(RU_t *ru) {
+  NR_DL_FRAME_PARMS *fp  = ru->nr_frame_parms;
+  RU_proc_t *proc         = &ru->proc;
+  int i;
+  void *rxp[2],*rxp2[2];
+  int32_t dummy_rx[ru->nb_rx][fp->samples_per_subframe] __attribute__((aligned(32)));
+  int rxs;
+  int ic;
+
+  // initialize the synchronization buffer to the common_vars.rxdata
+  for (int i=0; i<ru->nb_rx; i++)
+    rxp[i] = &ru->common.rxdata[i][0];
+
+  double temp_freq1 = ru->rfdevice.openair0_cfg->rx_freq[0];
+  double temp_freq2 = ru->rfdevice.openair0_cfg->tx_freq[0];
+
+  for (i=0; i<4; i++) {
+    ru->rfdevice.openair0_cfg->rx_freq[i] = ru->rfdevice.openair0_cfg->tx_freq[i];
+    ru->rfdevice.openair0_cfg->tx_freq[i] = temp_freq1;
+  }
+
+  ru->rfdevice.trx_set_freq_func(&ru->rfdevice,ru->rfdevice.openair0_cfg,0);
+
+  while ((ru->in_synch ==0)&&(!oai_exit)) {
+    // read in frame
+    rxs = ru->rfdevice.trx_read_func(&ru->rfdevice,
+                                     &(proc->timestamp_rx),
+                                     rxp,
+                                     fp->samples_per_subframe*10,
+                                     ru->nb_rx);
+
+    if (rxs != fp->samples_per_subframe*10) LOG_E(PHY,"requested %d samples, got %d\n",fp->samples_per_subframe*10,rxs);
+
+    // wakeup synchronization processing thread
+    wakeup_synch(ru);
+    ic=0;
+
+    while ((ic>=0)&&(!oai_exit)) {
+      // continuously read in frames, 1ms at a time,
+      // until we are done with the synchronization procedure
+      for (i=0; i<ru->nb_rx; i++)
+        rxp2[i] = (void *)&dummy_rx[i][0];
+
+      for (i=0; i<10; i++)
+        rxs = ru->rfdevice.trx_read_func(&ru->rfdevice,
+                                         &(proc->timestamp_rx),
+                                         rxp2,
+                                         fp->samples_per_subframe,
+                                         ru->nb_rx);
+
+      pthread_mutex_lock(&ru->proc.mutex_synch);
+      ic = ru->proc.instance_cnt_synch;
+      pthread_mutex_unlock(&ru->proc.mutex_synch);
+    } // ic>=0
+  } // in_synch==0
+
+  // read in rx_offset samples
+  LOG_I(PHY,"Resynchronizing by %d samples\n",ru->rx_offset);
+  rxs = ru->rfdevice.trx_read_func(&ru->rfdevice,
+                                   &(proc->timestamp_rx),
+                                   rxp,
+                                   ru->rx_offset,
+                                   ru->nb_rx);
+
+  for (i=0; i<4; i++) {
+    ru->rfdevice.openair0_cfg->rx_freq[i] = temp_freq1;
+    ru->rfdevice.openair0_cfg->tx_freq[i] = temp_freq2;
+  }
+
+  ru->rfdevice.trx_set_freq_func(&ru->rfdevice,ru->rfdevice.openair0_cfg,0);
+}
+
+
+
+void wakeup_gNB_L1s(RU_t *ru) {
+  int i;
+  PHY_VARS_gNB **gNB_list = ru->gNB_list;
+  LOG_D(PHY,"wakeup_gNB_L1s (num %d) for RU %d ru->gNB_top:%p\n",ru->num_gNB,ru->idx, ru->gNB_top);
+
+  if (ru->num_gNB==1 && ru->gNB_top!=0 && get_thread_parallel_conf() == PARALLEL_SINGLE_THREAD) {
+    // call gNB function directly
+    char string[20];
+    sprintf(string,"Incoming RU %d",ru->idx);
+    LOG_D(PHY,"RU %d Call gNB_top\n",ru->idx);
+    ru->gNB_top(gNB_list[0],ru->proc.frame_rx,ru->proc.tti_rx,string,ru);
+  } else {
+    LOG_D(PHY,"ru->num_gNB:%d\n", ru->num_gNB);
+
+    for (i=0; i<ru->num_gNB; i++) {
+      LOG_D(PHY,"ru->wakeup_rxtx:%p\n", ru->nr_wakeup_rxtx);
+
+      if (ru->nr_wakeup_rxtx!=0 && ru->nr_wakeup_rxtx(gNB_list[i],ru) < 0) {
+        LOG_E(PHY,"could not wakeup gNB rxtx process for subframe %d\n", ru->proc.tti_rx);
+      }
+    }
+  }
+}
+
+static inline int wakeup_prach_ru(RU_t *ru) {
+  struct timespec wait;
+  wait.tv_sec=0;
+  wait.tv_nsec=5000000L;
+
+  if (pthread_mutex_timedlock(&ru->proc.mutex_prach,&wait) !=0) {
+    LOG_E( PHY, "[RU] ERROR pthread_mutex_lock for RU prach thread (IC %d)\n", ru->proc.instance_cnt_prach);
+    exit_fun( "error locking mutex_rxtx" );
+    return(-1);
+  }
+
+  if (ru->proc.instance_cnt_prach==-1) {
+    ++ru->proc.instance_cnt_prach;
+    ru->proc.frame_prach    = ru->proc.frame_rx;
+    ru->proc.subframe_prach = ru->proc.tti_rx;
+
+    // DJP - think prach_procedures() is looking at gNB frame_prach
+    if (ru->gNB_list[0]) {
+      ru->gNB_list[0]->proc.frame_prach = ru->proc.frame_rx;
+      ru->gNB_list[0]->proc.slot_prach = ru->proc.tti_rx;
+    }
+
+    LOG_I(PHY,"RU %d: waking up PRACH thread\n",ru->idx);
+    // the thread can now be woken up
+    AssertFatal(pthread_cond_signal(&ru->proc.cond_prach) == 0, "ERROR pthread_cond_signal for RU prach thread\n");
+  } else LOG_W(PHY,"RU prach thread busy, skipping\n");
+
+  pthread_mutex_unlock( &ru->proc.mutex_prach );
+  return(0);
+}
+
+// this is for RU with local RF unit
+void fill_rf_config(RU_t *ru, char *rf_config_file) {
+  int i;
+  NR_DL_FRAME_PARMS *fp   = ru->nr_frame_parms;
+  nfapi_nr_config_request_t *gNB_config = &ru->gNB_list[0]->gNB_config; //tmp index
+  openair0_config_t *cfg   = &ru->openair0_cfg;
+  int N_RB = gNB_config->rf_config.dl_carrier_bandwidth.value;
+  int mu = gNB_config->subframe_config.numerology_index_mu.value;
+
+  if (mu == NR_MU_0) { //or if LTE
+    if(N_RB == 100) {
+      if (fp->threequarter_fs) {
+        cfg->sample_rate=23.04e6;
+        cfg->samples_per_frame = 230400;
+        cfg->tx_bw = 10e6;
+        cfg->rx_bw = 10e6;
+      } else {
+        cfg->sample_rate=30.72e6;
+        cfg->samples_per_frame = 307200;
+        cfg->tx_bw = 10e6;
+        cfg->rx_bw = 10e6;
+      }
+    } else if(N_RB == 50) {
+      cfg->sample_rate=15.36e6;
+      cfg->samples_per_frame = 153600;
+      cfg->tx_bw = 5e6;
+      cfg->rx_bw = 5e6;
+    } else if (N_RB == 25) {
+      cfg->sample_rate=7.68e6;
+      cfg->samples_per_frame = 76800;
+      cfg->tx_bw = 2.5e6;
+      cfg->rx_bw = 2.5e6;
+    } else if (N_RB == 6) {
+      cfg->sample_rate=1.92e6;
+      cfg->samples_per_frame = 19200;
+      cfg->tx_bw = 1.5e6;
+      cfg->rx_bw = 1.5e6;
+    } else AssertFatal(1==0,"Unknown N_RB %d\n",N_RB);
+  } else if (mu == NR_MU_1) {
+    if(N_RB == 217) {
+      if (fp->threequarter_fs) {
+        cfg->sample_rate=92.16e6;
+        cfg->samples_per_frame = 921600;
+        cfg->tx_bw = 40e6;
+        cfg->rx_bw = 40e6;
+      } else {
+        cfg->sample_rate=122.88e6;
+        cfg->samples_per_frame = 1228800;
+        cfg->tx_bw = 40e6;
+        cfg->rx_bw = 40e6;
+      }
+    } else if(N_RB == 106) {
+      cfg->sample_rate=61.44e6;
+      cfg->samples_per_frame = 614400;
+      cfg->tx_bw = 20e6;
+      cfg->rx_bw = 20e6;
+    } else {
+      AssertFatal(0==1,"N_RB %d not yet supported for numerology %d\n",N_RB,mu);
+    }
+  } else {
+    AssertFatal(0 == 1,"Numerology %d not supported for the moment\n",mu);
+  }
+
+  if (gNB_config->subframe_config.duplex_mode.value==TDD)
+    cfg->duplex_mode = duplex_mode_TDD;
+  else //FDD
+    cfg->duplex_mode = duplex_mode_FDD;
+
+  cfg->Mod_id = 0;
+  cfg->num_rb_dl=N_RB;
+  cfg->tx_num_channels=ru->nb_tx;
+  cfg->rx_num_channels=ru->nb_rx;
+
+  for (i=0; i<ru->nb_tx; i++) {
+    cfg->tx_freq[i] = (double)fp->dl_CarrierFreq;
+    cfg->rx_freq[i] = (double)fp->ul_CarrierFreq;
+    cfg->tx_gain[i] = ru->att_tx;
+    cfg->rx_gain[i] = ru->max_rxgain-ru->att_rx;
+    cfg->configFilename = rf_config_file;
+    printf("channel %d, Setting tx_gain offset %f, rx_gain offset %f, tx_freq %f, rx_freq %f\n",
+           i, cfg->tx_gain[i],
+           cfg->rx_gain[i],
+           cfg->tx_freq[i],
+           cfg->rx_freq[i]);
+  }
+}
+
+/* this function maps the RU tx and rx buffers to the available rf chains.
+   Each rf chain is is addressed by the card number and the chain on the card. The
+   rf_map specifies for each antenna port, on which rf chain the mapping should start. Multiple
+   antennas are mapped to successive RF chains on the same card. */
+int setup_RU_buffers(RU_t *ru) {
+  int i,j;
+  int card,ant;
+  //uint16_t N_TA_offset = 0;
+  NR_DL_FRAME_PARMS *frame_parms;
+  //nfapi_nr_config_request_t *gNB_config = ru->gNB_list[0]->gNB_config; //tmp index
+
+  if (ru) {
+    frame_parms = ru->nr_frame_parms;
+    printf("setup_RU_buffers: frame_parms = %p\n",frame_parms);
+  } else {
+    printf("RU[%d] not initialized\n", ru->idx);
+    return(-1);
+  }
+
+  /*  if (frame_parms->frame_type == TDD) {
+      if      (frame_parms->N_RB_DL == 100) ru->N_TA_offset = 624;
+      else if (frame_parms->N_RB_DL == 50)  ru->N_TA_offset = 624/2;
+      else if (frame_parms->N_RB_DL == 25)  ru->N_TA_offset = 624/4;
+    } */
+  if (ru->openair0_cfg.mmapped_dma == 1) {
+    // replace RX signal buffers with mmaped HW versions
+    for (i=0; i<ru->nb_rx; i++) {
+      card = i/4;
+      ant = i%4;
+      printf("Mapping RU id %d, rx_ant %d, on card %d, chain %d\n",ru->idx,i,ru->rf_map.card+card, ru->rf_map.chain+ant);
+      free(ru->common.rxdata[i]);
+      ru->common.rxdata[i] = ru->openair0_cfg.rxbase[ru->rf_map.chain+ant];
+      printf("rxdata[%d] @ %p\n",i,ru->common.rxdata[i]);
+
+      for (j=0; j<16; j++) {
+        printf("rxbuffer %d: %x\n",j,ru->common.rxdata[i][j]);
+        ru->common.rxdata[i][j] = 16-j;
+      }
+    }
+
+    for (i=0; i<ru->nb_tx; i++) {
+      card = i/4;
+      ant = i%4;
+      printf("Mapping RU id %d, tx_ant %d, on card %d, chain %d\n",ru->idx,i,ru->rf_map.card+card, ru->rf_map.chain+ant);
+      free(ru->common.txdata[i]);
+      ru->common.txdata[i] = ru->openair0_cfg.txbase[ru->rf_map.chain+ant];
+      printf("txdata[%d] @ %p\n",i,ru->common.txdata[i]);
+
+      for (j=0; j<16; j++) {
+        printf("txbuffer %d: %x\n",j,ru->common.txdata[i][j]);
+        ru->common.txdata[i][j] = 16-j;
+      }
+    }
+  } else { // not memory-mapped DMA
+    //nothing to do, everything already allocated in lte_init
+  }
+
+  return(0);
+}
+
+static void *ru_stats_thread(void *param) {
+  RU_t               *ru      = (RU_t *)param;
+  wait_sync("ru_stats_thread");
+
+  while (!oai_exit) {
+    sleep(1);
+
+    if (opp_enabled == 1) {
+      if (ru->feprx) print_meas(&ru->ofdm_demod_stats,"feprx",NULL,NULL);
+
+      if (ru->feptx_ofdm) print_meas(&ru->ofdm_mod_stats,"feptx_ofdm",NULL,NULL);
+
+      if (ru->fh_north_asynch_in) print_meas(&ru->rx_fhaul,"rx_fhaul",NULL,NULL);
+
+      if (ru->fh_north_out) {
+        print_meas(&ru->tx_fhaul,"tx_fhaul",NULL,NULL);
+        print_meas(&ru->compression,"compression",NULL,NULL);
+        print_meas(&ru->transport,"transport",NULL,NULL);
+      }
+    }
+  }
+
+  return(NULL);
+}
+
+static void *ru_thread_tx( void *param ) {
+  RU_t *ru              = (RU_t *)param;
+  RU_proc_t *proc       = &ru->proc;
+  PHY_VARS_gNB *gNB;
+  gNB_L1_proc_t *gNB_proc;
+  gNB_L1_rxtx_proc_t *L1_proc;
+  NR_DL_FRAME_PARMS *fp      = ru->nr_frame_parms;
+  char               filename[40];
+  int                print_frame = 8;
+  int                i = 0;
+  cpu_set_t cpuset;
+  CPU_ZERO(&cpuset);
+  //CPU_SET(5, &cpuset);
+  //pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
+  //wait_sync("ru_thread_tx");
+  wait_on_condition(&proc->mutex_FH1,&proc->cond_FH1,&proc->instance_cnt_FH1,"ru_thread_tx");
+  printf( "ru_thread_tx ready\n");
+
+  while (!oai_exit) {
+    if (oai_exit) break;
+
+    LOG_I(PHY,"ru_thread_tx: Waiting for TX processing\n");
+    // wait until eNBs are finished subframe RX n and TX n+4
+    wait_on_condition(&proc->mutex_gNBs,&proc->cond_gNBs,&proc->instance_cnt_gNBs,"ru_thread_tx");
+
+    if (oai_exit) break;
+
+    //printf("~~~~~~~~~~~~~~~~start process for ru_thread_tx %d.%d\n", proc->frame_tx, proc->tti_tx);
+    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_TX0_RU, proc->frame_tx );
+    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_TTI_NUMBER_TX0_RU, proc->tti_tx );
+
+    // do TX front-end processing if needed (precoding and/or IDFTs)
+    if (ru->feptx_prec) ru->feptx_prec(ru);
+
+    // do OFDM if needed
+    if ((ru->fh_north_asynch_in == NULL) && (ru->feptx_ofdm)) ru->feptx_ofdm(ru);
+
+    if(!emulate_rf) {
+      // do outgoing fronthaul (south) if needed
+      if ((ru->fh_north_asynch_in == NULL) && (ru->fh_south_out)) ru->fh_south_out(ru);
+
+      if (ru->fh_north_out) ru->fh_north_out(ru);
+    } else {
+      if(proc->frame_tx == print_frame) {
+        for (i=0; i<ru->nb_tx; i++) {
+          sprintf(filename,"tx%ddataF_frame%d_sl%d.m", i, print_frame, proc->tti_tx);
+          LOG_M(filename,"txdataF_frame",&ru->common.txdataF_BF[i][0],fp->samples_per_subframe_wCP, 1, 1);
+
+          if(proc->tti_tx == 9) {
+            sprintf(filename,"tx%ddata_frame%d.m", i, print_frame);
+            LOG_M(filename,"txdata_frame",&ru->common.txdata[i][0],fp->samples_per_frame, 1, 1);
+            sprintf(filename,"tx%ddata_frame%d.dat", i, print_frame);
+            FILE *output_fd = fopen(filename,"w");
+
+            if (output_fd) {
+              fwrite(&ru->common.txdata[i][0],
+                     sizeof(int32_t),
+                     fp->samples_per_frame,
+                     output_fd);
+              fclose(output_fd);
+            } else {
+              LOG_E(PHY,"Cannot write to file %s\n",filename);
+            }
+          }//if(proc->tti_tx == 9)
+        }//for (i=0; i<ru->nb_tx; i++)
+      }//if(proc->frame_tx == print_frame)
+    }//else  emulate_rf
+
+    release_thread(&proc->mutex_gNBs,&proc->instance_cnt_gNBs,"ru_thread_tx");
+
+    for(i = 0; i<ru->num_gNB; i++) {
+      gNB       = ru->gNB_list[i];
+      gNB_proc  = &gNB->proc;
+      L1_proc   = (get_thread_parallel_conf() == PARALLEL_RU_L1_TRX_SPLIT)? &gNB_proc->L1_proc_tx : &gNB_proc->L1_proc;
+      pthread_mutex_lock(&gNB_proc->mutex_RU_tx);
+
+      for (int j=0; j<gNB->num_RU; j++) {
+        if (ru == gNB->RU_list[j]) {
+          if ((gNB_proc->RU_mask_tx&(1<<j)) > 0)
+            LOG_E(PHY,"eNB %d frame %d, subframe %d : previous information from RU tx %d (num_RU %d,mask %x) has not been served yet!\n",
+                  gNB->Mod_id,gNB_proc->frame_rx,gNB_proc->slot_rx,ru->idx,gNB->num_RU,gNB_proc->RU_mask_tx);
+
+          gNB_proc->RU_mask_tx |= (1<<j);
+        }
+      }
+
+      if (gNB_proc->RU_mask_tx != (1<<gNB->num_RU)-1) {  // not all RUs have provided their information so return
+        pthread_mutex_unlock(&gNB_proc->mutex_RU_tx);
+      } else { // all RUs TX are finished so send the ready signal to eNB processing
+        gNB_proc->RU_mask_tx = 0;
+        pthread_mutex_unlock(&gNB_proc->mutex_RU_tx);
+        pthread_mutex_lock( &L1_proc->mutex_RUs);
+        L1_proc->instance_cnt_RUs = 0;
+
+        // the thread can now be woken up
+        if (pthread_cond_signal(&L1_proc->cond_RUs) != 0) {
+          LOG_E( PHY, "[eNB] ERROR pthread_cond_signal for eNB TXnp4 thread\n");
+          exit_fun( "ERROR pthread_cond_signal" );
+        }
+
+        pthread_mutex_unlock( &L1_proc->mutex_RUs );
+      }
+    }
+  }
+
+  release_thread(&proc->mutex_FH1,&proc->instance_cnt_FH1,"ru_thread_tx");
+  return 0;
+}
+
+static void *ru_thread( void *param ) {
+  static int ru_thread_status;
+  RU_t               *ru      = (RU_t *)param;
+  RU_proc_t          *proc    = &ru->proc;
+  NR_DL_FRAME_PARMS *fp      = ru->nr_frame_parms;
+  int                ret;
+  int                slot = fp->slots_per_frame-1;
+  int                frame    =1023;
+  char               filename[40],threadname[40];
+  int                print_frame = 8;
+  int                i = 0;
+  // set default return value
+  ru_thread_status = 0;
+  // set default return value
+  sprintf(threadname,"ru_thread %d",ru->idx);
+  LOG_I(PHY,"Starting RU %d (%s,%s),\n",ru->idx,NB_functions[ru->function],NB_timing[ru->if_timing]);
+
+  if(emulate_rf) {
+    fill_rf_config(ru,ru->rf_config_file);
+    nr_init_frame_parms(&ru->gNB_list[0]->gNB_config, fp);
+    nr_dump_frame_parms(fp);
+    nr_phy_init_RU(ru);
+
+    if (setup_RU_buffers(ru)!=0) {
+      printf("Exiting, cannot initialize RU Buffers\n");
+      exit(-1);
+    }
+  } else {
+    // Start IF device if any
+    if (ru->start_if) {
+      LOG_I(PHY,"Starting IF interface for RU %d\n",ru->idx);
+      AssertFatal(ru->start_if(ru,NULL) == 0, "Could not start the IF device\n");
+
+      if (ru->if_south == LOCAL_RF) ret = connect_rau(ru);
+      else ret = attach_rru(ru);
+
+      AssertFatal(ret==0,"Cannot connect to remote radio\n");
+    }
+
+    if (ru->if_south == LOCAL_RF) { // configure RF parameters only
+      fill_rf_config(ru,ru->rf_config_file);
+      nr_init_frame_parms(&ru->gNB_list[0]->gNB_config, fp);
+      nr_dump_frame_parms(fp);
+      nr_phy_init_RU(ru);
+      ret = openair0_device_load(&ru->rfdevice,&ru->openair0_cfg);
+      AssertFatal(ret==0,"Cannot connect to local radio\n");
+    }
+
+    if (setup_RU_buffers(ru)!=0) {
+      printf("Exiting, cannot initialize RU Buffers\n");
+      exit(-1);
+    }
+  }
+
+  LOG_I(PHY, "Signaling main thread that RU %d is ready\n",ru->idx);
+  pthread_mutex_lock(&RC.ru_mutex);
+  RC.ru_mask &= ~(1<<ru->idx);
+  pthread_cond_signal(&RC.ru_cond);
+  pthread_mutex_unlock(&RC.ru_mutex);
+  wait_sync("ru_thread");
+
+  if(!emulate_rf) {
+    // Start RF device if any
+    if (ru->start_rf) {
+      if (ru->start_rf(ru) != 0)
+        LOG_E(HW,"Could not start the RF device\n");
+      else LOG_I(PHY,"RU %d rf device ready\n",ru->idx);
+    } else LOG_I(PHY,"RU %d no rf device\n",ru->idx);
+
+    // if an asnych_rxtx thread exists
+    // wakeup the thread because the devices are ready at this point
+
+    if ((ru->fh_south_asynch_in)||(ru->fh_north_asynch_in)) {
+      pthread_mutex_lock(&proc->mutex_asynch_rxtx);
+      proc->instance_cnt_asynch_rxtx=0;
+      pthread_mutex_unlock(&proc->mutex_asynch_rxtx);
+      pthread_cond_signal(&proc->cond_asynch_rxtx);
+    } else LOG_I(PHY,"RU %d no asynch_south interface\n",ru->idx);
+
+    // if this is a slave RRU, try to synchronize on the DL frequency
+    if ((ru->is_slave) && (ru->if_south == LOCAL_RF)) do_ru_synch(ru);
+  }
+
+  pthread_mutex_lock(&proc->mutex_FH1);
+  proc->instance_cnt_FH1 = 0;
+  pthread_mutex_unlock(&proc->mutex_FH1);
+  pthread_cond_signal(&proc->cond_FH1);
+
+  // This is a forever while loop, it loops over subframes which are scheduled by incoming samples from HW devices
+  while (!oai_exit) {
+    // these are local subframe/frame counters to check that we are in synch with the fronthaul timing.
+    // They are set on the first rx/tx in the underly FH routines.
+    if (slot==(fp->slots_per_frame-1)) {
+      slot=0;
+      frame++;
+      frame&=1023;
+    } else {
+      slot++;
+    }
+
+    // synchronization on input FH interface, acquire signals/data and block
+    if (ru->fh_south_in) ru->fh_south_in(ru,&frame,&slot);
+    else AssertFatal(1==0, "No fronthaul interface at south port");
+
+    LOG_D(PHY,"AFTER fh_south_in - SFN/SL:%d%d RU->proc[RX:%d.%d TX:%d.%d] RC.gNB[0][0]:[RX:%d%d TX(SFN):%d]\n",
+          frame,slot,
+          proc->frame_rx,proc->tti_rx,
+          proc->frame_tx,proc->tti_tx,
+          RC.gNB[0][0]->proc.frame_rx,RC.gNB[0][0]->proc.slot_rx,
+          RC.gNB[0][0]->proc.frame_tx);
+    /*
+          LOG_D(PHY,"RU thread (do_prach %d, is_prach_subframe %d), received frame %d, subframe %d\n",
+              ru->do_prach,
+              is_prach_subframe(fp, proc->frame_rx, proc->tti_rx),
+              proc->frame_rx,proc->tti_rx);
+
+        if ((ru->do_prach>0) && (is_prach_subframe(fp, proc->frame_rx, proc->tti_rx)==1)) {
+          wakeup_prach_ru(ru);
+        }*/
+
+    // adjust for timing offset between RU
+    //printf("~~~~~~~~~~~~~~~~~~~~~~~~~~%d.%d in ru_thread is in process\n", proc->frame_rx, proc->tti_rx);
+    if (ru->idx!=0) proc->frame_tx = (proc->frame_tx+proc->frame_offset)&1023;
+
+    // do RX front-end processing (frequency-shift, dft) if needed
+    if (ru->feprx) ru->feprx(ru);
+
+    // At this point, all information for subframe has been received on FH interface
+
+    // wakeup all gNB processes waiting for this RU
+    if (ru->num_gNB>0) wakeup_gNB_L1s(ru);
+
+    if(get_thread_parallel_conf() == PARALLEL_SINGLE_THREAD && ru->num_eNB==0) {
+      // do TX front-end processing if needed (precoding and/or IDFTs)
+      if (ru->feptx_prec) ru->feptx_prec(ru);
+
+      // do OFDM if needed
+      if ((ru->fh_north_asynch_in == NULL) && (ru->feptx_ofdm)) ru->feptx_ofdm(ru);
+
+      if(!emulate_rf) {
+        // do outgoing fronthaul (south) if needed
+        if ((ru->fh_north_asynch_in == NULL) && (ru->fh_south_out)) ru->fh_south_out(ru);
+
+        if (ru->fh_north_out) ru->fh_north_out(ru);
+      } else {
+        if(proc->frame_tx == print_frame) {
+          for (i=0; i<ru->nb_tx; i++) {
+            sprintf(filename,"tx%ddataF_frame%d_sl%d.m", i, print_frame, proc->tti_tx);
+            LOG_M(filename,"txdataF_frame",&ru->common.txdataF_BF[i][0],fp->samples_per_slot_wCP, 1, 1);
+
+            if(proc->tti_tx == 9) {
+              sprintf(filename,"tx%ddata_frame%d.m", i, print_frame);
+              LOG_M(filename,"txdata_frame",&ru->common.txdata[i][0],fp->samples_per_frame, 1, 1);
+              sprintf(filename,"tx%ddata_frame%d.dat", i, print_frame);
+              FILE *output_fd = fopen(filename,"w");
+
+              if (output_fd) {
+                fwrite(&ru->common.txdata[i][0],
+                       sizeof(int32_t),
+                       fp->samples_per_frame,
+                       output_fd);
+                fclose(output_fd);
+              } else {
+                LOG_E(PHY,"Cannot write to file %s\n",filename);
+              }
+            }//if(proc->tti_tx == 9)
+          }//for (i=0; i<ru->nb_tx; i++)
+        }//if(proc->frame_tx == print_frame)
+      }//else  emulate_rf
+
+      proc->emulate_rf_busy = 0;
+    }//if(get_thread_parallel_conf() == PARALLEL_SINGLE_THREAD)
+  }
+
+  printf( "Exiting ru_thread \n");
+
+  if (ru->stop_rf != NULL) {
+    if (ru->stop_rf(ru) != 0)
+      LOG_E(HW,"Could not stop the RF device\n");
+    else LOG_I(PHY,"RU %d rf device stopped\n",ru->idx);
+  }
+
+  ru_thread_status = 0;
+  return &ru_thread_status;
+}
+/*
+// This thread run the initial synchronization like a UE
+void *ru_thread_synch(void *arg) {
+
+  RU_t *ru = (RU_t*)arg;
+  NR_DL_FRAME_PARMS *fp=ru->nr_frame_parms;
+  int32_t sync_pos,sync_pos2;
+  uint32_t peak_val;
+  uint32_t sync_corr[307200] __attribute__((aligned(32)));
+  static int ru_thread_synch_status;
+
+
+
+  wait_sync("ru_thread_synch");
+
+  // initialize variables for PSS detection
+  lte_sync_time_init(ru->nr_frame_parms);
+
+  while (!oai_exit) {
+
+    // wait to be woken up
+    if (wait_on_condition(&ru->proc.mutex_synch,&ru->proc.cond_synch,&ru->proc.instance_cnt_synch,"ru_thread_synch")<0) break;
+
+    // if we're not in synch, then run initial synch
+    if (ru->in_synch == 0) {
+      // run intial synch like UE
+      LOG_I(PHY,"Running initial synchronization\n");
+
+      sync_pos = lte_sync_time_gNB(ru->common.rxdata,
+           fp,
+           fp->samples_per_subframe*5,
+           &peak_val,
+           sync_corr);
+      LOG_I(PHY,"RU synch: %d, val %d\n",sync_pos,peak_val);
+
+      if (sync_pos >= 0) {
+  if (sync_pos >= fp->nb_prefix_samples)
+    sync_pos2 = sync_pos - fp->nb_prefix_samples;
+  else
+    sync_pos2 = sync_pos + (fp->samples_per_subframe*10) - fp->nb_prefix_samples;
+
+  if (fp->frame_type == FDD) {
+
+    // PSS is hypothesized in last symbol of first slot in Frame
+    int sync_pos_slot = (fp->samples_per_subframe>>1) - fp->ofdm_symbol_size - fp->nb_prefix_samples;
+
+    if (sync_pos2 >= sync_pos_slot)
+      ru->rx_offset = sync_pos2 - sync_pos_slot;
+    else
+      ru->rx_offset = (fp->samples_per_subframe*10) + sync_pos2 - sync_pos_slot;
+  }
+  else {
+
+  }
+
+  LOG_I(PHY,"Estimated sync_pos %d, peak_val %d => timing offset %d\n",sync_pos,peak_val,ru->rx_offset);
+
+  if ((peak_val > 300000) && (sync_pos > 0)) {
+  //      if (sync_pos++ > 3) {
+  write_output("ru_sync.m","sync",(void*)&sync_corr[0],fp->samples_per_subframe*5,1,2);
+  write_output("ru_rx.m","rxs",(void*)ru->ru_time.rxdata[0][0],fp->samples_per_subframe*10,1,1);
+  exit(-1);
+  }
+
+  ru->in_synch=1;
+      }
+    }
+
+    if (release_thread(&ru->proc.mutex_synch,&ru->proc.instance_cnt_synch,"ru_synch_thread") < 0) break;
+  } // oai_exit
+
+  ru_thread_synch_status = 0;
+  return &ru_thread_synch_status;
+
+}
+*/
+
+int start_if(struct RU_t_s *ru,struct PHY_VARS_gNB_s *gNB) {
+  return(ru->ifdevice.trx_start_func(&ru->ifdevice));
+}
+
+int start_rf(RU_t *ru) {
+  return(ru->rfdevice.trx_start_func(&ru->rfdevice));
+}
+
+int stop_rf(RU_t *ru) {
+  ru->rfdevice.trx_end_func(&ru->rfdevice);
+  return 0;
+}
+
+extern void fep_full(RU_t *ru);
+extern void ru_fep_full_2thread(RU_t *ru);
+extern void nr_feptx_ofdm(RU_t *ru);
+extern void nr_feptx_ofdm_2thread(RU_t *ru);
+extern void feptx_prec(RU_t *ru);
+extern void init_fep_thread(RU_t *ru);
+extern void init_nr_feptx_thread(RU_t *ru);
+
+void init_RU_proc(RU_t *ru) {
+  int i=0;
+  RU_proc_t *proc;
+  char name[100];
+#ifndef OCP_FRAMEWORK
+  LOG_I(PHY,"Initializing RU proc %d (%s,%s),\n",ru->idx,NB_functions[ru->function],NB_timing[ru->if_timing]);
+#endif
+  proc = &ru->proc;
+  memset((void *)proc,0,sizeof(RU_proc_t));
+  proc->ru = ru;
+  proc->instance_cnt_prach       = -1;
+  proc->instance_cnt_synch       = -1;     ;
+  proc->instance_cnt_FH          = -1;
+  proc->instance_cnt_FH1         = -1;
+  proc->instance_cnt_gNBs        = -1;
+  proc->instance_cnt_asynch_rxtx = -1;
+  proc->instance_cnt_emulateRF   = -1;
+  proc->first_rx                 = 1;
+  proc->first_tx                 = 1;
+  proc->frame_offset             = 0;
+  proc->num_slaves               = 0;
+  proc->frame_tx_unwrap          = 0;
+
+  for (i=0; i<10; i++) proc->symbol_mask[i]=0;
+
+  pthread_mutex_init( &proc->mutex_prach, NULL);
+  pthread_mutex_init( &proc->mutex_asynch_rxtx, NULL);
+  pthread_mutex_init( &proc->mutex_synch,NULL);
+  pthread_mutex_init( &proc->mutex_FH,NULL);
+  pthread_mutex_init( &proc->mutex_FH1,NULL);
+  pthread_mutex_init( &proc->mutex_emulateRF,NULL);
+  pthread_mutex_init( &proc->mutex_gNBs, NULL);
+  pthread_cond_init( &proc->cond_prach, NULL);
+  pthread_cond_init( &proc->cond_FH, NULL);
+  pthread_cond_init( &proc->cond_FH1, NULL);
+  pthread_cond_init( &proc->cond_emulateRF, NULL);
+  pthread_cond_init( &proc->cond_asynch_rxtx, NULL);
+  pthread_cond_init( &proc->cond_synch,NULL);
+  pthread_cond_init( &proc->cond_gNBs, NULL);
+  threadCreate( &proc->pthread_FH, ru_thread, (void *)ru, "thread_FH", -1, OAI_PRIORITY_RT_MAX );
+
+  if (get_thread_parallel_conf() == PARALLEL_RU_L1_SPLIT || get_thread_parallel_conf() == PARALLEL_RU_L1_TRX_SPLIT)
+    threadCreate( &proc->pthread_FH1, ru_thread_tx, (void *)ru, "thread_FH1", -1, OAI_PRIORITY_RT );
+
+  if(emulate_rf)
+    threadCreate( &proc->pthread_emulateRF, emulatedRF_thread, (void *)proc, "emulateRF", -1, OAI_PRIORITY_RT );
+
+  if (ru->function == NGFI_RRU_IF4p5) {
+    threadCreate( &proc->pthread_prach, ru_thread_prach, (void *)ru, "RACH", -1, OAI_PRIORITY_RT );
+    ///tmp deactivation of synch thread
+    //    if (ru->is_slave == 1) pthread_create( &proc->pthread_synch, attr_synch, ru_thread_synch, (void*)ru);
+
+    if ((ru->if_timing == synch_to_other) ||
+        (ru->function == NGFI_RRU_IF5) ||
+        (ru->function == NGFI_RRU_IF4p5)) threadCreate( &proc->pthread_asynch_rxtx, ru_thread_asynch_rxtx, (void *)ru, "asynch_rxtx", -1, OAI_PRIORITY_RT );
+
+    snprintf( name, sizeof(name), "ru_thread_FH %d", ru->idx );
+    pthread_setname_np( proc->pthread_FH, name );
+  } else if (ru->function == gNodeB_3GPP && ru->if_south == LOCAL_RF) { // DJP - need something else to distinguish between monolithic and PNF
+    LOG_I(PHY,"%s() DJP - added creation of pthread_prach\n", __FUNCTION__);
+    threadCreate( &proc->pthread_prach, ru_thread_prach, (void *)ru,"RACH", -1, OAI_PRIORITY_RT );
+  }
+
+  if (get_nprocs()>=2) {
+    if (ru->feprx) init_fep_thread(ru);
+
+    if (ru->feptx_ofdm) nr_init_feptx_thread(ru);
+  }
+
+  if (opp_enabled == 1) threadCreate(&ru->ru_stats_thread,ru_stats_thread,(void *)ru, "emulateRF", -1, OAI_PRIORITY_RT_LOW);
+}
+
+void kill_RU_proc(int inst) {
+  RU_t *ru = RC.ru[inst];
+  RU_proc_t *proc = &ru->proc;
+  pthread_mutex_lock(&proc->mutex_FH);
+  proc->instance_cnt_FH = 0;
+  pthread_mutex_unlock(&proc->mutex_FH);
+  pthread_cond_signal(&proc->cond_FH);
+  pthread_mutex_lock(&proc->mutex_prach);
+  proc->instance_cnt_prach = 0;
+  pthread_mutex_unlock(&proc->mutex_prach);
+  pthread_cond_signal(&proc->cond_prach);
+  pthread_mutex_lock(&proc->mutex_synch);
+  proc->instance_cnt_synch = 0;
+  pthread_mutex_unlock(&proc->mutex_synch);
+  pthread_cond_signal(&proc->cond_synch);
+  pthread_mutex_lock(&proc->mutex_gNBs);
+  proc->instance_cnt_gNBs = 0;
+  pthread_mutex_unlock(&proc->mutex_gNBs);
+  pthread_cond_signal(&proc->cond_gNBs);
+  pthread_mutex_lock(&proc->mutex_asynch_rxtx);
+  proc->instance_cnt_asynch_rxtx = 0;
+  pthread_mutex_unlock(&proc->mutex_asynch_rxtx);
+  pthread_cond_signal(&proc->cond_asynch_rxtx);
+  LOG_D(PHY, "Joining pthread_FH\n");
+  pthread_join(proc->pthread_FH, NULL);
+
+  if (ru->function == NGFI_RRU_IF4p5) {
+    LOG_D(PHY, "Joining pthread_prach\n");
+    pthread_join(proc->pthread_prach, NULL);
+
+    if (ru->is_slave) {
+      LOG_D(PHY, "Joining pthread_\n");
+      pthread_join(proc->pthread_synch, NULL);
+    }
+
+    if ((ru->if_timing == synch_to_other) ||
+        (ru->function == NGFI_RRU_IF5) ||
+        (ru->function == NGFI_RRU_IF4p5)) {
+      LOG_D(PHY, "Joining pthread_asynch_rxtx\n");
+      pthread_join(proc->pthread_asynch_rxtx, NULL);
+    }
+  }
+
+  if (get_nprocs() >= 2) {
+    if (ru->feprx) {
+      pthread_mutex_lock(&proc->mutex_fep);
+      proc->instance_cnt_fep = 0;
+      pthread_mutex_unlock(&proc->mutex_fep);
+      pthread_cond_signal(&proc->cond_fep);
+      LOG_D(PHY, "Joining pthread_fep\n");
+      pthread_join(proc->pthread_fep, NULL);
+      pthread_mutex_destroy(&proc->mutex_fep);
+      pthread_cond_destroy(&proc->cond_fep);
+    }
+
+    if (ru->feptx_ofdm) {
+      pthread_mutex_lock(&proc->mutex_feptx);
+      proc->instance_cnt_feptx = 0;
+      pthread_mutex_unlock(&proc->mutex_feptx);
+      pthread_cond_signal(&proc->cond_feptx);
+      LOG_D(PHY, "Joining pthread_feptx\n");
+      pthread_join(proc->pthread_feptx, NULL);
+      pthread_mutex_destroy(&proc->mutex_feptx);
+      pthread_cond_destroy(&proc->cond_feptx);
+    }
+  }
+
+  if (opp_enabled) {
+    LOG_D(PHY, "Joining ru_stats_thread\n");
+    pthread_join(ru->ru_stats_thread, NULL);
+  }
+
+  pthread_mutex_destroy(&proc->mutex_prach);
+  pthread_mutex_destroy(&proc->mutex_asynch_rxtx);
+  pthread_mutex_destroy(&proc->mutex_synch);
+  pthread_mutex_destroy(&proc->mutex_FH);
+  pthread_mutex_destroy(&proc->mutex_gNBs);
+  pthread_cond_destroy(&proc->cond_prach);
+  pthread_cond_destroy(&proc->cond_FH);
+  pthread_cond_destroy(&proc->cond_asynch_rxtx);
+  pthread_cond_destroy(&proc->cond_synch);
+  pthread_cond_destroy(&proc->cond_gNBs);
+}
+
+int check_capabilities(RU_t *ru,RRU_capabilities_t *cap) {
+  FH_fmt_options_t fmt = cap->FH_fmt;
+  int i;
+  int found_band=0;
+  LOG_I(PHY,"RRU %d, num_bands %d, looking for band %d\n",ru->idx,cap->num_bands,ru->nr_frame_parms->eutra_band);
+
+  for (i=0; i<cap->num_bands; i++) {
+    LOG_I(PHY,"band %d on RRU %d\n",cap->band_list[i],ru->idx);
+
+    if (ru->nr_frame_parms->eutra_band == cap->band_list[i]) {
+      found_band=1;
+      break;
+    }
+  }
+
+  if (found_band == 0) {
+    LOG_I(PHY,"Couldn't find target EUTRA band %d on RRU %d\n",ru->nr_frame_parms->eutra_band,ru->idx);
+    return(-1);
+  }
+
+  switch (ru->if_south) {
+    case LOCAL_RF:
+      AssertFatal(1==0, "This RU should not have a local RF, exiting\n");
+      return(0);
+      break;
+
+    case REMOTE_IF5:
+      if (fmt == OAI_IF5_only || fmt == OAI_IF5_and_IF4p5) return(0);
+
+      break;
+
+    case REMOTE_IF4p5:
+      if (fmt == OAI_IF4p5_only || fmt == OAI_IF5_and_IF4p5) return(0);
+
+      break;
+
+    case REMOTE_MBP_IF5:
+      if (fmt == MBP_IF5) return(0);
+
+      break;
+
+    default:
+      LOG_I(PHY,"No compatible Fronthaul interface found for RRU %d\n", ru->idx);
+      return(-1);
+  }
+
+  return(-1);
+}
+
+
+char rru_format_options[4][20] = {"OAI_IF5_only","OAI_IF4p5_only","OAI_IF5_and_IF4p5","MBP_IF5"};
+
+char rru_formats[3][20] = {"OAI_IF5","MBP_IF5","OAI_IF4p5"};
+char ru_if_formats[4][20] = {"LOCAL_RF","REMOTE_OAI_IF5","REMOTE_MBP_IF5","REMOTE_OAI_IF4p5"};
+
+void configure_ru(int idx,
+                  void *arg) {
+  RU_t               *ru           = RC.ru[idx];
+  RRU_config_t       *config       = (RRU_config_t *)arg;
+  RRU_capabilities_t *capabilities = (RRU_capabilities_t *)arg;
+  nfapi_nr_config_request_t *gNB_config = &ru->gNB_list[0]->gNB_config;
+  int ret;
+  LOG_I(PHY, "Received capabilities from RRU %d\n",idx);
+
+  if (capabilities->FH_fmt < MAX_FH_FMTs) LOG_I(PHY, "RU FH options %s\n",rru_format_options[capabilities->FH_fmt]);
+
+  AssertFatal((ret=check_capabilities(ru,capabilities)) == 0,
+              "Cannot configure RRU %d, check_capabilities returned %d\n", idx,ret);
+  // take antenna capabilities of RRU
+  ru->nb_tx                      = capabilities->nb_tx[0];
+  ru->nb_rx                      = capabilities->nb_rx[0];
+  // Pass configuration to RRU
+  LOG_I(PHY, "Using %s fronthaul (%d), band %d \n",ru_if_formats[ru->if_south],ru->if_south,ru->nr_frame_parms->eutra_band);
+  // wait for configuration
+  config->FH_fmt                 = ru->if_south;
+  config->num_bands              = 1;
+  config->band_list[0]           = ru->nr_frame_parms->eutra_band;
+  config->tx_freq[0]             = ru->nr_frame_parms->dl_CarrierFreq;
+  config->rx_freq[0]             = ru->nr_frame_parms->ul_CarrierFreq;
+  //config->tdd_config[0]          = ru->nr_frame_parms->tdd_config;
+  //config->tdd_config_S[0]        = ru->nr_frame_parms->tdd_config_S;
+  config->att_tx[0]              = ru->att_tx;
+  config->att_rx[0]              = ru->att_rx;
+  config->N_RB_DL[0]             = gNB_config->rf_config.dl_carrier_bandwidth.value;
+  config->N_RB_UL[0]             = gNB_config->rf_config.ul_carrier_bandwidth.value;
+  config->threequarter_fs[0]     = ru->nr_frame_parms->threequarter_fs;
+  /*  if (ru->if_south==REMOTE_IF4p5) {
+      config->prach_FreqOffset[0]  = ru->nr_frame_parms->prach_config_common.prach_ConfigInfo.prach_FreqOffset;
+      config->prach_ConfigIndex[0] = ru->nr_frame_parms->prach_config_common.prach_ConfigInfo.prach_ConfigIndex;
+      LOG_I(PHY,"REMOTE_IF4p5: prach_FrequOffset %d, prach_ConfigIndex %d\n",
+      config->prach_FreqOffset[0],config->prach_ConfigIndex[0]);*/
+  nr_init_frame_parms(&ru->gNB_list[0]->gNB_config, ru->nr_frame_parms);
+  nr_phy_init_RU(ru);
+}
+
+void configure_rru(int idx,
+                   void *arg) {
+  RRU_config_t *config = (RRU_config_t *)arg;
+  RU_t         *ru         = RC.ru[idx];
+  nfapi_nr_config_request_t *gNB_config = &ru->gNB_list[0]->gNB_config;
+  ru->nr_frame_parms->eutra_band                                               = config->band_list[0];
+  ru->nr_frame_parms->dl_CarrierFreq                                           = config->tx_freq[0];
+  ru->nr_frame_parms->ul_CarrierFreq                                           = config->rx_freq[0];
+
+  if (ru->nr_frame_parms->dl_CarrierFreq == ru->nr_frame_parms->ul_CarrierFreq) {
+    gNB_config->subframe_config.duplex_mode.value                         = TDD;
+    //ru->nr_frame_parms->tdd_config                                            = config->tdd_config[0];
+    //ru->nr_frame_parms->tdd_config_S                                          = config->tdd_config_S[0];
+  } else
+    gNB_config->subframe_config.duplex_mode.value                            = FDD;
+
+  ru->att_tx                                                               = config->att_tx[0];
+  ru->att_rx                                                               = config->att_rx[0];
+  gNB_config->rf_config.dl_carrier_bandwidth.value                         = config->N_RB_DL[0];
+  gNB_config->rf_config.ul_carrier_bandwidth.value                         = config->N_RB_UL[0];
+  ru->nr_frame_parms->threequarter_fs                                       = config->threequarter_fs[0];
+
+  //ru->nr_frame_parms->pdsch_config_common.referenceSignalPower                 = ru->max_pdschReferenceSignalPower-config->att_tx[0];
+  if (ru->function==NGFI_RRU_IF4p5) {
+    ru->nr_frame_parms->att_rx = ru->att_rx;
+    ru->nr_frame_parms->att_tx = ru->att_tx;
+    /*
+        LOG_I(PHY,"Setting ru->function to NGFI_RRU_IF4p5, prach_FrequOffset %d, prach_ConfigIndex %d, att (%d,%d)\n",
+        config->prach_FreqOffset[0],config->prach_ConfigIndex[0],ru->att_tx,ru->att_rx);
+        ru->nr_frame_parms->prach_config_common.prach_ConfigInfo.prach_FreqOffset  = config->prach_FreqOffset[0];
+        ru->nr_frame_parms->prach_config_common.prach_ConfigInfo.prach_ConfigIndex = config->prach_ConfigIndex[0]; */
+  }
+
+  fill_rf_config(ru,ru->rf_config_file);
+  nr_init_frame_parms(&ru->gNB_list[0]->gNB_config, ru->nr_frame_parms);
+  nr_phy_init_RU(ru);
+}
+
+/*
+void init_precoding_weights(PHY_VARS_gNB *gNB) {
+
+  int layer,ru_id,aa,re,ue,tb;
+  LTE_DL_FRAME_PARMS *fp=&gNB->frame_parms;
+  RU_t *ru;
+  LTE_gNB_DLSCH_t *dlsch;
+
+  // init precoding weigths
+  for (ue=0;ue<NUMBER_OF_UE_MAX;ue++) {
+    for (tb=0;tb<2;tb++) {
+      dlsch = gNB->dlsch[ue][tb];
+      for (layer=0; layer<4; layer++) {
+  int nb_tx=0;
+  for (ru_id=0;ru_id<RC.nb_RU;ru_id++) {
+    ru = RC.ru[ru_id];
+    nb_tx+=ru->nb_tx;
+  }
+  dlsch->ue_spec_bf_weights[layer] = (int32_t**)malloc16(nb_tx*sizeof(int32_t*));
+
+  for (aa=0; aa<nb_tx; aa++) {
+    dlsch->ue_spec_bf_weights[layer][aa] = (int32_t *)malloc16(fp->ofdm_symbol_size*sizeof(int32_t));
+    for (re=0;re<fp->ofdm_symbol_size; re++) {
+      dlsch->ue_spec_bf_weights[layer][aa][re] = 0x00007fff;
+    }
+  }
+      }
+    }
+  }
+}*/
+
+void set_function_spec_param(RU_t *ru) {
+  int ret;
+
+  switch (ru->if_south) {
+    case LOCAL_RF:   // this is an RU with integrated RF (RRU, gNB)
+      if (ru->function ==  NGFI_RRU_IF5) {                 // IF5 RRU
+        ru->do_prach              = 0;                      // no prach processing in RU
+        ru->fh_north_in           = NULL;                   // no shynchronous incoming fronthaul from north
+        ru->fh_north_out          = fh_if5_north_out;       // need only to do send_IF5  reception
+        ru->fh_south_out          = tx_rf;                  // send output to RF
+        ru->fh_north_asynch_in    = fh_if5_north_asynch_in; // TX packets come asynchronously
+        ru->feprx                 = NULL;                   // nothing (this is a time-domain signal)
+        ru->feptx_ofdm            = NULL;                   // nothing (this is a time-domain signal)
+        ru->feptx_prec            = NULL;                   // nothing (this is a time-domain signal)
+        ru->start_if              = start_if;               // need to start the if interface for if5
+        ru->ifdevice.host_type    = RRU_HOST;
+        ru->rfdevice.host_type    = RRU_HOST;
+        ru->ifdevice.eth_params   = &ru->eth_params;
+        reset_meas(&ru->rx_fhaul);
+        reset_meas(&ru->tx_fhaul);
+        reset_meas(&ru->compression);
+        reset_meas(&ru->transport);
+        ret = openair0_transport_load(&ru->ifdevice,&ru->openair0_cfg,&ru->eth_params);
+        printf("openair0_transport_init returns %d for ru_id %d\n", ret, ru->idx);
+
+        if (ret<0) {
+          printf("Exiting, cannot initialize transport protocol\n");
+          exit(-1);
+        }
+      } else if (ru->function == NGFI_RRU_IF4p5) {
+        ru->do_prach              = 1;                        // do part of prach processing in RU
+        ru->fh_north_in           = NULL;                     // no synchronous incoming fronthaul from north
+        ru->fh_north_out          = fh_if4p5_north_out;       // send_IF4p5 on reception
+        ru->fh_south_out          = tx_rf;                    // send output to RF
+        ru->fh_north_asynch_in    = fh_if4p5_north_asynch_in; // TX packets come asynchronously
+        ru->feprx                 = (get_nprocs()<=2) ? fep_full :ru_fep_full_2thread;                 // RX DFTs
+        ru->feptx_ofdm            = (get_nprocs()<=2) ? nr_feptx_ofdm : nr_feptx_ofdm_2thread;               // this is fep with idft only (no precoding in RRU)
+        ru->feptx_prec            = NULL;
+        ru->start_if              = start_if;                 // need to start the if interface for if4p5
+        ru->ifdevice.host_type    = RRU_HOST;
+        ru->rfdevice.host_type    = RRU_HOST;
+        ru->ifdevice.eth_params   = &ru->eth_params;
+        reset_meas(&ru->rx_fhaul);
+        reset_meas(&ru->tx_fhaul);
+        reset_meas(&ru->compression);
+        reset_meas(&ru->transport);
+        ret = openair0_transport_load(&ru->ifdevice,&ru->openair0_cfg,&ru->eth_params);
+        printf("openair0_transport_init returns %d for ru_id %d\n", ret, ru->idx);
+
+        if (ret<0) {
+          printf("Exiting, cannot initialize transport protocol\n");
+          exit(-1);
+        }
+
+        malloc_IF4p5_buffer(ru);
+      } else if (ru->function == gNodeB_3GPP) {
+        ru->do_prach             = 0;                       // no prach processing in RU
+        ru->feprx                = (get_nprocs()<=2) ? fep_full : ru_fep_full_2thread;                // RX DFTs
+        ru->feptx_ofdm           = (get_nprocs()<=2) ? nr_feptx_ofdm : nr_feptx_ofdm_2thread;              // this is fep with idft and precoding
+        ru->feptx_prec           = feptx_prec;              // this is fep with idft and precoding
+        ru->fh_north_in          = NULL;                    // no incoming fronthaul from north
+        ru->fh_north_out         = NULL;                    // no outgoing fronthaul to north
+        ru->start_if             = NULL;                    // no if interface
+        ru->rfdevice.host_type   = RAU_HOST;
+      }
+
+      ru->fh_south_in            = rx_rf;                               // local synchronous RF RX
+      ru->fh_south_out           = tx_rf;                               // local synchronous RF TX
+      ru->start_rf               = start_rf;                            // need to start the local RF interface
+      ru->stop_rf                = stop_rf;
+      printf("configuring ru_id %d (start_rf %p)\n", ru->idx, start_rf);
+      /*
+          if (ru->function == gNodeB_3GPP) { // configure RF parameters only for 3GPP eNodeB, we need to get them from RAU otherwise
+            fill_rf_config(ru,rf_config_file);
+            init_frame_parms(&ru->frame_parms,1);
+            nr_phy_init_RU(ru);
+          }
+
+          ret = openair0_device_load(&ru->rfdevice,&ru->openair0_cfg);
+          if (setup_RU_buffers(ru)!=0) {
+            printf("Exiting, cannot initialize RU Buffers\n");
+            exit(-1);
+          }*/
+      break;
+
+    case REMOTE_IF5: // the remote unit is IF5 RRU
+      ru->do_prach               = 0;
+      ru->feprx                  = (get_nprocs()<=2) ? fep_full : fep_full;                   // this is frequency-shift + DFTs
+      ru->feptx_prec             = feptx_prec;                 // need to do transmit Precoding + IDFTs
+      ru->feptx_ofdm             = (get_nprocs()<=2) ? nr_feptx_ofdm : nr_feptx_ofdm_2thread;                 // need to do transmit Precoding + IDFTs
+      ru->fh_south_in          = fh_if5_south_in;     // synchronous IF5 reception
+      ru->fh_south_out         = fh_if5_south_out;    // synchronous IF5 transmission
+      ru->fh_south_asynch_in   = NULL;                // no asynchronous UL
+      ru->start_rf               = NULL;                 // no local RF
+      ru->stop_rf                = NULL;
+      ru->start_if               = start_if;             // need to start if interface for IF5
+      ru->ifdevice.host_type     = RAU_HOST;
+      ru->ifdevice.eth_params    = &ru->eth_params;
+      ru->ifdevice.configure_rru = configure_ru;
+      ret = openair0_transport_load(&ru->ifdevice,&ru->openair0_cfg,&ru->eth_params);
+      printf("openair0_transport_init returns %d for ru_id %d\n", ret, ru->idx);
+
+      if (ret<0) {
+        printf("Exiting, cannot initialize transport protocol\n");
+        exit(-1);
+      }
+
+      break;
+
+    case REMOTE_IF4p5:
+      ru->do_prach               = 0;
+      ru->feprx                  = NULL;                // DFTs
+      ru->feptx_prec             = feptx_prec;          // Precoding operation
+      ru->feptx_ofdm             = NULL;                // no OFDM mod
+      ru->fh_south_in            = fh_if4p5_south_in;   // synchronous IF4p5 reception
+      ru->fh_south_out           = fh_if4p5_south_out;  // synchronous IF4p5 transmission
+      ru->fh_south_asynch_in     = (ru->if_timing == synch_to_other) ? fh_if4p5_south_in : NULL;                // asynchronous UL if synch_to_other
+      ru->fh_north_out           = NULL;
+      ru->fh_north_asynch_in     = NULL;
+      ru->start_rf               = NULL;                // no local RF
+      ru->stop_rf                = NULL;
+      ru->start_if               = start_if;            // need to start if interface for IF4p5
+      ru->ifdevice.host_type     = RAU_HOST;
+      ru->ifdevice.eth_params    = &ru->eth_params;
+      ru->ifdevice.configure_rru = configure_ru;
+      ret = openair0_transport_load(&ru->ifdevice, &ru->openair0_cfg, &ru->eth_params);
+      printf("openair0_transport_init returns %d for ru_id %d\n", ret, ru->idx);
+
+      if (ret<0) {
+        printf("Exiting, cannot initialize transport protocol\n");
+        exit(-1);
+      }
+
+      malloc_IF4p5_buffer(ru);
+      break;
+
+    default:
+      LOG_E(PHY,"RU with invalid or unknown southbound interface type %d\n",ru->if_south);
+      break;
+  } // switch on interface type
+}
+
+extern void RCconfig_RU(void);
+
+void init_RU(char *rf_config_file) {
+  int ru_id;
+  RU_t *ru;
+  PHY_VARS_gNB *gNB0= (PHY_VARS_gNB *)NULL;
+  NR_DL_FRAME_PARMS *fp = (NR_DL_FRAME_PARMS *)NULL;
+  int i;
+  int CC_id;
+  // create status mask
+  RC.ru_mask = 0;
+  pthread_mutex_init(&RC.ru_mutex,NULL);
+  pthread_cond_init(&RC.ru_cond,NULL);
+  // read in configuration file)
+  printf("configuring RU from file\n");
+  RCconfig_RU();
+  LOG_I(PHY,"number of L1 instances %d, number of RU %d, number of CPU cores %d\n",RC.nb_nr_L1_inst,RC.nb_RU,get_nprocs());
+
+  if (RC.nb_nr_CC != 0)
+    for (i=0; i<RC.nb_nr_L1_inst; i++)
+      for (CC_id=0; CC_id<RC.nb_nr_CC[i]; CC_id++) RC.gNB[i][CC_id]->num_RU=0;
+
+  LOG_D(PHY,"Process RUs RC.nb_RU:%d\n",RC.nb_RU);
+
+  for (ru_id=0; ru_id<RC.nb_RU; ru_id++) {
+    LOG_D(PHY,"Process RC.ru[%d]\n",ru_id);
+    ru               = RC.ru[ru_id];
+    ru->rf_config_file = rf_config_file;
+    ru->idx          = ru_id;
+    ru->ts_offset    = 0;
+    // use gNB_list[0] as a reference for RU frame parameters
+    // NOTE: multiple CC_id are not handled here yet!
+
+    if (ru->num_gNB > 0) {
+      LOG_D(PHY, "%s() RC.ru[%d].num_gNB:%d ru->gNB_list[0]:%p RC.gNB[0][0]:%p rf_config_file:%s\n", __FUNCTION__, ru_id, ru->num_gNB, ru->gNB_list[0], RC.gNB[0][0], ru->rf_config_file);
+
+      if (ru->gNB_list[0] == 0) {
+        LOG_E(PHY,"%s() DJP - ru->gNB_list ru->num_gNB are not initialized - so do it manually\n", __FUNCTION__);
+        ru->gNB_list[0] = RC.gNB[0][0];
+        ru->num_gNB=1;
+        //
+        // DJP - feptx_prec() / feptx_ofdm() parses the gNB_list (based on num_gNB) and copies the txdata_F to txdata in RU
+        //
+      } else {
+        LOG_E(PHY,"DJP - delete code above this %s:%d\n", __FILE__, __LINE__);
+      }
+    }
+
+    gNB0             = ru->gNB_list[0];
+    fp               = ru->nr_frame_parms;
+    LOG_D(PHY, "RU FUnction:%d ru->if_south:%d\n", ru->function, ru->if_south);
+
+    if (gNB0) {
+      if ((ru->function != NGFI_RRU_IF5) && (ru->function != NGFI_RRU_IF4p5))
+        AssertFatal(gNB0!=NULL,"gNB0 is null!\n");
+
+      if (gNB0) {
+        LOG_I(PHY,"Copying frame parms from gNB %d to ru %d\n",gNB0->Mod_id,ru->idx);
+        memcpy((void *)fp,(void *)&gNB0->frame_parms,sizeof(NR_DL_FRAME_PARMS));
+        memset((void *)ru->frame_parms, 0, sizeof(LTE_DL_FRAME_PARMS));
+        // attach all RU to all gNBs in its list/
+        LOG_D(PHY,"ru->num_gNB:%d gNB0->num_RU:%d\n", ru->num_gNB, gNB0->num_RU);
+
+        for (i=0; i<ru->num_gNB; i++) {
+          gNB0 = ru->gNB_list[i];
+          gNB0->RU_list[gNB0->num_RU++] = ru;
+        }
+      }
+    }
+
+    //    LOG_I(PHY,"Initializing RRU descriptor %d : (%s,%s,%d)\n",ru_id,ru_if_types[ru->if_south],gNB_timing[ru->if_timing],ru->function);
+    set_function_spec_param(ru);
+    LOG_I(PHY,"Starting ru_thread %d\n",ru_id);
+    init_RU_proc(ru);
+  } // for ru_id
+
+  //  sleep(1);
+  LOG_D(HW,"[nr-softmodem.c] RU threads created\n");
+}
+
+
+
+
+void stop_RU(int nb_ru) {
+  for (int inst = 0; inst < nb_ru; inst++) {
+    LOG_I(PHY, "Stopping RU %d processing threads\n", inst);
+    kill_RU_proc(inst);
+  }
+}
+
+
+/* --------------------------------------------------------*/
+/* from here function to use configuration module          */
+void RCconfig_RU(void) {
+  int               j                             = 0;
+  int               i                             = 0;
+  paramdef_t RUParams[] = RUPARAMS_DESC;
+  paramlist_def_t RUParamList = {CONFIG_STRING_RU_LIST,NULL,0};
+  config_getlist( &RUParamList,RUParams,sizeof(RUParams)/sizeof(paramdef_t), NULL);
+
+  if ( RUParamList.numelt > 0) {
+    RC.ru = (RU_t **)malloc(RC.nb_RU*sizeof(RU_t *));
+    RC.ru_mask=(1<<NB_RU) - 1;
+    printf("Set RU mask to %lx\n",RC.ru_mask);
+
+    for (j = 0; j < RC.nb_RU; j++) {
+      RC.ru[j]                                    = (RU_t *)malloc(sizeof(RU_t));
+      memset((void *)RC.ru[j],0,sizeof(RU_t));
+      RC.ru[j]->idx                                 = j;
+      RC.ru[j]->nr_frame_parms                      = (NR_DL_FRAME_PARMS *)malloc(sizeof(NR_DL_FRAME_PARMS));
+      RC.ru[j]->frame_parms                      = (LTE_DL_FRAME_PARMS *)malloc(sizeof(LTE_DL_FRAME_PARMS));
+      printf("Creating RC.ru[%d]:%p\n", j, RC.ru[j]);
+      RC.ru[j]->if_timing                           = synch_to_ext_device;
+
+      if (RC.nb_nr_L1_inst >0)
+        RC.ru[j]->num_gNB                           = RUParamList.paramarray[j][RU_ENB_LIST_IDX].numelt;
+      else
+        RC.ru[j]->num_gNB                           = 0;
+
+      for (i=0; i<RC.ru[j]->num_gNB; i++) RC.ru[j]->gNB_list[i] = RC.gNB[RUParamList.paramarray[j][RU_ENB_LIST_IDX].iptr[i]][0];
+
+      if (config_isparamset(RUParamList.paramarray[j], RU_SDR_ADDRS)) {
+        RC.ru[j]->openair0_cfg.sdr_addrs = strdup(*(RUParamList.paramarray[j][RU_SDR_ADDRS].strptr));
+      }
+
+      if (config_isparamset(RUParamList.paramarray[j], RU_SDR_CLK_SRC)) {
+        if (strcmp(*(RUParamList.paramarray[j][RU_SDR_CLK_SRC].strptr), "internal") == 0) {
+          RC.ru[j]->openair0_cfg.clock_source = internal;
+          LOG_D(PHY, "RU clock source set as internal\n");
+        } else if (strcmp(*(RUParamList.paramarray[j][RU_SDR_CLK_SRC].strptr), "external") == 0) {
+          RC.ru[j]->openair0_cfg.clock_source = external;
+          LOG_D(PHY, "RU clock source set as external\n");
+        } else if (strcmp(*(RUParamList.paramarray[j][RU_SDR_CLK_SRC].strptr), "gpsdo") == 0) {
+          RC.ru[j]->openair0_cfg.clock_source = gpsdo;
+          LOG_D(PHY, "RU clock source set as gpsdo\n");
+        } else {
+          LOG_E(PHY, "Erroneous RU clock source in the provided configuration file: '%s'\n", *(RUParamList.paramarray[j][RU_SDR_CLK_SRC].strptr));
+        }
+      }
+
+      if (strcmp(*(RUParamList.paramarray[j][RU_LOCAL_RF_IDX].strptr), "yes") == 0) {
+        if ( !(config_isparamset(RUParamList.paramarray[j],RU_LOCAL_IF_NAME_IDX)) ) {
+          RC.ru[j]->if_south                        = LOCAL_RF;
+          RC.ru[j]->function                        = gNodeB_3GPP;
+          printf("Setting function for RU %d to gNodeB_3GPP\n",j);
+        } else {
+          RC.ru[j]->eth_params.local_if_name            = strdup(*(RUParamList.paramarray[j][RU_LOCAL_IF_NAME_IDX].strptr));
+          RC.ru[j]->eth_params.my_addr                  = strdup(*(RUParamList.paramarray[j][RU_LOCAL_ADDRESS_IDX].strptr));
+          RC.ru[j]->eth_params.remote_addr              = strdup(*(RUParamList.paramarray[j][RU_REMOTE_ADDRESS_IDX].strptr));
+          RC.ru[j]->eth_params.my_portc                 = *(RUParamList.paramarray[j][RU_LOCAL_PORTC_IDX].uptr);
+          RC.ru[j]->eth_params.remote_portc             = *(RUParamList.paramarray[j][RU_REMOTE_PORTC_IDX].uptr);
+          RC.ru[j]->eth_params.my_portd                 = *(RUParamList.paramarray[j][RU_LOCAL_PORTD_IDX].uptr);
+          RC.ru[j]->eth_params.remote_portd             = *(RUParamList.paramarray[j][RU_REMOTE_PORTD_IDX].uptr);
+
+          if (strcmp(*(RUParamList.paramarray[j][RU_TRANSPORT_PREFERENCE_IDX].strptr), "udp") == 0) {
+            RC.ru[j]->if_south                        = LOCAL_RF;
+            RC.ru[j]->function                        = NGFI_RRU_IF5;
+            RC.ru[j]->eth_params.transp_preference    = ETH_UDP_MODE;
+            printf("Setting function for RU %d to NGFI_RRU_IF5 (udp)\n",j);
+          } else if (strcmp(*(RUParamList.paramarray[j][RU_TRANSPORT_PREFERENCE_IDX].strptr), "raw") == 0) {
+            RC.ru[j]->if_south                        = LOCAL_RF;
+            RC.ru[j]->function                        = NGFI_RRU_IF5;
+            RC.ru[j]->eth_params.transp_preference    = ETH_RAW_MODE;
+            printf("Setting function for RU %d to NGFI_RRU_IF5 (raw)\n",j);
+          } else if (strcmp(*(RUParamList.paramarray[j][RU_TRANSPORT_PREFERENCE_IDX].strptr), "udp_if4p5") == 0) {
+            RC.ru[j]->if_south                        = LOCAL_RF;
+            RC.ru[j]->function                        = NGFI_RRU_IF4p5;
+            RC.ru[j]->eth_params.transp_preference    = ETH_UDP_IF4p5_MODE;
+            printf("Setting function for RU %d to NGFI_RRU_IF4p5 (udp)\n",j);
+          } else if (strcmp(*(RUParamList.paramarray[j][RU_TRANSPORT_PREFERENCE_IDX].strptr), "raw_if4p5") == 0) {
+            RC.ru[j]->if_south                        = LOCAL_RF;
+            RC.ru[j]->function                        = NGFI_RRU_IF4p5;
+            RC.ru[j]->eth_params.transp_preference    = ETH_RAW_IF4p5_MODE;
+            printf("Setting function for RU %d to NGFI_RRU_IF4p5 (raw)\n",j);
+          }
+        }
+
+        RC.ru[j]->max_pdschReferenceSignalPower     = *(RUParamList.paramarray[j][RU_MAX_RS_EPRE_IDX].uptr);;
+        RC.ru[j]->max_rxgain                        = *(RUParamList.paramarray[j][RU_MAX_RXGAIN_IDX].uptr);
+        RC.ru[j]->num_bands                         = RUParamList.paramarray[j][RU_BAND_LIST_IDX].numelt;
+
+        for (i=0; i<RC.ru[j]->num_bands; i++) RC.ru[j]->band[i] = RUParamList.paramarray[j][RU_BAND_LIST_IDX].iptr[i];
+      } //strcmp(local_rf, "yes") == 0
+      else {
+        printf("RU %d: Transport %s\n",j,*(RUParamList.paramarray[j][RU_TRANSPORT_PREFERENCE_IDX].strptr));
+        RC.ru[j]->eth_params.local_if_name        = strdup(*(RUParamList.paramarray[j][RU_LOCAL_IF_NAME_IDX].strptr));
+        RC.ru[j]->eth_params.my_addr          = strdup(*(RUParamList.paramarray[j][RU_LOCAL_ADDRESS_IDX].strptr));
+        RC.ru[j]->eth_params.remote_addr        = strdup(*(RUParamList.paramarray[j][RU_REMOTE_ADDRESS_IDX].strptr));
+        RC.ru[j]->eth_params.my_portc         = *(RUParamList.paramarray[j][RU_LOCAL_PORTC_IDX].uptr);
+        RC.ru[j]->eth_params.remote_portc       = *(RUParamList.paramarray[j][RU_REMOTE_PORTC_IDX].uptr);
+        RC.ru[j]->eth_params.my_portd         = *(RUParamList.paramarray[j][RU_LOCAL_PORTD_IDX].uptr);
+        RC.ru[j]->eth_params.remote_portd       = *(RUParamList.paramarray[j][RU_REMOTE_PORTD_IDX].uptr);
+
+        if (strcmp(*(RUParamList.paramarray[j][RU_TRANSPORT_PREFERENCE_IDX].strptr), "udp") == 0) {
+          RC.ru[j]->if_south                     = REMOTE_IF5;
+          RC.ru[j]->function                     = NGFI_RAU_IF5;
+          RC.ru[j]->eth_params.transp_preference = ETH_UDP_MODE;
+        } else if (strcmp(*(RUParamList.paramarray[j][RU_TRANSPORT_PREFERENCE_IDX].strptr), "raw") == 0) {
+          RC.ru[j]->if_south                     = REMOTE_IF5;
+          RC.ru[j]->function                     = NGFI_RAU_IF5;
+          RC.ru[j]->eth_params.transp_preference = ETH_RAW_MODE;
+        } else if (strcmp(*(RUParamList.paramarray[j][RU_TRANSPORT_PREFERENCE_IDX].strptr), "udp_if4p5") == 0) {
+          RC.ru[j]->if_south                     = REMOTE_IF4p5;
+          RC.ru[j]->function                     = NGFI_RAU_IF4p5;
+          RC.ru[j]->eth_params.transp_preference = ETH_UDP_IF4p5_MODE;
+        } else if (strcmp(*(RUParamList.paramarray[j][RU_TRANSPORT_PREFERENCE_IDX].strptr), "raw_if4p5") == 0) {
+          RC.ru[j]->if_south                     = REMOTE_IF4p5;
+          RC.ru[j]->function                     = NGFI_RAU_IF4p5;
+          RC.ru[j]->eth_params.transp_preference = ETH_RAW_IF4p5_MODE;
+        } else if (strcmp(*(RUParamList.paramarray[j][RU_TRANSPORT_PREFERENCE_IDX].strptr), "raw_if5_mobipass") == 0) {
+          RC.ru[j]->if_south                     = REMOTE_IF5;
+          RC.ru[j]->function                     = NGFI_RAU_IF5;
+          RC.ru[j]->if_timing                    = synch_to_other;
+          RC.ru[j]->eth_params.transp_preference = ETH_RAW_IF5_MOBIPASS;
+        }
+      }  /* strcmp(local_rf, "yes") != 0 */
+
+      RC.ru[j]->nb_tx                             = *(RUParamList.paramarray[j][RU_NB_TX_IDX].uptr);
+      RC.ru[j]->nb_rx                             = *(RUParamList.paramarray[j][RU_NB_RX_IDX].uptr);
+      RC.ru[j]->att_tx                            = *(RUParamList.paramarray[j][RU_ATT_TX_IDX].uptr);
+      RC.ru[j]->att_rx                            = *(RUParamList.paramarray[j][RU_ATT_RX_IDX].uptr);
+    }// j=0..num_rus
+  } else {
+    RC.nb_RU = 0;
+  } // setting != NULL
+
+  return;
+}
diff --git a/executables/nr-softmodem.c b/executables/nr-softmodem.c
new file mode 100644
index 0000000000..3147284e99
--- /dev/null
+++ b/executables/nr-softmodem.c
@@ -0,0 +1,1237 @@
+/*
+ * 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
+ */
+
+
+#define _GNU_SOURCE             /* See feature_test_macros(7) */
+#include <sched.h>
+
+
+#include "T.h"
+
+#undef MALLOC //there are two conflicting definitions, so we better make sure we don't use it at all
+#include <common/utils/assertions.h>
+
+#include "msc.h"
+
+#include "PHY/types.h"
+#include "common/ran_context.h"
+
+#include "PHY/defs_gNB.h"
+#include "common/config/config_userapi.h"
+#include "common/utils/load_module_shlib.h"
+#undef MALLOC //there are two conflicting definitions, so we better make sure we don't use it at all
+//#undef FRAME_LENGTH_COMPLEX_SAMPLES //there are two conflicting definitions, so we better make sure we don't use it at all
+
+#include "../../ARCH/COMMON/common_lib.h"
+#include "../../ARCH/ETHERNET/USERSPACE/LIB/if_defs.h"
+
+//#undef FRAME_LENGTH_COMPLEX_SAMPLES //there are two conflicting definitions, so we better make sure we don't use it at all
+
+#include "PHY/phy_vars.h"
+#include "SCHED/sched_common_vars.h"
+#include "LAYER2/MAC/mac_vars.h"
+
+#include "LAYER2/MAC/mac.h"
+#include "LAYER2/MAC/mac_proto.h"
+#include "RRC/LTE/rrc_vars.h"
+#include "PHY_INTERFACE/phy_interface_vars.h"
+#include "gnb_config.h"
+
+#ifdef SMBV
+#include "PHY/TOOLS/smbv.h"
+unsigned short config_frames[4] = {2,9,11,13};
+#endif
+
+#include "common/utils/LOG/log.h"
+#include "common/utils/LOG/vcd_signal_dumper.h"
+
+#include "UTIL/OPT/opt.h"
+
+//#include "PHY/TOOLS/time_meas.h"
+
+#ifndef OPENAIR2
+  #include "UTIL/OTG/otg_vars.h"
+#endif
+
+#if defined(ENABLE_ITTI)
+  #include "intertask_interface.h"
+#endif
+
+#include "PHY/INIT/phy_init.h"
+
+#include "system.h"
+#include <openair2/GNB_APP/gnb_app.h>
+
+#ifdef XFORMS
+  #include "PHY/TOOLS/nr_phy_scope.h"
+  #include "stats.h"
+#endif
+#include "nr-softmodem.h"
+#include "NB_IoT_interface.h"
+
+#ifdef XFORMS
+  // current status is that every UE has a DL scope for a SINGLE eNB (gnb_id=0)
+  // at eNB 0, an UL scope for every UE
+
+  FD_phy_scope_gnb *form_gnb[MAX_NUM_CCs][NUMBER_OF_UE_MAX];
+  FD_stats_form                  *form_stats=NULL,*form_stats_l2=NULL;
+  char title[255];
+  unsigned char                   scope_enb_num_ue = 2;
+  static pthread_t                forms_thread; //xforms
+
+#endif //XFORMS
+
+short nr_mod_table[NR_MOD_TABLE_SIZE_SHORT] = {0,0,16384,16384,-16384,-16384,16384,16384,16384,-16384,-16384,16384,-16384,-16384,7327,7327,7327,21981,21981,7327,21981,21981,7327,-7327,7327,-21981,21981,-7327,21981,-21981,-7327,7327,-7327,21981,-21981,7327,-21981,21981,-7327,-7327,-7327,-21981,-21981,-7327,-21981,-21981,10726,10726,10726,3576,3576,10726,3576,3576,10726,17876,10726,25027,3576,17876,3576,25027,17876,10726,17876,3576,25027,10726,25027,3576,17876,17876,17876,25027,25027,17876,25027,25027,10726,-10726,10726,-3576,3576,-10726,3576,-3576,10726,-17876,10726,-25027,3576,-17876,3576,-25027,17876,-10726,17876,-3576,25027,-10726,25027,-3576,17876,-17876,17876,-25027,25027,-17876,25027,-25027,-10726,10726,-10726,3576,-3576,10726,-3576,3576,-10726,17876,-10726,25027,-3576,17876,-3576,25027,-17876,10726,-17876,3576,-25027,10726,-25027,3576,-17876,17876,-17876,25027,-25027,17876,-25027,25027,-10726,-10726,-10726,-3576,-3576,-10726,-3576,-3576,-10726,-17876,-10726,-25027,-3576,-17876,-3576,-25027,-17876,-10726,-17876,-3576,-25027,-10726,-25027,-3576,-17876,-17876,-17876,-25027,-25027,-17876,-25027,-25027,8886,8886,8886,12439,12439,8886,12439,12439,8886,5332,8886,1778,12439,5332,12439,1778,5332,8886,5332,12439,1778,8886,1778,12439,5332,5332,5332,1778,1778,5332,1778,1778,8886,19547,8886,15993,12439,19547,12439,15993,8886,23101,8886,26655,12439,23101,12439,26655,5332,19547,5332,15993,1778,19547,1778,15993,5332,23101,5332,26655,1778,23101,1778,26655,19547,8886,19547,12439,15993,8886,15993,12439,19547,5332,19547,1778,15993,5332,15993,1778,23101,8886,23101,12439,26655,8886,26655,12439,23101,5332,23101,1778,26655,5332,26655,1778,19547,19547,19547,15993,15993,19547,15993,15993,19547,23101,19547,26655,15993,23101,15993,26655,23101,19547,23101,15993,26655,19547,26655,15993,23101,23101,23101,26655,26655,23101,26655,26655,8886,-8886,8886,-12439,12439,-8886,12439,-12439,8886,-5332,8886,-1778,12439,-5332,12439,-1778,5332,-8886,5332,-12439,1778,-8886,1778,-12439,5332,-5332,5332,-1778,1778,-5332,1778,-1778,8886,-19547,8886,-15993,12439,-19547,12439,-15993,8886,-23101,8886,-26655,12439,-23101,12439,-26655,5332,-19547,5332,-15993,1778,-19547,1778,-15993,5332,-23101,5332,-26655,1778,-23101,1778,-26655,19547,-8886,19547,-12439,15993,-8886,15993,-12439,19547,-5332,19547,-1778,15993,-5332,15993,-1778,23101,-8886,23101,-12439,26655,-8886,26655,-12439,23101,-5332,23101,-1778,26655,-5332,26655,-1778,19547,-19547,19547,-15993,15993,-19547,15993,-15993,19547,-23101,19547,-26655,15993,-23101,15993,-26655,23101,-19547,23101,-15993,26655,-19547,26655,-15993,23101,-23101,23101,-26655,26655,-23101,26655,-26655,-8886,8886,-8886,12439,-12439,8886,-12439,12439,-8886,5332,-8886,1778,-12439,5332,-12439,1778,-5332,8886,-5332,12439,-1778,8886,-1778,12439,-5332,5332,-5332,1778,-1778,5332,-1778,1778,-8886,19547,-8886,15993,-12439,19547,-12439,15993,-8886,23101,-8886,26655,-12439,23101,-12439,26655,-5332,19547,-5332,15993,-1778,19547,-1778,15993,-5332,23101,-5332,26655,-1778,23101,-1778,26655,-19547,8886,-19547,12439,-15993,8886,-15993,12439,-19547,5332,-19547,1778,-15993,5332,-15993,1778,-23101,8886,-23101,12439,-26655,8886,-26655,12439,-23101,5332,-23101,1778,-26655,5332,-26655,1778,-19547,19547,-19547,15993,-15993,19547,-15993,15993,-19547,23101,-19547,26655,-15993,23101,-15993,26655,-23101,19547,-23101,15993,-26655,19547,-26655,15993,-23101,23101,-23101,26655,-26655,23101,-26655,26655,-8886,-8886,-8886,-12439,-12439,-8886,-12439,-12439,-8886,-5332,-8886,-1778,-12439,-5332,-12439,-1778,-5332,-8886,-5332,-12439,-1778,-8886,-1778,-12439,-5332,-5332,-5332,-1778,-1778,-5332,-1778,-1778,-8886,-19547,-8886,-15993,-12439,-19547,-12439,-15993,-8886,-23101,-8886,-26655,-12439,-23101,-12439,-26655,-5332,-19547,-5332,-15993,-1778,-19547,-1778,-15993,-5332,-23101,-5332,-26655,-1778,-23101,-1778,-26655,-19547,-8886,-19547,-12439,-15993,-8886,-15993,-12439,-19547,-5332,-19547,-1778,-15993,-5332,-15993,-1778,-23101,-8886,-23101,-12439,-26655,-8886,-26655,-12439,-23101,-5332,-23101,-1778,-26655,-5332,-26655,-1778,-19547,-19547,-19547,-15993,-15993,-19547,-15993,-15993,-19547,-23101,-19547,-26655,-15993,-23101,-15993,-26655,-23101,-19547,-23101,-15993,-26655,-19547,-26655,-15993,-23101,-23101,-23101,-26655,-26655,-23101,-26655,-26655};
+
+
+pthread_cond_t nfapi_sync_cond;
+pthread_mutex_t nfapi_sync_mutex;
+int nfapi_sync_var=-1; //!< protected by mutex \ref nfapi_sync_mutex
+
+uint8_t nfapi_mode = 0; // Default to monolithic mode
+
+pthread_cond_t sync_cond;
+pthread_mutex_t sync_mutex;
+int sync_var=-1; //!< protected by mutex \ref sync_mutex.
+int config_sync_var=-1;
+
+#if defined(ENABLE_ITTI)
+  volatile int             start_gNB = 0;
+#endif
+volatile int             oai_exit = 0;
+
+static clock_source_t clock_source = internal;
+static int wait_for_sync = 0;
+
+unsigned int                    mmapped_dma=0;
+int                             single_thread_flag=1;
+
+static int8_t                     threequarter_fs=0;
+
+uint32_t                 downlink_frequency[MAX_NUM_CCs][4];
+int32_t                  uplink_frequency_offset[MAX_NUM_CCs][4];
+
+//Temp fix for inexisting NR upper layer
+unsigned char NB_gNB_INST = 1;
+
+#if defined(ENABLE_ITTI)
+  static char                    *itti_dump_file = NULL;
+#endif
+
+int UE_scan = 1;
+int UE_scan_carrier = 0;
+runmode_t mode = normal_txrx;
+
+FILE *input_fd=NULL;
+
+
+#if MAX_NUM_CCs == 1
+rx_gain_t                rx_gain_mode[MAX_NUM_CCs][4] = {{max_gain,max_gain,max_gain,max_gain}};
+double tx_gain[MAX_NUM_CCs][4] = {{20,0,0,0}};
+double rx_gain[MAX_NUM_CCs][4] = {{110,0,0,0}};
+#else
+rx_gain_t                rx_gain_mode[MAX_NUM_CCs][4] = {{max_gain,max_gain,max_gain,max_gain},{max_gain,max_gain,max_gain,max_gain}};
+double tx_gain[MAX_NUM_CCs][4] = {{20,0,0,0},{20,0,0,0}};
+double rx_gain[MAX_NUM_CCs][4] = {{110,0,0,0},{20,0,0,0}};
+#endif
+
+double rx_gain_off = 0.0;
+
+double sample_rate=30.72e6;
+double bw = 10.0e6;
+
+static int                      tx_max_power[MAX_NUM_CCs]; /* =  {0,0}*/;
+
+char   rf_config_file[1024]="/usr/local/etc/syriq/ue.band7.tm1.PRB100.NR40.dat";
+
+int chain_offset=0;
+int phy_test = 0;
+uint8_t usim_test = 0;
+
+uint8_t dci_Format = 0;
+uint8_t agregation_Level =0xFF;
+
+uint8_t nb_antenna_tx = 1;
+uint8_t nb_antenna_rx = 1;
+
+char ref[128] = "internal";
+char channels[128] = "0";
+
+int                      rx_input_level_dBm;
+
+#ifdef XFORMS
+  extern int                      otg_enabled;
+  static char                     do_forms=0;
+#else
+  int                             otg_enabled;
+#endif
+//int                             number_of_cards =   1;
+
+
+//static NR_DL_FRAME_PARMS      *frame_parms[MAX_NUM_CCs];
+//static nfapi_nr_config_request_t *config[MAX_NUM_CCs];
+uint32_t target_dl_mcs = 28; //maximum allowed mcs
+uint32_t target_ul_mcs = 20;
+uint32_t timing_advance = 0;
+uint8_t exit_missed_slots=1;
+uint64_t num_missed_slots=0; // counter for the number of missed slots
+
+
+extern void reset_opp_meas(void);
+extern void print_opp_meas(void);
+
+extern void init_eNB_afterRU(void);
+
+int transmission_mode=1;
+int emulate_rf = 0;
+int numerology = 0;
+char *parallel_config = NULL;
+char *worker_config = NULL;
+
+static THREAD_STRUCT thread_struct;
+void set_parallel_conf(char *parallel_conf) {
+  if(strcmp(parallel_conf,"PARALLEL_SINGLE_THREAD")==0)           thread_struct.parallel_conf = PARALLEL_SINGLE_THREAD;
+  else if(strcmp(parallel_conf,"PARALLEL_RU_L1_SPLIT")==0)        thread_struct.parallel_conf = PARALLEL_RU_L1_SPLIT;
+  else if(strcmp(parallel_conf,"PARALLEL_RU_L1_TRX_SPLIT")==0)    thread_struct.parallel_conf = PARALLEL_RU_L1_TRX_SPLIT;
+
+  printf("[CONFIG] parallel conf is set to %d\n",thread_struct.parallel_conf);
+}
+void set_worker_conf(char *worker_conf) {
+  if(strcmp(worker_conf,"WORKER_DISABLE")==0)                     thread_struct.worker_conf = WORKER_DISABLE;
+  else if(strcmp(worker_conf,"WORKER_ENABLE")==0)                 thread_struct.worker_conf = WORKER_ENABLE;
+
+  printf("[CONFIG] worker conf is set to %d\n",thread_struct.worker_conf);
+}
+PARALLEL_CONF_t get_thread_parallel_conf(void) {
+  return thread_struct.parallel_conf;
+}
+WORKER_CONF_t get_thread_worker_conf(void) {
+  return thread_struct.worker_conf;
+}
+
+
+/* struct for ethernet specific parameters given in eNB conf file */
+eth_params_t *eth_params;
+
+openair0_config_t openair0_cfg[MAX_CARDS];
+
+double cpuf;
+
+extern char uecap_xer[1024];
+char uecap_xer_in=0;
+
+/* see file openair2/LAYER2/MAC/main.c for why abstraction_flag is needed
+ * this is very hackish - find a proper solution
+ */
+uint8_t abstraction_flag=0;
+
+/* forward declarations */
+void set_default_frame_parms(nfapi_nr_config_request_t *config[MAX_NUM_CCs], NR_DL_FRAME_PARMS *frame_parms[MAX_NUM_CCs]);
+
+/*---------------------BMC: timespec helpers -----------------------------*/
+
+struct timespec min_diff_time = { .tv_sec = 0, .tv_nsec = 0 };
+struct timespec max_diff_time = { .tv_sec = 0, .tv_nsec = 0 };
+
+struct timespec clock_difftime(struct timespec start, struct timespec end) {
+  struct timespec temp;
+
+  if ((end.tv_nsec-start.tv_nsec)<0) {
+    temp.tv_sec = end.tv_sec-start.tv_sec-1;
+    temp.tv_nsec = 1000000000+end.tv_nsec-start.tv_nsec;
+  } else {
+    temp.tv_sec = end.tv_sec-start.tv_sec;
+    temp.tv_nsec = end.tv_nsec-start.tv_nsec;
+  }
+
+  return temp;
+}
+
+void print_difftimes(void) {
+#ifdef DEBUG
+  printf("difftimes min = %lu ns ; max = %lu ns\n", min_diff_time.tv_nsec, max_diff_time.tv_nsec);
+#else
+  LOG_I(HW,"difftimes min = %lu ns ; max = %lu ns\n", min_diff_time.tv_nsec, max_diff_time.tv_nsec);
+#endif
+}
+
+void update_difftimes(struct timespec start, struct timespec end) {
+  struct timespec diff_time = { .tv_sec = 0, .tv_nsec = 0 };
+  int             changed = 0;
+  diff_time = clock_difftime(start, end);
+
+  if ((min_diff_time.tv_nsec == 0) || (diff_time.tv_nsec < min_diff_time.tv_nsec)) {
+    min_diff_time.tv_nsec = diff_time.tv_nsec;
+    changed = 1;
+  }
+
+  if ((max_diff_time.tv_nsec == 0) || (diff_time.tv_nsec > max_diff_time.tv_nsec)) {
+    max_diff_time.tv_nsec = diff_time.tv_nsec;
+    changed = 1;
+  }
+
+#if 1
+
+  if (changed) print_difftimes();
+
+#endif
+}
+
+/*------------------------------------------------------------------------*/
+
+unsigned int build_rflocal(int txi, int txq, int rxi, int rxq) {
+  return (txi + (txq<<6) + (rxi<<12) + (rxq<<18));
+}
+unsigned int build_rfdc(int dcoff_i_rxfe, int dcoff_q_rxfe) {
+  return (dcoff_i_rxfe + (dcoff_q_rxfe<<8));
+}
+
+#if !defined(ENABLE_ITTI)
+void signal_handler(int sig) {
+  void *array[10];
+  size_t size;
+
+  if (sig==SIGSEGV) {
+    // get void*'s for all entries on the stack
+    size = backtrace(array, 10);
+    // print out all the frames to stderr
+    fprintf(stderr, "Error: signal %d:\n", sig);
+    backtrace_symbols_fd(array, size, 2);
+    exit(-1);
+  } else {
+    printf("trying to exit gracefully...\n");
+    oai_exit = 1;
+  }
+}
+#endif
+#define KNRM  "\x1B[0m"
+#define KRED  "\x1B[31m"
+#define KGRN  "\x1B[32m"
+#define KBLU  "\x1B[34m"
+#define RESET "\033[0m"
+
+#if defined(ENABLE_ITTI)
+void signal_handler_itti(int sig) {
+  // Call exit function
+  char msg[256];
+  memset(msg, 0, 256);
+  sprintf(msg, "caught signal %s\n", strsignal(sig));
+  exit_function(__FILE__, __FUNCTION__, __LINE__, msg);
+}
+#endif
+
+void exit_function(const char *file, const char *function, const int line, const char *s) {
+  int ru_id;
+
+  if (s != NULL) {
+    printf("%s:%d %s() Exiting OAI softmodem: %s\n",file,line, function, s);
+  }
+
+  oai_exit = 1;
+
+  if (RC.ru == NULL)
+    exit(-1); // likely init not completed, prevent crash or hang, exit now...
+
+  for (ru_id=0; ru_id<RC.nb_RU; ru_id++) {
+    if (RC.ru[ru_id] && RC.ru[ru_id]->rfdevice.trx_end_func) {
+      RC.ru[ru_id]->rfdevice.trx_end_func(&RC.ru[ru_id]->rfdevice);
+      RC.ru[ru_id]->rfdevice.trx_end_func = NULL;
+    }
+
+    if (RC.ru[ru_id] && RC.ru[ru_id]->ifdevice.trx_end_func) {
+      RC.ru[ru_id]->ifdevice.trx_end_func(&RC.ru[ru_id]->ifdevice);
+      RC.ru[ru_id]->ifdevice.trx_end_func = NULL;
+    }
+  }
+
+  sleep(1); //allow lte-softmodem threads to exit first
+#if defined(ENABLE_ITTI)
+  itti_terminate_tasks (TASK_UNKNOWN);
+#endif
+  exit(1);
+}
+
+#ifdef XFORMS
+
+
+void reset_stats(FL_OBJECT *button, long arg) {
+  PHY_VARS_gNB *phy_vars_gNB = RC.gNB[0][0];
+
+  for (int i=0; i<NUMBER_OF_UE_MAX; i++) {
+    for (int k=0; k<8; k++) { //harq_processes
+      /*      for (j=0; j<phy_vars_gNB->dlsch[i][0]->Mlimit; j++) {
+        phy_vars_gNB->UE_stats[i].dlsch_NAK[k][j]=0;
+        phy_vars_gNB->UE_stats[i].dlsch_ACK[k][j]=0;
+        phy_vars_gNB->UE_stats[i].dlsch_trials[k][j]=0;
+            }*/
+      phy_vars_gNB->UE_stats[i].dlsch_l2_errors[k]=0;
+      phy_vars_gNB->UE_stats[i].ulsch_errors[k]=0;
+      phy_vars_gNB->UE_stats[i].ulsch_consecutive_errors=0;
+      phy_vars_gNB->UE_stats[i].dlsch_sliding_cnt=0;
+      phy_vars_gNB->UE_stats[i].dlsch_NAK_round0=0;
+      phy_vars_gNB->UE_stats[i].dlsch_mcs_offset=0;
+    }
+  }
+}
+
+static void *scope_thread(void *arg) {
+  int UE_id, CC_id;
+  int ue_cnt=0;
+# ifdef ENABLE_XFORMS_WRITE_STATS
+  FILE *gNB_stats = fopen("gNB_stats.txt", "w");
+#endif
+
+  while (!oai_exit) {
+    ue_cnt=0;
+
+    for(UE_id=0; UE_id<NUMBER_OF_UE_MAX; UE_id++) {
+      for(CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
+        if ((ue_cnt<scope_enb_num_ue)) {
+          /*
+          //this function needs to be written
+          phy_scope_gNB(form_gnb[CC_id][ue_cnt],
+                    RC.gNB[0][CC_id],
+                UE_id);
+          */
+          ue_cnt++;
+        }
+      }
+    }
+
+    sleep(1);
+  }
+
+  //  printf("%s",stats_buffer);
+# ifdef ENABLE_XFORMS_WRITE_STATS
+
+  if (eNB_stats) {
+    rewind (gNB_stats);
+    fwrite (stats_buffer, 1, len, gNB_stats);
+    fclose (gNB_stats);
+  }
+
+# endif
+  pthread_exit((void *)arg);
+}
+#endif
+
+
+
+
+#if defined(ENABLE_ITTI)
+void *l2l1_task(void *arg) {
+  MessageDef *message_p = NULL;
+  int         result;
+  itti_set_task_real_time(TASK_L2L1);
+  itti_mark_task_ready(TASK_L2L1);
+  /* Wait for the initialize message */
+  printf("Wait for the ITTI initialize message\n");
+
+  do {
+    if (message_p != NULL) {
+      result = itti_free (ITTI_MSG_ORIGIN_ID(message_p), message_p);
+      AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result);
+    }
+
+    itti_receive_msg (TASK_L2L1, &message_p);
+
+    switch (ITTI_MSG_ID(message_p)) {
+      case INITIALIZE_MESSAGE:
+        /* Start eNB thread */
+        LOG_D(EMU, "L2L1 TASK received %s\n", ITTI_MSG_NAME(message_p));
+        start_gNB = 1;
+        break;
+
+      case TERMINATE_MESSAGE:
+        printf("received terminate message\n");
+        oai_exit=1;
+        start_gNB = 0;
+        itti_exit_task ();
+        break;
+
+      default:
+        LOG_E(EMU, "Received unexpected message %s\n", ITTI_MSG_NAME(message_p));
+        break;
+    }
+  } while (ITTI_MSG_ID(message_p) != INITIALIZE_MESSAGE);
+
+  result = itti_free (ITTI_MSG_ORIGIN_ID(message_p), message_p);
+  AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result);
+  /* ???? no else but seems to be UE only ???
+    do {
+      // Wait for a message
+      itti_receive_msg (TASK_L2L1, &message_p);
+
+      switch (ITTI_MSG_ID(message_p)) {
+      case TERMINATE_MESSAGE:
+        oai_exit=1;
+        itti_exit_task ();
+        break;
+
+      case ACTIVATE_MESSAGE:
+        start_UE = 1;
+        break;
+
+      case DEACTIVATE_MESSAGE:
+        start_UE = 0;
+        break;
+
+      case MESSAGE_TEST:
+        LOG_I(EMU, "Received %s\n", ITTI_MSG_NAME(message_p));
+        break;
+
+      default:
+        LOG_E(EMU, "Received unexpected message %s\n", ITTI_MSG_NAME(message_p));
+        break;
+      }
+
+      result = itti_free (ITTI_MSG_ORIGIN_ID(message_p), message_p);
+      AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result);
+    } while(!oai_exit);
+  */
+  return NULL;
+}
+#endif
+
+int create_gNB_tasks(uint32_t gnb_nb) {
+  LOG_D(GNB_APP, "%s(gnb_nb:%d\n", __FUNCTION__, gnb_nb);
+  itti_wait_ready(1);
+
+  if (itti_create_task (TASK_L2L1, l2l1_task, NULL) < 0) {
+    LOG_E(PDCP, "Create task for L2L1 failed\n");
+    return -1;
+  }
+
+  if (gnb_nb > 0) {
+    /* Last task to create, others task must be ready before its start */
+    if (itti_create_task (TASK_GNB_APP, gNB_app_task, NULL) < 0) {
+      LOG_E(GNB_APP, "Create task for gNB APP failed\n");
+      return -1;
+    }
+  }
+
+  /*
+  #   if defined(ENABLE_USE_MME)
+        if (gnb_nb > 0) {
+          if (itti_create_task (TASK_SCTP, sctp_eNB_task, NULL) < 0) {
+            LOG_E(SCTP, "Create task for SCTP failed\n");
+            return -1;
+          }
+
+          if (itti_create_task (TASK_S1AP, s1ap_eNB_task, NULL) < 0) {
+            LOG_E(S1AP, "Create task for S1AP failed\n");
+            return -1;
+          }
+          if(!emulate_rf){
+            if (itti_create_task (TASK_UDP, udp_eNB_task, NULL) < 0) {
+              LOG_E(UDP_, "Create task for UDP failed\n");
+              return -1;
+            }
+          }
+
+          if (itti_create_task (TASK_GTPV1_U, &gtpv1u_eNB_task, NULL) < 0) {
+            LOG_E(GTPU, "Create task for GTPV1U failed\n");
+            return -1;
+          }
+        }
+
+  #      endif
+  */
+
+  if (gnb_nb > 0) {
+    LOG_I(NR_RRC,"Creating NR RRC gNB Task\n");
+
+    if (itti_create_task (TASK_RRC_GNB, rrc_gnb_task, NULL) < 0) {
+      LOG_E(NR_RRC, "Create task for NR RRC gNB failed\n");
+      return -1;
+    }
+  }
+
+  return 0;
+}
+
+
+static void get_options(void) {
+  int tddflag, nonbiotflag;
+  uint32_t online_log_messages;
+  uint32_t glog_level, glog_verbosity;
+  uint32_t start_telnetsrv;
+  paramdef_t cmdline_params[] =CMDLINE_PARAMS_DESC ;
+  paramdef_t cmdline_logparams[] =CMDLINE_LOGPARAMS_DESC ;
+  config_process_cmdline( cmdline_params,sizeof(cmdline_params)/sizeof(paramdef_t),NULL);
+
+  if (strlen(in_path) > 0) {
+    opt_type = OPT_PCAP;
+    opt_enabled=1;
+    printf("Enabling OPT for PCAP  with the following file %s \n",in_path);
+  }
+
+  if (strlen(in_ip) > 0) {
+    opt_enabled=1;
+    opt_type = OPT_WIRESHARK;
+    printf("Enabling OPT for wireshark for local interface");
+  }
+
+  config_process_cmdline( cmdline_logparams,sizeof(cmdline_logparams)/sizeof(paramdef_t),NULL);
+
+  if(config_isparamset(cmdline_logparams,CMDLINE_ONLINELOG_IDX)) {
+    set_glog_onlinelog(online_log_messages);
+  }
+
+  if(config_isparamset(cmdline_logparams,CMDLINE_GLOGLEVEL_IDX)) {
+    set_glog(glog_level);
+  }
+
+  if (start_telnetsrv) {
+    load_module_shlib("telnetsrv",NULL,0,NULL);
+  }
+
+#if T_TRACER
+  paramdef_t cmdline_ttraceparams[] =CMDLINE_TTRACEPARAMS_DESC ;
+  config_process_cmdline( cmdline_ttraceparams,sizeof(cmdline_ttraceparams)/sizeof(paramdef_t),NULL);
+#endif
+
+  if ( !(CONFIG_ISFLAGSET(CONFIG_ABORT)) ) {
+    memset((void *)&RC,0,sizeof(RC));
+    /* Read RC configuration file */
+    NRRCConfig();
+    NB_gNB_INST = RC.nb_nr_inst;
+    NB_RU   = RC.nb_RU;
+    printf("Configuration: nb_rrc_inst %d, nb_nr_L1_inst %d, nb_ru %d\n",NB_gNB_INST,RC.nb_nr_L1_inst,NB_RU);
+  }
+
+  if(parallel_config != NULL) set_parallel_conf(parallel_config);
+
+  if(worker_config != NULL)   set_worker_conf(worker_config);
+}
+
+
+#if T_TRACER
+  int T_nowait = 0;     /* by default we wait for the tracer */
+  int T_port = 2021;    /* default port to listen to to wait for the tracer */
+  int T_dont_fork = 0;  /* default is to fork, see 'T_init' to understand */
+#endif
+
+
+
+void set_default_frame_parms(nfapi_nr_config_request_t *config[MAX_NUM_CCs], NR_DL_FRAME_PARMS *frame_parms[MAX_NUM_CCs]) {
+  int CC_id;
+
+  for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
+    frame_parms[CC_id] = (NR_DL_FRAME_PARMS *) malloc(sizeof(NR_DL_FRAME_PARMS));
+    config[CC_id] = (nfapi_nr_config_request_t *) malloc(sizeof(nfapi_nr_config_request_t));
+    config[CC_id]->subframe_config.numerology_index_mu.value =1;
+    config[CC_id]->subframe_config.duplex_mode.value = 1; //FDD
+    config[CC_id]->subframe_config.dl_cyclic_prefix_type.value = 0; //NORMAL
+    config[CC_id]->rf_config.dl_carrier_bandwidth.value = 106;
+    config[CC_id]->rf_config.ul_carrier_bandwidth.value = 106;
+    config[CC_id]->sch_config.physical_cell_id.value = 0;
+    ///dl frequency to be filled in
+    /*  //Set some default values that may be overwritten while reading options
+        frame_parms[CC_id]->frame_type          = FDD;
+        frame_parms[CC_id]->tdd_config          = 3;
+        frame_parms[CC_id]->tdd_config_S        = 0;
+        frame_parms[CC_id]->N_RB_DL             = 100;
+        frame_parms[CC_id]->N_RB_UL             = 100;
+        frame_parms[CC_id]->Ncp                 = NORMAL;
+        frame_parms[CC_id]->Ncp_UL              = NORMAL;
+        frame_parms[CC_id]->Nid_cell            = 0;
+        frame_parms[CC_id]->num_MBSFN_config    = 0;
+        frame_parms[CC_id]->nb_antenna_ports_eNB  = 1;
+        frame_parms[CC_id]->nb_antennas_tx      = 1;
+        frame_parms[CC_id]->nb_antennas_rx      = 1;
+
+        frame_parms[CC_id]->nushift             = 0;
+
+        frame_parms[CC_id]->phich_config_common.phich_resource = oneSixth;
+        frame_parms[CC_id]->phich_config_common.phich_duration = normal;
+        // UL RS Config
+        frame_parms[CC_id]->pusch_config_common.ul_ReferenceSignalsPUSCH.cyclicShift = 0;//n_DMRS1 set to 0
+        frame_parms[CC_id]->pusch_config_common.ul_ReferenceSignalsPUSCH.groupHoppingEnabled = 0;
+        frame_parms[CC_id]->pusch_config_common.ul_ReferenceSignalsPUSCH.sequenceHoppingEnabled = 0;
+        frame_parms[CC_id]->pusch_config_common.ul_ReferenceSignalsPUSCH.groupAssignmentPUSCH = 0;
+
+        frame_parms[CC_id]->prach_config_common.rootSequenceIndex=22;
+        frame_parms[CC_id]->prach_config_common.prach_ConfigInfo.zeroCorrelationZoneConfig=1;
+        frame_parms[CC_id]->prach_config_common.prach_ConfigInfo.prach_ConfigIndex=0;
+        frame_parms[CC_id]->prach_config_common.prach_ConfigInfo.highSpeedFlag=0;
+        frame_parms[CC_id]->prach_config_common.prach_ConfigInfo.prach_FreqOffset=0;
+
+    //    downlink_frequency[CC_id][0] = 2680000000; // Use float to avoid issue with frequency over 2^31.
+    //    downlink_frequency[CC_id][1] = downlink_frequency[CC_id][0];
+    //    downlink_frequency[CC_id][2] = downlink_frequency[CC_id][0];
+    //    downlink_frequency[CC_id][3] = downlink_frequency[CC_id][0];
+        //printf("Downlink for CC_id %d frequency set to %u\n", CC_id, downlink_frequency[CC_id][0]);
+        frame_parms[CC_id]->dl_CarrierFreq=downlink_frequency[CC_id][0];
+    */
+  }
+}
+
+/*
+void init_openair0(void) {
+
+  int card;
+  int i;
+
+  for (card=0; card<MAX_CARDS; card++) {
+
+    openair0_cfg[card].mmapped_dma=mmapped_dma;
+    openair0_cfg[card].configFilename = NULL;
+
+    if(config[0]->rf_config.dl_carrier_bandwidth.value == 100) {
+      if (frame_parms[0]->threequarter_fs) {
+  openair0_cfg[card].sample_rate=23.04e6;
+  openair0_cfg[card].samples_per_frame = 230400;
+  openair0_cfg[card].tx_bw = 10e6;
+  openair0_cfg[card].rx_bw = 10e6;
+      } else {
+  openair0_cfg[card].sample_rate=30.72e6;
+  openair0_cfg[card].samples_per_frame = 307200;
+  openair0_cfg[card].tx_bw = 10e6;
+  openair0_cfg[card].rx_bw = 10e6;
+      }
+    } else if(config[0]->rf_config.dl_carrier_bandwidth.value == 50) {
+      openair0_cfg[card].sample_rate=15.36e6;
+      openair0_cfg[card].samples_per_frame = 153600;
+      openair0_cfg[card].tx_bw = 5e6;
+      openair0_cfg[card].rx_bw = 5e6;
+    } else if (config[0]->rf_config.dl_carrier_bandwidth.value == 25) {
+      openair0_cfg[card].sample_rate=7.68e6;
+      openair0_cfg[card].samples_per_frame = 76800;
+      openair0_cfg[card].tx_bw = 2.5e6;
+      openair0_cfg[card].rx_bw = 2.5e6;
+    } else if (config[0]->rf_config.dl_carrier_bandwidth.value == 6) {
+      openair0_cfg[card].sample_rate=1.92e6;
+      openair0_cfg[card].samples_per_frame = 19200;
+      openair0_cfg[card].tx_bw = 1.5e6;
+      openair0_cfg[card].rx_bw = 1.5e6;
+    }
+
+
+    if (config[0]->subframe_config.duplex_mode.value==TDD)
+      openair0_cfg[card].duplex_mode = duplex_mode_TDD;
+    else //FDD
+      openair0_cfg[card].duplex_mode = duplex_mode_FDD;
+
+    printf("HW: Configuring card %d, nb_antennas_tx/rx %d/%d\n",card,
+     RC.gNB[0][0]->gNB_config.rf_config.tx_antenna_ports.value,
+     RC.gNB[0][0]->gNB_config.rf_config.tx_antenna_ports.value );
+    openair0_cfg[card].Mod_id = 0;
+
+    openair0_cfg[card].num_rb_dl=config[0]->rf_config.dl_carrier_bandwidth.value;
+
+    openair0_cfg[card].clock_source = clock_source;
+
+
+    openair0_cfg[card].tx_num_channels=min(2,RC.gNB[0][0]->gNB_config.rf_config.tx_antenna_ports.value );
+    openair0_cfg[card].rx_num_channels=min(2,RC.gNB[0][0]->gNB_config.rf_config.tx_antenna_ports.value );
+
+    for (i=0; i<4; i++) {
+
+      if (i<openair0_cfg[card].tx_num_channels)
+  openair0_cfg[card].tx_freq[i] = downlink_frequency[0][i] ;
+      else
+  openair0_cfg[card].tx_freq[i]=0.0;
+
+      if (i<openair0_cfg[card].rx_num_channels)
+  openair0_cfg[card].rx_freq[i] =downlink_frequency[0][i] + uplink_frequency_offset[0][i] ;
+      else
+  openair0_cfg[card].rx_freq[i]=0.0;
+
+      openair0_cfg[card].autocal[i] = 1;
+      openair0_cfg[card].tx_gain[i] = tx_gain[0][i];
+      openair0_cfg[card].rx_gain[i] = RC.gNB[0][0]->rx_total_gain_dB;
+
+
+      openair0_cfg[card].configFilename = rf_config_file;
+      printf("Card %d, channel %d, Setting tx_gain %f, rx_gain %f, tx_freq %f, rx_freq %f\n",
+       card,i, openair0_cfg[card].tx_gain[i],
+       openair0_cfg[card].rx_gain[i],
+       openair0_cfg[card].tx_freq[i],
+       openair0_cfg[card].rx_freq[i]);
+    }
+  } // for loop on cards
+}
+*/
+
+void wait_RUs(void) {
+  LOG_I(PHY,"Waiting for RUs to be configured ... RC.ru_mask:%02lx\n", RC.ru_mask);
+  // wait for all RUs to be configured over fronthaul
+  pthread_mutex_lock(&RC.ru_mutex);
+
+  while (RC.ru_mask>0) {
+    pthread_cond_wait(&RC.ru_cond,&RC.ru_mutex);
+    printf("RC.ru_mask:%02lx\n", RC.ru_mask);
+  }
+
+  pthread_mutex_unlock(&RC.ru_mutex);
+  LOG_I(PHY,"RUs configured\n");
+}
+
+void wait_gNBs(void) {
+  int i,j;
+  int waiting=1;
+
+  while (waiting==1) {
+    printf("Waiting for gNB L1 instances to all get configured ... sleeping 50ms (nb_nr_sL1_inst %d)\n",RC.nb_nr_L1_inst);
+    usleep(50*1000);
+    waiting=0;
+
+    for (i=0; i<RC.nb_nr_L1_inst; i++) {
+      printf("RC.nb_nr_L1_CC[%d]:%d\n", i, RC.nb_nr_L1_CC[i]);
+
+      for (j=0; j<RC.nb_nr_L1_CC[i]; j++) {
+        if (RC.gNB[i][j]->configured==0) {
+          waiting=1;
+          break;
+        }
+      }
+    }
+  }
+
+  printf("gNB L1 are configured\n");
+}
+
+#if defined(ENABLE_ITTI)
+/*
+ * helper function to terminate a certain ITTI task
+ */
+void terminate_task(task_id_t task_id, module_id_t mod_id) {
+  LOG_I(ENB_APP, "sending TERMINATE_MESSAGE to task %s (%d)\n", itti_get_task_name(task_id), task_id);
+  MessageDef *msg;
+  msg = itti_alloc_new_message (ENB_APP, TERMINATE_MESSAGE);
+  itti_send_msg_to_task (task_id, ENB_MODULE_ID_TO_INSTANCE(mod_id), msg);
+}
+
+//extern void  free_transport(PHY_VARS_gNB *);
+extern void  nr_phy_free_RU(RU_t *);
+
+int stop_L1L2(module_id_t gnb_id) {
+  LOG_W(ENB_APP, "stopping nr-softmodem\n");
+  oai_exit = 1;
+
+  if (!RC.ru) {
+    LOG_F(ENB_APP, "no RU configured\n");
+    return -1;
+  }
+
+  /* stop trx devices, multiple carrier currently not supported by RU */
+  if (RC.ru[gnb_id]) {
+    if (RC.ru[gnb_id]->rfdevice.trx_stop_func) {
+      RC.ru[gnb_id]->rfdevice.trx_stop_func(&RC.ru[gnb_id]->rfdevice);
+      LOG_I(ENB_APP, "turned off RU rfdevice\n");
+    } else {
+      LOG_W(ENB_APP, "can not turn off rfdevice due to missing trx_stop_func callback, proceding anyway!\n");
+    }
+
+    if (RC.ru[gnb_id]->ifdevice.trx_stop_func) {
+      RC.ru[gnb_id]->ifdevice.trx_stop_func(&RC.ru[gnb_id]->ifdevice);
+      LOG_I(ENB_APP, "turned off RU ifdevice\n");
+    } else {
+      LOG_W(ENB_APP, "can not turn off ifdevice due to missing trx_stop_func callback, proceding anyway!\n");
+    }
+  } else {
+    LOG_W(ENB_APP, "no RU found for index %d\n", gnb_id);
+    return -1;
+  }
+
+  /* these tasks need to pick up new configuration */
+  terminate_task(TASK_RRC_ENB, gnb_id);
+  terminate_task(TASK_L2L1, gnb_id);
+  LOG_I(ENB_APP, "calling kill_gNB_proc() for instance %d\n", gnb_id);
+  kill_gNB_proc(gnb_id);
+  LOG_I(ENB_APP, "calling kill_RU_proc() for instance %d\n", gnb_id);
+  kill_RU_proc(gnb_id);
+  oai_exit = 0;
+
+  for (int cc_id = 0; cc_id < RC.nb_nr_CC[gnb_id]; cc_id++) {
+    //free_transport(RC.gNB[gnb_id][cc_id]);
+    phy_free_nr_gNB(RC.gNB[gnb_id][cc_id]);
+  }
+
+  nr_phy_free_RU(RC.ru[gnb_id]);
+  free_lte_top();
+  return 0;
+}
+
+/*
+ * Restart the nr-softmodem after it has been soft-stopped with stop_L1L2()
+ */
+int restart_L1L2(module_id_t gnb_id) {
+  RU_t *ru = RC.ru[gnb_id];
+  int cc_id;
+  MessageDef *msg_p = NULL;
+  LOG_W(ENB_APP, "restarting nr-softmodem\n");
+  /* block threads */
+  sync_var = -1;
+
+  for (cc_id = 0; cc_id < RC.nb_nr_L1_CC[gnb_id]; cc_id++) {
+    RC.gNB[gnb_id][cc_id]->configured = 0;
+  }
+
+  RC.ru_mask |= (1 << ru->idx);
+  /* copy the changed frame parameters to the RU */
+  /* TODO this should be done for all RUs associated to this gNB */
+  memcpy(&ru->nr_frame_parms, &RC.gNB[gnb_id][0]->frame_parms, sizeof(NR_DL_FRAME_PARMS));
+  set_function_spec_param(RC.ru[gnb_id]);
+  LOG_I(ENB_APP, "attempting to create ITTI tasks\n");
+
+  if (itti_create_task (TASK_RRC_ENB, rrc_enb_task, NULL) < 0) {
+    LOG_E(RRC, "Create task for RRC eNB failed\n");
+    return -1;
+  } else {
+    LOG_I(RRC, "Re-created task for RRC gNB successfully\n");
+  }
+
+  if (itti_create_task (TASK_L2L1, l2l1_task, NULL) < 0) {
+    LOG_E(PDCP, "Create task for L2L1 failed\n");
+    return -1;
+  } else {
+    LOG_I(PDCP, "Re-created task for L2L1 successfully\n");
+  }
+
+  /* pass a reconfiguration request which will configure everything down to
+   * RC.eNB[i][j]->frame_parms, too */
+  msg_p = itti_alloc_new_message(TASK_ENB_APP, RRC_CONFIGURATION_REQ);
+  RRC_CONFIGURATION_REQ(msg_p) = RC.rrc[gnb_id]->configuration;
+  itti_send_msg_to_task(TASK_RRC_ENB, ENB_MODULE_ID_TO_INSTANCE(gnb_id), msg_p);
+  /* TODO XForms might need to be restarted, but it is currently (09/02/18)
+   * broken, so we cannot test it */
+  wait_gNBs();
+  init_RU_proc(ru);
+  ru->rf_map.card = 0;
+  ru->rf_map.chain = 0; /* CC_id + chain_offset;*/
+  wait_RUs();
+  init_eNB_afterRU();
+  printf("Sending sync to all threads\n");
+  pthread_mutex_lock(&sync_mutex);
+  sync_var=0;
+  pthread_cond_broadcast(&sync_cond);
+  pthread_mutex_unlock(&sync_mutex);
+  return 0;
+}
+#endif
+
+static  void wait_nfapi_init(char *thread_name) {
+  printf( "waiting for NFAPI PNF connection and population of global structure (%s)\n",thread_name);
+  pthread_mutex_lock( &nfapi_sync_mutex );
+
+  while (nfapi_sync_var<0)
+    pthread_cond_wait( &nfapi_sync_cond, &nfapi_sync_mutex );
+
+  pthread_mutex_unlock(&nfapi_sync_mutex);
+  printf( "NFAPI: got sync (%s)\n", thread_name);
+}
+
+int main( int argc, char **argv ) {
+  int i;
+#if defined (XFORMS)
+  //void *status;
+#endif
+  int CC_id;
+  int ru_id;
+#if defined (XFORMS)
+  int ret;
+#endif
+  start_background_system();
+
+  ///static configuration for NR at the moment
+  if ( load_configmodule(argc,argv) == NULL) {
+    exit_fun("[SOFTMODEM] Error, configuration module init failed\n");
+  }
+
+#ifdef DEBUG_CONSOLE
+  setvbuf(stdout, NULL, _IONBF, 0);
+  setvbuf(stderr, NULL, _IONBF, 0);
+#endif
+  mode = normal_txrx;
+  memset(&openair0_cfg[0],0,sizeof(openair0_config_t)*MAX_CARDS);
+  memset(tx_max_power,0,sizeof(int)*MAX_NUM_CCs);
+  configure_linux();
+  logInit();
+  printf("Reading in command-line options\n");
+  get_options ();
+
+  if (CONFIG_ISFLAGSET(CONFIG_ABORT) ) {
+    fprintf(stderr,"Getting configuration failed\n");
+    exit(-1);
+  }
+
+#if T_TRACER
+  T_Config_Init();
+#endif
+  //randominit (0);
+  set_taus_seed (0);
+  printf("configuring for RAU/RRU\n");
+
+  if (opp_enabled ==1) {
+    reset_opp_meas();
+  }
+
+  cpuf=get_cpu_freq_GHz();
+#if defined(ENABLE_ITTI)
+  itti_init(TASK_MAX, THREAD_MAX, MESSAGES_ID_MAX, tasks_info, messages_info);
+  // initialize mscgen log after ITTI
+  MSC_INIT(MSC_E_UTRAN, THREAD_MAX+TASK_MAX);
+#endif
+
+  if (opt_type != OPT_NONE) {
+    if (init_opt(in_path, in_ip) == -1)
+      LOG_E(OPT,"failed to run OPT \n");
+  }
+
+#ifdef PDCP_USE_NETLINK
+  netlink_init();
+#if defined(PDCP_USE_NETLINK_QUEUES)
+  pdcp_netlink_init();
+#endif
+#endif
+#if !defined(ENABLE_ITTI)
+  // to make a graceful exit when ctrl-c is pressed
+  signal(SIGSEGV, signal_handler);
+  signal(SIGINT, signal_handler);
+#endif
+#ifndef PACKAGE_VERSION
+#  define PACKAGE_VERSION "UNKNOWN-EXPERIMENTAL"
+#endif
+  LOG_I(HW, "Version: %s\n", PACKAGE_VERSION);
+#if defined(ENABLE_ITTI)
+
+  if (RC.nb_nr_inst > 0)  {
+    // don't create if node doesn't connect to RRC/S1/GTP
+    AssertFatal(create_gNB_tasks(1) == 0,"cannot create ITTI tasks\n");
+  } else {
+    printf("No ITTI, Initializing L1\n");
+    RCconfig_L1();
+  }
+
+#endif
+  /* Start the agent. If it is turned off in the configuration, it won't start */
+  RCconfig_nr_flexran();
+
+  for (i = 0; i < RC.nb_nr_L1_inst; i++) {
+    flexran_agent_start(i);
+  }
+
+  // init UE_PF_PO and mutex lock
+  pthread_mutex_init(&ue_pf_po_mutex, NULL);
+  memset (&UE_PF_PO[0][0], 0, sizeof(UE_PF_PO_t)*NUMBER_OF_UE_MAX*MAX_NUM_CCs);
+  mlockall(MCL_CURRENT | MCL_FUTURE);
+  pthread_cond_init(&sync_cond,NULL);
+  pthread_mutex_init(&sync_mutex, NULL);
+#ifdef XFORMS
+  int UE_id;
+
+  if (do_forms==1) {
+    fl_initialize (&argc, argv, NULL, 0, 0);
+    form_stats_l2 = create_form_stats_form();
+    fl_show_form (form_stats_l2->stats_form, FL_PLACE_HOTSPOT, FL_FULLBORDER, "l2 stats");
+    form_stats = create_form_stats_form();
+    fl_show_form (form_stats->stats_form, FL_PLACE_HOTSPOT, FL_FULLBORDER, "stats");
+
+    for(UE_id=0; UE_id<scope_enb_num_ue; UE_id++) {
+      for(CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
+        form_gnb[CC_id][UE_id] = create_phy_scope_gnb();
+        sprintf (title, "LTE UL SCOPE eNB for CC_id %d, UE %d",CC_id,UE_id);
+        fl_show_form (form_gnb[CC_id][UE_id]->phy_scope_gnb, FL_PLACE_HOTSPOT, FL_FULLBORDER, title);
+
+        if (otg_enabled) {
+          fl_set_button(form_gnb[CC_id][UE_id]->button_0,1);
+          fl_set_object_label(form_gnb[CC_id][UE_id]->button_0,"DL Traffic ON");
+        } else {
+          fl_set_button(form_gnb[CC_id][UE_id]->button_0,0);
+          fl_set_object_label(form_gnb[CC_id][UE_id]->button_0,"DL Traffic OFF");
+        }
+      } // CC_id
+    } // UE_id
+
+    threadCreate(&forms_thread, scope_thread, NULL, "scope", -1, OAI_PRIORITY_RT_LOW);
+    printf("Scope thread created, ret=%d\n",ret);
+  }
+
+#endif
+  usleep(10*1000);
+
+  if (nfapi_mode) {
+    printf("NFAPI*** - mutex and cond created - will block shortly for completion of PNF connection\n");
+    pthread_cond_init(&sync_cond,NULL);
+    pthread_mutex_init(&sync_mutex, NULL);
+  }
+
+  const char *nfapi_mode_str = "<UNKNOWN>";
+
+  switch(nfapi_mode) {
+    case 0:
+      nfapi_mode_str = "MONOLITHIC";
+      break;
+
+    case 1:
+      nfapi_mode_str = "PNF";
+      break;
+
+    case 2:
+      nfapi_mode_str = "VNF";
+      break;
+
+    default:
+      nfapi_mode_str = "<UNKNOWN NFAPI MODE>";
+      break;
+  }
+
+  printf("NFAPI MODE:%s\n", nfapi_mode_str);
+
+  if (nfapi_mode==2) // VNF
+    wait_nfapi_init("main?");
+
+  printf("START MAIN THREADS\n");
+  // start the main threads
+  number_of_cards = 1;
+  printf("RC.nb_nr_L1_inst:%d\n", RC.nb_nr_L1_inst);
+
+  if (RC.nb_nr_L1_inst > 0) {
+    printf("Initializing gNB threads single_thread_flag:%d wait_for_sync:%d\n", single_thread_flag,wait_for_sync);
+    init_gNB(single_thread_flag,wait_for_sync);
+  }
+
+  printf("wait_gNBs()\n");
+  wait_gNBs();
+  printf("About to Init RU threads RC.nb_RU:%d\n", RC.nb_RU);
+
+  if (RC.nb_RU >0) {
+    printf("Initializing RU threads\n");
+    init_RU(rf_config_file);
+
+    for (ru_id=0; ru_id<RC.nb_RU; ru_id++) {
+      RC.ru[ru_id]->rf_map.card=0;
+      RC.ru[ru_id]->rf_map.chain=CC_id+chain_offset;
+    }
+  }
+
+  config_sync_var=0;
+
+  if (nfapi_mode==1) { // PNF
+    wait_nfapi_init("main?");
+  }
+
+  printf("wait RUs\n");
+  wait_RUs();
+  printf("ALL RUs READY!\n");
+  printf("RC.nb_RU:%d\n", RC.nb_RU);
+  // once all RUs are ready initialize the rest of the gNBs ((dependence on final RU parameters after configuration)
+  printf("ALL RUs ready - init gNBs\n");
+
+  if (nfapi_mode != 1 && nfapi_mode != 2) {
+    printf("Not NFAPI mode - call init_eNB_afterRU()\n");
+    init_eNB_afterRU();
+  } else {
+    printf("NFAPI mode - DO NOT call init_gNB_afterRU()\n");
+  }
+
+  printf("ALL RUs ready - ALL gNBs ready\n");
+  // connect the TX/RX buffers
+  printf("Sending sync to all threads\n");
+  pthread_mutex_lock(&sync_mutex);
+  sync_var=0;
+  pthread_cond_broadcast(&sync_cond);
+  pthread_mutex_unlock(&sync_mutex);
+  printf("About to call end_configmodule() from %s() %s:%d\n", __FUNCTION__, __FILE__, __LINE__);
+  end_configmodule();
+  printf("Called end_configmodule() from %s() %s:%d\n", __FUNCTION__, __FILE__, __LINE__);
+  // wait for end of program
+  printf("TYPE <CTRL-C> TO TERMINATE\n");
+  //getchar();
+#if defined(ENABLE_ITTI)
+  printf("Entering ITTI signals handler\n");
+  itti_wait_tasks_end();
+  printf("Returned from ITTI signal handler\n");
+  oai_exit=1;
+  printf("oai_exit=%d\n",oai_exit);
+#else
+
+  while (oai_exit==0)
+    sleep(1);
+
+  printf("Terminating application - oai_exit=%d\n",oai_exit);
+#endif
+  // stop threads
+#ifdef XFORMS
+  /*
+    printf("waiting for XFORMS thread\n");
+
+    if (do_forms==1) {
+      pthread_join(forms_thread,&status);
+      fl_hide_form(form_stats->stats_form);
+      fl_free_form(form_stats->stats_form);
+
+        fl_hide_form(form_stats_l2->stats_form);
+        fl_free_form(form_stats_l2->stats_form);
+
+        for(UE_id=0; UE_id<scope_enb_num_ue; UE_id++) {
+    for(CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
+      fl_hide_form(form_enb[CC_id][UE_id]->phy_scope_gNB);
+      fl_free_form(form_enb[CC_id][UE_id]->phy_scope_gNB);
+    }
+        }
+    }
+  */
+#endif
+  printf("stopping MODEM threads\n");
+  // cleanup
+  stop_gNB(NB_gNB_INST);
+  stop_RU(NB_RU);
+
+  /* release memory used by the RU/gNB threads (incomplete), after all
+   * threads have been stopped (they partially use the same memory) */
+  for (int inst = 0; inst < NB_gNB_INST; inst++) {
+    for (int cc_id = 0; cc_id < RC.nb_nr_CC[inst]; cc_id++) {
+      //free_transport(RC.gNB[inst][cc_id]);
+      phy_free_nr_gNB(RC.gNB[inst][cc_id]);
+    }
+  }
+
+  for (int inst = 0; inst < NB_RU; inst++) {
+    nr_phy_free_RU(RC.ru[inst]);
+  }
+
+  free_lte_top();
+  pthread_cond_destroy(&sync_cond);
+  pthread_mutex_destroy(&sync_mutex);
+  pthread_cond_destroy(&nfapi_sync_cond);
+  pthread_mutex_destroy(&nfapi_sync_mutex);
+  pthread_mutex_destroy(&ue_pf_po_mutex);
+
+  // *** Handle per CC_id openair0
+
+  for(ru_id=0; ru_id<NB_RU; ru_id++) {
+    if (RC.ru[ru_id]->rfdevice.trx_end_func)
+      RC.ru[ru_id]->rfdevice.trx_end_func(&RC.ru[ru_id]->rfdevice);
+
+    if (RC.ru[ru_id]->ifdevice.trx_end_func)
+      RC.ru[ru_id]->ifdevice.trx_end_func(&RC.ru[ru_id]->ifdevice);
+  }
+
+  if (opt_enabled == 1)
+    terminate_opt();
+
+  logClean();
+  printf("Bye.\n");
+  return 0;
+}
diff --git a/executables/nr-softmodem.h b/executables/nr-softmodem.h
new file mode 100644
index 0000000000..b01d92e6ed
--- /dev/null
+++ b/executables/nr-softmodem.h
@@ -0,0 +1,240 @@
+#ifndef NR_SOFTMODEM_H
+#define NR_SOFTMODEM_H
+
+#define _GNU_SOURCE
+#include <execinfo.h>
+#include <fcntl.h>
+#include <getopt.h>
+#include <linux/sched.h>
+#include <sched.h>
+#include <signal.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <syscall.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/sysinfo.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <sys/sysinfo.h>
+#include "targets/ARCH/COMMON/common_lib.h"
+#undef MALLOC
+#include "assertions.h"
+#include "msc.h"
+#include "PHY/types.h"
+
+#include "flexran_agent.h"
+#include "PHY/defs_gNB.h"
+
+#if defined(ENABLE_ITTI)
+  #if defined(ENABLE_USE_MME)
+    #include "s1ap_eNB.h"
+    #ifdef PDCP_USE_NETLINK
+      #include "SIMULATION/ETH_TRANSPORT/proto.h"
+    #endif
+  #endif
+#endif
+
+/* help strings definition for command line options, used in CMDLINE_XXX_DESC macros and printed when -h option is used */
+#define CONFIG_HLP_RFCFGF        "Configuration file for front-end (e.g. LMS7002M)\n"
+#define CONFIG_HLP_ULMAXE        "set the eNodeB max ULSCH erros\n"
+#define CONFIG_HLP_CALUER        "set UE RX calibration\n"
+#define CONFIG_HLP_CALUERM       ""
+#define CONFIG_HLP_CALUERB       ""
+#define CONFIG_HLP_DBGUEPR       "UE run normal prach power ramping, but don't continue random-access\n"
+#define CONFIG_HLP_CALPRACH      "UE run normal prach with maximum power, but don't continue random-access\n"
+#define CONFIG_HLP_NOL2CN        "bypass L2 and upper layers\n"
+#define CONFIG_HLP_UERXG         "set UE RX gain\n"
+#define CONFIG_HLP_UERXGOFF      "external UE amplifier offset\n"
+#define CONFIG_HLP_UETXG         "set UE TX gain\n"
+#define CONFIG_HLP_UENANTR       "set UE number of rx antennas\n"
+#define CONFIG_HLP_UENANTT       "set UE number of tx antennas\n"
+#define CONFIG_HLP_UESCAN        "set UE to scan around carrier\n"
+#define CONFIG_HLP_DUMPFRAME     "dump UE received frame to rxsig_frame0.dat and exit\n"
+#define CONFIG_HLP_DLSHIFT       "dynamic shift for LLR compuation for TM3/4 (default 0)\n"
+#define CONFIG_HLP_UELOOP        "get softmodem (UE) to loop through memory instead of acquiring from HW\n"
+#define CONFIG_HLP_PHYTST        "test UE phy layer, mac disabled\n"
+#define CONFIG_HLP_DMAMAP        "sets flag for improved EXMIMO UE performance\n"
+#define CONFIG_HLP_EXCCLK        "tells hardware to use an external clock reference\n"
+#define CONFIG_HLP_USIM          "use XOR autentication algo in case of test usim mode\n"
+#define CONFIG_HLP_NOSNGLT       "Disables single-thread mode in lte-softmodem\n"
+#define CONFIG_HLP_TADV          "Set timing_advance\n"
+#define CONFIG_HLP_DLF           "Set the downlink frequency for all component carriers\n"
+#define CONFIG_HLP_CHOFF         "Channel id offset\n"
+#define CONFIG_HLP_SOFTS         "Enable soft scope and L1 and L2 stats (Xforms)\n"
+#define CONFIG_HLP_EXMCAL        "Calibrate the EXMIMO borad, available files: exmimo2_2arxg.lime exmimo2_2brxg.lime \n"
+#define CONFIG_HLP_ITTIL         "Generate ITTI analyzser logs (similar to wireshark logs but with more details)\n"
+#define CONFIG_HLP_DLMCS         "Set the maximum downlink MCS\n"
+#define CONFIG_HLP_STMON         "Enable processing timing measurement of lte softmodem on per subframe basis \n"
+#define CONFIG_HLP_PRB           "Set the PRB, valid values: 6, 25, 50, 100  \n"
+#define CONFIG_HLP_MSLOTS        "Skip the missed slots/subframes \n"
+#define CONFIG_HLP_ULMCS         "Set the maximum uplink MCS\n"
+#define CONFIG_HLP_TDD           "Set hardware to TDD mode (default: FDD). Used only with -U (otherwise set in config file).\n"
+#define CONFIG_HLP_UE            "Set the lte softmodem as a UE\n"
+#define CONFIG_HLP_L2MONW        "Enable L2 wireshark messages on localhost \n"
+#define CONFIG_HLP_L2MONP        "Enable L2 pcap  messages on localhost \n"
+#define CONFIG_HLP_VCD           "Enable VCD (generated file will is named openair_dump_eNB.vcd, read it with target/RT/USER/eNB.gtkw\n"
+#define CONFIG_HLP_TQFS          "Apply three-quarter of sampling frequency, 23.04 Msps to reduce the data rate on USB/PCIe transfers (only valid for 20 MHz)\n"
+#define CONFIG_HLP_TPORT         "tracer port\n"
+#define CONFIG_HLP_NOTWAIT       "don't wait for tracer, start immediately\n"
+#define CONFIG_HLP_TNOFORK       "to ease debugging with gdb\n"
+#define CONFIG_HLP_DISABLNBIOT   "disable nb-iot, even if defined in config\n"
+
+#define CONFIG_HLP_NUMEROLOGY    "adding numerology for 5G\n"
+#define CONFIG_HLP_EMULATE_RF    "Emulated RF enabled(disable by defult)\n"
+#define CONFIG_HLP_PARALLEL_CMD  "three config for level of parallelism 'PARALLEL_SINGLE_THREAD', 'PARALLEL_RU_L1_SPLIT', or 'PARALLEL_RU_L1_TRX_SPLIT'\n"
+#define CONFIG_HLP_WORKER_CMD    "two option for worker 'WORKER_DISABLE' or 'WORKER_ENABLE'\n"
+
+/***************************************************************************************************************************************/
+/* command line options definitions, CMDLINE_XXXX_DESC macros are used to initialize paramdef_t arrays which are then used as argument
+   when calling config_get or config_getlist functions                                                                                 */
+
+
+/*------------------------------------------------------------------------------------------------------------------------------------------*/
+/*                                            command line parameters defining UE running mode                                              */
+/*   optname                     helpstr                paramflags                      XXXptr        defXXXval         type       numelt   */
+/*------------------------------------------------------------------------------------------------------------------------------------------*/
+#define CMDLINE_UEMODEPARAMS_DESC {  \
+    {"calib-ue-rx",                 CONFIG_HLP_CALUER,     0,    iptr:&rx_input_level_dBm,   defintval:0,  TYPE_INT,   0},    \
+    {"calib-ue-rx-med",             CONFIG_HLP_CALUERM,    0,    iptr:&rx_input_level_dBm,   defintval:0,  TYPE_INT,   0},    \
+    {"calib-ue-rx-byp",             CONFIG_HLP_CALUERB,    0,    iptr:&rx_input_level_dBm,   defintval:0,  TYPE_INT,   0},    \
+    {"debug-ue-prach",              CONFIG_HLP_DBGUEPR,    PARAMFLAG_BOOL,   uptr:NULL,        defuintval:1,   TYPE_INT,   0},    \
+    {"no-L2-connect",               CONFIG_HLP_NOL2CN,     PARAMFLAG_BOOL,   uptr:NULL,        defuintval:1,   TYPE_INT,   0},    \
+    {"calib-prach-tx",              CONFIG_HLP_CALPRACH,   PARAMFLAG_BOOL,   uptr:NULL,        defuintval:1,   TYPE_INT,   0},    \
+    {"loop-memory",                 CONFIG_HLP_UELOOP,     0,    strptr:&loopfile,       defstrval:"iqs.in", TYPE_STRING,0},    \
+    {"ue-dump-frame",               CONFIG_HLP_DUMPFRAME,  PARAMFLAG_BOOL,   iptr:&dumpframe,      defintval:0,  TYPE_INT,   0},    \
+  }
+#define CMDLINE_CALIBUERX_IDX                   0
+#define CMDLINE_CALIBUERXMED_IDX                1
+#define CMDLINE_CALIBUERXBYP_IDX                2
+#define CMDLINE_DEBUGUEPRACH_IDX                3
+#define CMDLINE_NOL2CONNECT_IDX                 4
+#define CMDLINE_CALIBPRACHTX_IDX                5
+#define CMDLINE_MEMLOOP_IDX                     6
+#define CMDLINE_DUMPMEMORY_IDX                  7
+/*------------------------------------------------------------------------------------------------------------------------------------------*/
+
+
+#define DEFAULT_DLF 2680000000
+
+/*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
+/*                                            command line parameters common to eNodeB and UE                                                                                */
+/*   optname                     helpstr                paramflags                      XXXptr                  defXXXval                            type           numelt   */
+/*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
+#define CMDLINE_PARAMS_DESC {  \
+    {"rf-config-file",           CONFIG_HLP_RFCFGF, 0,      strptr:(char **)&rf_config_file,  defstrval:NULL,        TYPE_STRING,   sizeof(rf_config_file)}, \
+    {"ulsch-max-errors",         CONFIG_HLP_ULMAXE, 0,      uptr:&ULSCH_max_consecutive_errors, defuintval:0,        TYPE_UINT,   0},        \
+    {"phy-test",                 CONFIG_HLP_PHYTST, PARAMFLAG_BOOL,   iptr:&phy_test,     defintval:0,         TYPE_INT,    0},        \
+    {"usim-test",                CONFIG_HLP_USIM, PARAMFLAG_BOOL,   u8ptr:&usim_test,     defintval:0,         TYPE_UINT8,    0},        \
+    {"mmapped-dma",              CONFIG_HLP_DMAMAP, PARAMFLAG_BOOL,   uptr:&mmapped_dma,      defintval:0,         TYPE_INT,    0},        \
+    {"external-clock",           CONFIG_HLP_EXCCLK, PARAMFLAG_BOOL,   uptr:&clock_source,     defintval:0,         TYPE_INT,    0},        \
+    {"wait-for-sync",            NULL,      PARAMFLAG_BOOL,   iptr:&wait_for_sync,      defintval:0,         TYPE_INT,    0},        \
+    {"single-thread-disable",    CONFIG_HLP_NOSNGLT,  PARAMFLAG_BOOL,   iptr:&single_thread_flag,   defintval:1,         TYPE_INT,    0},        \
+    {"A" ,           CONFIG_HLP_TADV, 0,      uptr:&timing_advance,     defintval:0,         TYPE_UINT,   0},        \
+    {"C" ,           CONFIG_HLP_DLF,  0,      uptr:&(downlink_frequency[0][0]), defuintval:DEFAULT_DLF,      TYPE_UINT,   0},        \
+    {"a" ,           CONFIG_HLP_CHOFF,  0,      iptr:&chain_offset,     defintval:0,         TYPE_INT,    0},        \
+    {"d" ,           CONFIG_HLP_SOFTS,  PARAMFLAG_BOOL,   uptr:(uint32_t *)&do_forms,   defintval:0,         TYPE_INT8,   0},        \
+    {"E" ,           CONFIG_HLP_TQFS, PARAMFLAG_BOOL,   i8ptr:&threequarter_fs,   defintval:0,         TYPE_INT8,   0},        \
+    {"K" ,           CONFIG_HLP_ITTIL,  PARAMFLAG_NOFREE, strptr:&itti_dump_file,   defstrval:"/tmp/itti.dump",    TYPE_STRING,   0},        \
+    {"m" ,           CONFIG_HLP_DLMCS,  0,      uptr:&target_dl_mcs,      defintval:0,         TYPE_UINT,   0},        \
+    {"t" ,           CONFIG_HLP_ULMCS,  0,      uptr:&target_ul_mcs,      defintval:0,         TYPE_UINT,   0},        \
+    {"W" ,           CONFIG_HLP_L2MONW, 0,      strptr:(char **)&in_ip,   defstrval:"127.0.0.1",       TYPE_STRING,   sizeof(in_ip)},    \
+    {"P" ,           CONFIG_HLP_L2MONP, 0,      strptr:(char **)&in_path,   defstrval:"/tmp/oai_opt.pcap",     TYPE_STRING,   sizeof(in_path)},    \
+    {"q" ,           CONFIG_HLP_STMON,  PARAMFLAG_BOOL,   iptr:&opp_enabled,      defintval:0,         TYPE_INT,    0},        \
+    {"S" ,           CONFIG_HLP_MSLOTS, PARAMFLAG_BOOL,   u8ptr:&exit_missed_slots,   defintval:1,         TYPE_UINT8,    0},        \
+    {"T" ,           CONFIG_HLP_TDD,  PARAMFLAG_BOOL,   iptr:&tddflag,      defintval:0,         TYPE_INT,    0},        {"numerology" ,                  CONFIG_HLP_NUMEROLOGY,  PARAMFLAG_BOOL,         iptr:&numerology,                   defintval:0,                    TYPE_INT,       0},                     \
+    {"emulate-rf" ,                  CONFIG_HLP_EMULATE_RF,  PARAMFLAG_BOOL,         iptr:&emulate_rf,                   defintval:0,                    TYPE_INT,       0},                     \
+    {"parallel-config",              CONFIG_HLP_PARALLEL_CMD,0,                      strptr:(char **)&parallel_config,   defstrval:NULL,                 TYPE_STRING,    0},                     \
+    {"worker-config",                CONFIG_HLP_WORKER_CMD,  0,                      strptr:(char **)&worker_config,     defstrval:NULL,                 TYPE_STRING,    0},                     \
+    {"nbiot-disable",          CONFIG_HLP_DISABLNBIOT,PARAMFLAG_BOOL,   iptr:&nonbiotflag,      defintval:0,         TYPE_INT,    0}                       \
+  }
+
+#define CONFIG_HLP_FLOG          "Enable online log \n"
+#define CONFIG_HLP_LOGL          "Set the global log level, valide options: (9:trace, 8/7:debug, 6:info, 4:warn, 3:error)\n"
+#define CONFIG_HLP_LOGV          "Set the global log verbosity \n"
+#define CONFIG_HLP_TELN          "Start embedded telnet server \n"
+/*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
+/*                                            command line parameters for LOG utility                                                                                        */
+/*   optname                     helpstr                paramflags                      XXXptr                  defXXXval                            type           numelt   */
+/*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
+#define CMDLINE_LOGPARAMS_DESC {  \
+    {"R" ,           CONFIG_HLP_FLOG, 0,                uptr:&online_log_messages,    defintval:1,         TYPE_INT,    0},        \
+    {"g" ,           CONFIG_HLP_LOGL, 0,      uptr:&glog_level,     defintval:0,         TYPE_UINT,     0},        \
+    {"G" ,                           CONFIG_HLP_LOGV, 0,      uptr:&glog_verbosity,           defintval:0,         TYPE_UINT16,   0},        \
+    {"telnetsrv",        CONFIG_HLP_TELN, PARAMFLAG_BOOL,   uptr:&start_telnetsrv,    defintval:0,         TYPE_UINT,     0},        \
+  }
+#define CMDLINE_ONLINELOG_IDX     0
+#define CMDLINE_GLOGLEVEL_IDX     1
+#define CMDLINE_GLOGVERBO_IDX     2
+#define CMDLINE_STARTTELN_IDX     3
+
+
+typedef struct {
+  int *argc;
+  char **argv;
+} scopeParms_t;
+
+extern int T_port;
+extern int T_nowait;
+extern int T_dont_fork;
+
+
+/***************************************************************************************************************************************/
+/*  */
+extern pthread_cond_t sync_cond;
+extern pthread_mutex_t sync_mutex;
+extern int sync_var;
+
+
+extern uint32_t          downlink_frequency[MAX_NUM_CCs][4];
+extern int32_t           uplink_frequency_offset[MAX_NUM_CCs][4];
+
+extern int rx_input_level_dBm;
+extern uint8_t exit_missed_slots;
+extern uint64_t num_missed_slots; // counter for the number of missed slots
+
+extern int oaisim_flag;
+extern volatile int  oai_exit;
+
+extern openair0_config_t openair0_cfg[MAX_CARDS];
+extern pthread_cond_t sync_cond;
+extern pthread_mutex_t sync_mutex;
+extern int sync_var;
+extern int transmission_mode;
+extern double cpuf;
+
+#if defined(ENABLE_ITTI)
+  extern volatile int             start_gNB;
+#endif
+
+#include "threads_t.h"
+extern threads_t threads;
+
+// In nr-gnb.c
+extern void init_gNB(int single_thread_flag,int wait_for_sync);
+extern void stop_gNB(int);
+extern void kill_gNB_proc(int inst);
+
+// In nr-ru.c
+extern void init_RU(const char *);
+extern void init_RU_proc(RU_t *ru);
+extern void stop_RU(int nb_ru);
+extern void kill_RU_proc(int inst);
+extern void set_function_spec_param(RU_t *ru);
+
+extern void reset_opp_meas(void);
+extern void print_opp_meas(void);
+
+extern void init_fep_thread(PHY_VARS_gNB *);
+
+void init_gNB_afterRU(void);
+
+extern int stop_L1L2(module_id_t gnb_id);
+extern int restart_L1L2(module_id_t gnb_id);
+
+#endif
+
diff --git a/executables/nr-ue.c b/executables/nr-ue.c
new file mode 100644
index 0000000000..bf0dc9809a
--- /dev/null
+++ b/executables/nr-ue.c
@@ -0,0 +1,768 @@
+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+#include "executables/nr-uesoftmodem.h"
+
+#include "LAYER2/NR_MAC_UE/mac.h"
+//#include "RRC/LTE/rrc_extern.h"
+#include "PHY_INTERFACE/phy_interface_extern.h"
+
+#undef MALLOC //there are two conflicting definitions, so we better make sure we don't use it at all
+//#undef FRAME_LENGTH_COMPLEX_SAMPLES //there are two conflicting definitions, so we better make sure we don't use it at all
+
+#include "fapi_nr_ue_l1.h"
+#include "PHY/phy_extern_nr_ue.h"
+#include "PHY/INIT/phy_init.h"
+#include "PHY/MODULATION/modulation_UE.h"
+#include "LAYER2/NR_MAC_UE/mac_proto.h"
+#include "RRC/NR_UE/rrc_proto.h"
+
+//#ifndef NO_RAT_NR
+#include "SCHED_NR/phy_frame_config_nr.h"
+//#endif
+#include "SCHED_NR_UE/defs.h"
+
+#include "PHY/NR_UE_TRANSPORT/nr_transport_proto_ue.h"
+
+#include "common/utils/LOG/log.h"
+#include "common/utils/system.h"
+#include "common/utils/LOG/vcd_signal_dumper.h"
+
+#include "T.h"
+
+#ifdef XFORMS
+  #include "PHY/TOOLS/nr_phy_scope.h"
+
+  extern char do_forms;
+#endif
+
+
+extern double cpuf;
+//static  nfapi_nr_config_request_t config_t;
+//static  nfapi_nr_config_request_t* config =&config_t;
+
+/*
+ *  NR SLOT PROCESSING SEQUENCE
+ *
+ *  Processing occurs with following steps for connected mode:
+ *
+ *  - Rx samples for a slot are received,
+ *  - PDCCH processing (including DCI extraction for downlink and uplink),
+ *  - PDSCH processing (including transport blocks decoding),
+ *  - PUCCH/PUSCH (transmission of acknowledgements, CSI, ... or data).
+ *
+ *  Time between reception of the slot and related transmission depends on UE processing performance.
+ *  It is defined by the value NR_UE_CAPABILITY_SLOT_RX_TO_TX.
+ *
+ *  In NR, network gives the duration between Rx slot and Tx slot in the DCI:
+ *  - for reception of a PDSCH and its associated acknowledgment slot (with a PUCCH or a PUSCH),
+ *  - for reception of an uplink grant and its associated PUSCH slot.
+ *
+ *  So duration between reception and it associated transmission depends on its transmission slot given in the DCI.
+ *  NR_UE_CAPABILITY_SLOT_RX_TO_TX means the minimum duration but higher duration can be given by the network because UE can support it.
+ *
+ *                                                                                                    Slot k
+ *                                                                                  -------+------------+--------
+ *                Frame                                                                    | Tx samples |
+ *                Subframe                                                                 |   buffer   |
+ *                Slot n                                                            -------+------------+--------
+ *       ------ +------------+--------                                                     |
+ *              | Rx samples |                                                             |
+ *              |   buffer   |                                                             |
+ *       -------+------------+--------                                                     |
+ *                           |                                                             |
+ *                           V                                                             |
+ *                           +------------+                                                |
+ *                           |   PDCCH    |                                                |
+ *                           | processing |                                                |
+ *                           +------------+                                                |
+ *                           |            |                                                |
+ *                           |            v                                                |
+ *                           |            +------------+                                   |
+ *                           |            |   PDSCH    |                                   |
+ *                           |            | processing | decoding result                   |
+ *                           |            +------------+    -> ACK/NACK of PDSCH           |
+ *                           |                         |                                   |
+ *                           |                         v                                   |
+ *                           |                         +-------------+------------+        |
+ *                           |                         | PUCCH/PUSCH | Tx samples |        |
+ *                           |                         |  processing | transfer   |        |
+ *                           |                         +-------------+------------+        |
+ *                           |                                                             |
+ *                           |/___________________________________________________________\|
+ *                            \  duration between reception and associated transmission   /
+ *
+ * Remark: processing is done slot by slot, it can be distribute on different threads which are executed in parallel.
+ * This is an architecture optimization in order to cope with real time constraints.
+ * By example, for LTE, subframe processing is spread over 4 different threads.
+ *
+ */
+
+#ifndef NO_RAT_NR
+  #define DURATION_RX_TO_TX           (NR_UE_CAPABILITY_SLOT_RX_TO_TX)  /* for NR this will certainly depends to such UE capability which is not yet defined */
+#else
+  #define DURATION_RX_TO_TX           (4)   /* For LTE, this duration is fixed to 4 and it is linked to LTE standard for both modes FDD/TDD */
+#endif
+
+#define FRAME_PERIOD    100000000ULL
+#define DAQ_PERIOD      66667ULL
+
+typedef enum {
+  pss=0,
+  pbch=1,
+  si=2
+} sync_mode_t;
+
+
+PHY_VARS_NR_UE *init_nr_ue_vars(NR_DL_FRAME_PARMS *frame_parms,
+                                uint8_t UE_id,
+                                uint8_t abstraction_flag)
+
+{
+  PHY_VARS_NR_UE *ue;
+  ue = (PHY_VARS_NR_UE *)malloc(sizeof(PHY_VARS_NR_UE));
+  memset(ue,0,sizeof(PHY_VARS_NR_UE));
+  memcpy(&(ue->frame_parms), frame_parms, sizeof(NR_DL_FRAME_PARMS));
+  ue->Mod_id      = UE_id;
+  ue->mac_enabled = 1;
+  // initialize all signal buffers
+  init_nr_ue_signal(ue,1,abstraction_flag);
+  // intialize transport
+  init_nr_ue_transport(ue,abstraction_flag);
+  return(ue);
+}
+
+/*!
+ * It performs band scanning and synchonization.
+ * \param arg is a pointer to a \ref PHY_VARS_NR_UE structure.
+ */
+
+typedef struct syncData_s {
+  UE_nr_rxtx_proc_t proc;
+  PHY_VARS_NR_UE *UE;
+} syncData_t;
+
+static void UE_synch(void *arg) {
+  syncData_t *syncD=(syncData_t *) arg;
+  int i, hw_slot_offset;
+  PHY_VARS_NR_UE *UE = syncD->UE;
+  sync_mode_t sync_mode = pbch;
+  int CC_id = UE->CC_id;
+  int freq_offset=0;
+  UE->is_synchronized = 0;
+
+  if (UE->UE_scan == 0) {
+    get_band(downlink_frequency[CC_id][0], &UE->frame_parms.eutra_band,   &uplink_frequency_offset[CC_id][0], &UE->frame_parms.frame_type);
+    LOG_I( PHY, "[SCHED][UE] Check absolute frequency DL %"PRIu32", UL %"PRIu32" (oai_exit %d, rx_num_channels %d)\n",
+           downlink_frequency[0][0], downlink_frequency[0][0]+uplink_frequency_offset[0][0],
+           oai_exit, openair0_cfg[0].rx_num_channels);
+
+    for (i=0; i<openair0_cfg[UE->rf_map.card].rx_num_channels; i++) {
+      openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i];
+      openair0_cfg[UE->rf_map.card].tx_freq[UE->rf_map.chain+i] =
+        downlink_frequency[CC_id][i]+uplink_frequency_offset[CC_id][i];
+      openair0_cfg[UE->rf_map.card].autocal[UE->rf_map.chain+i] = 1;
+
+      if (uplink_frequency_offset[CC_id][i] != 0) //
+        openair0_cfg[UE->rf_map.card].duplex_mode = duplex_mode_FDD;
+      else //FDD
+        openair0_cfg[UE->rf_map.card].duplex_mode = duplex_mode_TDD;
+    }
+
+    sync_mode = pbch;
+  } else {
+    LOG_E(PHY,"Fixme!\n");
+    /*
+    for (i=0; i<openair0_cfg[UE->rf_map.card].rx_num_channels; i++) {
+      downlink_frequency[UE->rf_map.card][UE->rf_map.chain+i] = bands_to_scan.band_info[CC_id].dl_min;
+      uplink_frequency_offset[UE->rf_map.card][UE->rf_map.chain+i] =
+        bands_to_scan.band_info[CC_id].ul_min-bands_to_scan.band_info[CC_id].dl_min;
+      openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i];
+      openair0_cfg[UE->rf_map.card].tx_freq[UE->rf_map.chain+i] =
+        downlink_frequency[CC_id][i]+uplink_frequency_offset[CC_id][i];
+      openair0_cfg[UE->rf_map.card].rx_gain[UE->rf_map.chain+i] = UE->rx_total_gain_dB;
+    }
+    */
+  }
+
+  LOG_W(PHY, "Starting sync detection\n");
+
+  switch (sync_mode) {
+    /*
+    case pss:
+      LOG_I(PHY,"[SCHED][UE] Scanning band %d (%d), freq %u\n",bands_to_scan.band_info[current_band].band, current_band,bands_to_scan.band_info[current_band].dl_min+current_offset);
+      //lte_sync_timefreq(UE,current_band,bands_to_scan.band_info[current_band].dl_min+current_offset);
+      current_offset += 20000000; // increase by 20 MHz
+
+      if (current_offset > bands_to_scan.band_info[current_band].dl_max-bands_to_scan.band_info[current_band].dl_min) {
+        current_band++;
+        current_offset=0;
+      }
+
+      if (current_band==bands_to_scan.nbands) {
+        current_band=0;
+        oai_exit=1;
+      }
+
+      for (i=0; i<openair0_cfg[UE->rf_map.card].rx_num_channels; i++) {
+        downlink_frequency[UE->rf_map.card][UE->rf_map.chain+i] = bands_to_scan.band_info[current_band].dl_min+current_offset;
+        uplink_frequency_offset[UE->rf_map.card][UE->rf_map.chain+i] = bands_to_scan.band_info[current_band].ul_min-bands_to_scan.band_info[0].dl_min + current_offset;
+        openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i];
+        openair0_cfg[UE->rf_map.card].tx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i]+uplink_frequency_offset[CC_id][i];
+        openair0_cfg[UE->rf_map.card].rx_gain[UE->rf_map.chain+i] = UE->rx_total_gain_dB;
+
+        if (UE->UE_scan_carrier) {
+          openair0_cfg[UE->rf_map.card].autocal[UE->rf_map.chain+i] = 1;
+        }
+      }
+
+      break;
+    */
+    case pbch:
+      LOG_I(PHY, "[UE thread Synch] Running Initial Synch (mode %d)\n",UE->mode);
+
+      if (nr_initial_sync( &syncD->proc, UE, UE->mode ) == 0) {
+        freq_offset = UE->common_vars.freq_offset; // frequency offset computed with pss in initial sync
+        hw_slot_offset = (UE->rx_offset<<1) / UE->frame_parms.samples_per_slot;
+        LOG_I(PHY,"Got synch: hw_slot_offset %d, carrier off %d Hz, rxgain %d (DL %u, UL %u), UE_scan_carrier %d\n",
+              hw_slot_offset,
+              freq_offset,
+              UE->rx_total_gain_dB,
+              downlink_frequency[0][0]+freq_offset,
+              downlink_frequency[0][0]+uplink_frequency_offset[0][0]+freq_offset,
+              UE->UE_scan_carrier );
+
+        // rerun with new cell parameters and frequency-offset
+        for (i=0; i<openair0_cfg[UE->rf_map.card].rx_num_channels; i++) {
+          openair0_cfg[UE->rf_map.card].rx_gain[UE->rf_map.chain+i] = UE->rx_total_gain_dB;//-USRP_GAIN_OFFSET;
+
+          if (freq_offset >= 0)
+            openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] += abs(freq_offset);
+          else
+            openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] -= abs(freq_offset);
+
+          openair0_cfg[UE->rf_map.card].tx_freq[UE->rf_map.chain+i] =
+            openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i]+uplink_frequency_offset[CC_id][i];
+          downlink_frequency[CC_id][i] = openair0_cfg[CC_id].rx_freq[i];
+        }
+
+        // reconfigure for potentially different bandwidth
+        switch(UE->frame_parms.N_RB_DL) {
+          case 6:
+            openair0_cfg[UE->rf_map.card].sample_rate =1.92e6;
+            openair0_cfg[UE->rf_map.card].rx_bw          =.96e6;
+            openair0_cfg[UE->rf_map.card].tx_bw          =.96e6;
+            //            openair0_cfg[0].rx_gain[0] -= 12;
+            break;
+
+          case 25:
+            openair0_cfg[UE->rf_map.card].sample_rate =7.68e6;
+            openair0_cfg[UE->rf_map.card].rx_bw          =2.5e6;
+            openair0_cfg[UE->rf_map.card].tx_bw          =2.5e6;
+            //            openair0_cfg[0].rx_gain[0] -= 6;
+            break;
+
+          case 50:
+            openair0_cfg[UE->rf_map.card].sample_rate =15.36e6;
+            openair0_cfg[UE->rf_map.card].rx_bw          =5.0e6;
+            openair0_cfg[UE->rf_map.card].tx_bw          =5.0e6;
+            //            openair0_cfg[0].rx_gain[0] -= 3;
+            break;
+
+          case 100:
+            openair0_cfg[UE->rf_map.card].sample_rate=30.72e6;
+            openair0_cfg[UE->rf_map.card].rx_bw=10.0e6;
+            openair0_cfg[UE->rf_map.card].tx_bw=10.0e6;
+            //            openair0_cfg[0].rx_gain[0] -= 0;
+            break;
+        }
+
+        if (UE->mode != loop_through_memory) {
+          UE->rfdevice.trx_set_freq_func(&UE->rfdevice,&openair0_cfg[0],0);
+          //UE->rfdevice.trx_set_gains_func(&openair0,&openair0_cfg[0]);
+          //UE->rfdevice.trx_stop_func(&UE->rfdevice);
+          // sleep(1);
+          //nr_init_frame_parms_ue(&UE->frame_parms);
+          /*if (UE->rfdevice.trx_start_func(&UE->rfdevice) != 0 ) {
+            LOG_E(HW,"Could not start the device\n");
+            oai_exit=1;
+            }*/
+        }
+
+        if (UE->UE_scan_carrier == 1) {
+          UE->UE_scan_carrier = 0;
+        } else {
+          UE->is_synchronized = 1;
+        }
+      } else {
+        // initial sync failed
+        // calculate new offset and try again
+        if (UE->UE_scan_carrier == 1) {
+          if (freq_offset >= 0)
+            freq_offset += 100;
+
+          freq_offset *= -1;
+          LOG_I(PHY, "[initial_sync] trying carrier off %d Hz, rxgain %d (DL %u, UL %u)\n",
+                freq_offset,
+                UE->rx_total_gain_dB,
+                downlink_frequency[0][0]+freq_offset,
+                downlink_frequency[0][0]+uplink_frequency_offset[0][0]+freq_offset );
+
+          for (i=0; i<openair0_cfg[UE->rf_map.card].rx_num_channels; i++) {
+            openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i]+freq_offset;
+            openair0_cfg[UE->rf_map.card].tx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i]+uplink_frequency_offset[CC_id][i]+freq_offset;
+            openair0_cfg[UE->rf_map.card].rx_gain[UE->rf_map.chain+i] = UE->rx_total_gain_dB;//-USRP_GAIN_OFFSET;
+
+            if (UE->UE_scan_carrier==1)
+              openair0_cfg[UE->rf_map.card].autocal[UE->rf_map.chain+i] = 1;
+          }
+
+          if (UE->mode != loop_through_memory)
+            UE->rfdevice.trx_set_freq_func(&UE->rfdevice,&openair0_cfg[0],0);
+        }// initial_sync=0
+
+        break;
+
+      case si:
+      default:
+        break;
+      }
+  }
+}
+
+void processSubframeRX( PHY_VARS_NR_UE *UE, UE_nr_rxtx_proc_t *proc) {
+  // Process Rx data for one sub-frame
+  if (slot_select_nr(&UE->frame_parms, proc->frame_tx, proc->nr_tti_tx) & NR_DOWNLINK_SLOT) {
+    //clean previous FAPI MESSAGE
+    UE->rx_ind.number_pdus = 0;
+    UE->dci_ind.number_of_dcis = 0;
+    //clean previous FAPI MESSAGE
+    // call L2 for DL_CONFIG (DCI)
+    UE->dcireq.module_id = UE->Mod_id;
+    UE->dcireq.gNB_index = 0;
+    UE->dcireq.cc_id     = 0;
+    UE->dcireq.frame     = proc->frame_rx;
+    UE->dcireq.slot      = proc->nr_tti_rx;
+    nr_ue_dcireq(&UE->dcireq); //to be replaced with function pointer later
+    NR_UE_MAC_INST_t *UE_mac = get_mac_inst(0);
+    UE_mac->scheduled_response.dl_config = &UE->dcireq.dl_config_req;
+    UE_mac->scheduled_response.ul_config = NULL;
+    UE_mac->scheduled_response.tx_request = NULL;
+    UE_mac->scheduled_response.module_id = UE->Mod_id;
+    UE_mac->scheduled_response.CC_id     = 0;
+    UE_mac->scheduled_response.frame = proc->frame_rx;
+    UE_mac->scheduled_response.slot  = proc->nr_tti_rx;
+    nr_ue_scheduled_response(&UE_mac->scheduled_response);
+    //write_output("uerxdata_frame.m", "uerxdata_frame", UE->common_vars.rxdata[0], UE->frame_parms.samples_per_frame, 1, 1);
+#ifdef UE_SLOT_PARALLELISATION
+    phy_procedures_slot_parallelization_nrUE_RX( UE, proc, 0, 0, 1, UE->mode, no_relay, NULL );
+#else
+    uint64_t a=rdtsc();
+    phy_procedures_nrUE_RX( UE, proc, 0, 1, UE->mode);
+    LOG_D(PHY,"phy_procedures_nrUE_RX: slot:%d, time %lu\n", proc->nr_tti_rx, (rdtsc()-a)/3500);
+    //            printf(">>> nr_ue_pdcch_procedures ended\n");
+#endif
+  }
+
+  if (UE->mac_enabled==1) {
+    //  trigger L2 to run ue_scheduler thru IF module
+    //  [TODO] mapping right after NR initial sync
+    if(UE->if_inst != NULL && UE->if_inst->ul_indication != NULL) {
+      UE->ul_indication.module_id = 0;
+      UE->ul_indication.gNB_index = 0;
+      UE->ul_indication.cc_id = 0;
+      UE->ul_indication.frame = proc->frame_rx;
+      UE->ul_indication.slot = proc->nr_tti_rx;
+      UE->if_inst->ul_indication(&UE->ul_indication);
+    }
+  }
+}
+
+/*!
+ * \brief This is the UE thread for RX subframe n and TX subframe n+4.
+ * This thread performs the phy_procedures_UE_RX() on every received slot.
+ * then, if TX is enabled it performs TX for n+4.
+ * \param arg is a pointer to a \ref PHY_VARS_NR_UE structure.
+ * \returns a pointer to an int. The storage is not on the heap and must not be freed.
+ */
+
+typedef struct processingData_s {
+  UE_nr_rxtx_proc_t proc;
+  PHY_VARS_NR_UE    *UE;
+}  processingData_t;
+
+void UE_processing(void *arg) {
+  processingData_t *rxtxD=(processingData_t *) arg;
+  UE_nr_rxtx_proc_t *proc = &rxtxD->proc;
+  PHY_VARS_NR_UE    *UE   = rxtxD->UE;
+  processSubframeRX(UE, proc);
+  //printf(">>> mac ended\n");
+  // Prepare the future Tx data
+#if 0
+#ifndef NO_RAT_NR
+
+  if (slot_select_nr(&UE->frame_parms, proc->frame_tx, proc->nr_tti_tx) & NR_UPLINK_SLOT)
+#else
+  if ((subframe_select( &UE->frame_parms, proc->subframe_tx) == SF_UL) ||
+      (UE->frame_parms.frame_type == FDD) )
+#endif
+    if (UE->mode != loop_through_memory)
+      phy_procedures_nrUE_TX(UE,proc,0,0,UE->mode,no_relay);
+
+  //phy_procedures_UE_TX(UE,proc,0,0,UE->mode,no_relay);
+#endif
+#if 0
+
+  if ((subframe_select( &UE->frame_parms, proc->subframe_tx) == SF_S) &&
+      (UE->frame_parms.frame_type == TDD))
+    if (UE->mode != loop_through_memory)
+      //phy_procedures_UE_S_TX(UE,0,0,no_relay);
+      updateTimes(current, &t3, 10000, timing_proc_name);
+
+#endif
+}
+
+void readFrame(PHY_VARS_NR_UE *UE,  openair0_timestamp *timestamp) {
+  void *rxp[NB_ANTENNAS_RX];
+  void *dummy_tx[UE->frame_parms.nb_antennas_tx];
+
+  for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
+    dummy_tx[i]=malloc16_clear(UE->frame_parms.samples_per_subframe*4);
+
+  for(int x=0; x<10; x++) {
+    for (int i=0; i<UE->frame_parms.nb_antennas_rx; i++)
+      rxp[i] = ((void *)&UE->common_vars.rxdata[i][0]) + 4*x*UE->frame_parms.samples_per_subframe;
+
+    AssertFatal( UE->frame_parms.samples_per_subframe ==
+                 UE->rfdevice.trx_read_func(&UE->rfdevice,
+                                            timestamp,
+                                            rxp,
+                                            UE->frame_parms.samples_per_subframe,
+                                            UE->frame_parms.nb_antennas_rx), "");
+  }
+
+  for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
+    free(dummy_tx[i]);
+}
+
+void trashFrame(PHY_VARS_NR_UE *UE, openair0_timestamp *timestamp) {
+  void *dummy_tx[UE->frame_parms.nb_antennas_tx];
+
+  for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
+    dummy_tx[i]=malloc16_clear(UE->frame_parms.samples_per_subframe*4);
+
+  void *dummy_rx[UE->frame_parms.nb_antennas_rx];
+
+  for (int i=0; i<UE->frame_parms.nb_antennas_rx; i++)
+    dummy_rx[i]=malloc16(UE->frame_parms.samples_per_subframe*4);
+
+  for (int sf=0; sf<NR_NUMBER_OF_SUBFRAMES_PER_FRAME; sf++) {
+    //      printf("Reading dummy sf %d\n",sf);
+    UE->rfdevice.trx_read_func(&UE->rfdevice,
+                               timestamp,
+                               dummy_rx,
+                               UE->frame_parms.samples_per_subframe,
+                               UE->frame_parms.nb_antennas_rx);
+  }
+
+  for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
+    free(dummy_tx[i]);
+
+  for (int i=0; i<UE->frame_parms.nb_antennas_rx; i++)
+    free(dummy_rx[i]);
+}
+
+void syncInFrame(PHY_VARS_NR_UE *UE, openair0_timestamp *timestamp) {
+  if (UE->no_timing_correction==0) {
+    LOG_I(PHY,"Resynchronizing RX by %d samples (mode = %d)\n",UE->rx_offset,UE->mode);
+    void *dummy_tx[UE->frame_parms.nb_antennas_tx];
+
+    for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
+      dummy_tx[i]=malloc16_clear(UE->frame_parms.samples_per_subframe*4);
+
+    for ( int size=UE->rx_offset ; size > 0 ; size -= UE->frame_parms.samples_per_subframe ) {
+      int unitTransfer=size>UE->frame_parms.samples_per_subframe ? UE->frame_parms.samples_per_subframe : size ;
+      AssertFatal(unitTransfer ==
+                  UE->rfdevice.trx_read_func(&UE->rfdevice,
+                                             timestamp,
+                                             (void **)UE->common_vars.rxdata,
+                                             unitTransfer,
+                                             UE->frame_parms.nb_antennas_rx),"");
+    }
+
+    for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
+      free(dummy_tx[i]);
+  }
+}
+
+int computeSamplesShift(PHY_VARS_NR_UE *UE) {
+  if ( getenv("RFSIMULATOR") != 0) {
+    LOG_E(PHY,"SET rx_offset %d \n",UE->rx_offset);
+    //UE->rx_offset_diff=0;
+    return 0;
+  }
+
+  // compute TO compensation that should be applied for this frame
+  if ( UE->rx_offset < UE->frame_parms.samples_per_frame/2  &&
+       UE->rx_offset > 0 ) {
+    //LOG_I(PHY,"!!!adjusting -1 samples!!!\n");
+    return -1 ;
+  }
+
+  if ( UE->rx_offset > UE->frame_parms.samples_per_frame/2 &&
+       UE->rx_offset < UE->frame_parms.samples_per_frame ) {
+    //LOG_I(PHY,"!!!adjusting +1 samples!!!\n");
+    return 1;
+  }
+
+  return 0;
+}
+
+void *UE_thread(void *arg) {
+  //this thread should be over the processing thread to keep in real time
+  PHY_VARS_NR_UE *UE = (PHY_VARS_NR_UE *) arg;
+  //  int tx_enabled = 0;
+  openair0_timestamp timestamp;
+  void *rxp[NB_ANTENNAS_RX], *txp[NB_ANTENNAS_TX];
+  int start_rx_stream = 0;
+  const uint16_t table_sf_slot[20] = {0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9};
+  AssertFatal(0== openair0_device_load(&(UE->rfdevice), &openair0_cfg[0]), "");
+  UE->rfdevice.host_type = RAU_HOST;
+  AssertFatal(UE->rfdevice.trx_start_func(&UE->rfdevice) == 0, "Could not start the device\n");
+  notifiedFIFO_t nf;
+  initNotifiedFIFO(&nf);
+  int nbSlotProcessing=0;
+  int thread_idx=0;
+  notifiedFIFO_t freeBlocks;
+  initNotifiedFIFO_nothreadSafe(&freeBlocks);
+
+  for (int i=0; i<RX_NB_TH+1; i++)  // RX_NB_TH working + 1 we are making to be pushed
+    pushNotifiedFIFO_nothreadSafe(&freeBlocks,
+                                  newNotifiedFIFO_elt(sizeof(processingData_t), 0,&nf,UE_processing));
+
+  bool syncRunning=false;
+  const int nb_slot_frame = 10*UE->frame_parms.slots_per_subframe;
+  int absolute_slot=0, decoded_frame_rx=INT_MAX, trashed_frames=0;
+
+  while (!oai_exit) {
+    if (syncRunning) {
+      notifiedFIFO_elt_t *res=tryPullTpool(&nf, Tpool);
+
+      if (res) {
+        syncRunning=false;
+        syncData_t *tmp=(syncData_t *)NotifiedFifoData(res);
+        // shift the frame index with all the frames we trashed meanwhile we perform the synch search
+        decoded_frame_rx=(tmp->proc.decoded_frame_rx+trashed_frames) % MAX_FRAME_NUMBER;
+        delNotifiedFIFO_elt(res);
+      } else {
+        trashFrame(UE, &timestamp);
+        trashed_frames++;
+        continue;
+      }
+    }
+
+    AssertFatal( !syncRunning, "At this point synchronisation can't be running\n");
+
+    if (!UE->is_synchronized) {
+      readFrame(UE, &timestamp);
+      notifiedFIFO_elt_t *Msg=newNotifiedFIFO_elt(sizeof(syncData_t),0,&nf,UE_synch);
+      syncData_t *syncMsg=(syncData_t *)NotifiedFifoData(Msg);
+      syncMsg->UE=UE;
+      memset(&syncMsg->proc, 0, sizeof(syncMsg->proc));
+      pushTpool(Tpool, Msg);
+      trashed_frames=0;
+      syncRunning=true;
+      continue;
+    }
+
+    if (start_rx_stream==0) {
+      start_rx_stream=1;
+      syncInFrame(UE, &timestamp);
+      UE->rx_offset=0;
+      UE->time_sync_cell=0;
+      // read in first symbol
+      AssertFatal (UE->frame_parms.ofdm_symbol_size+UE->frame_parms.nb_prefix_samples0 ==
+                   UE->rfdevice.trx_read_func(&UE->rfdevice,
+                                              &timestamp,
+                                              (void **)UE->common_vars.rxdata,
+                                              UE->frame_parms.ofdm_symbol_size+UE->frame_parms.nb_prefix_samples0,
+                                              UE->frame_parms.nb_antennas_rx),"");
+      // we have the decoded frame index in the return of the synch process
+      // and we shifted above to the first slot of next frame
+      decoded_frame_rx++;
+      // we do ++ first in the regular processing, so it will be beging of frame;
+      absolute_slot=decoded_frame_rx*nb_slot_frame + nb_slot_frame -1;
+      continue;
+    }
+
+    absolute_slot++;
+    // whatever means thread_idx
+    // Fix me: will be wrong when slot 1 is slow, as slot 2 finishes
+    // Slot 3 will overlap if RX_NB_TH is 2
+    // this is general failure in UE !!!
+    thread_idx = absolute_slot % RX_NB_TH;
+    int slot_nr = absolute_slot % nb_slot_frame;
+    notifiedFIFO_elt_t *msgToPush;
+    AssertFatal((msgToPush=pullNotifiedFIFO_nothreadSafe(&freeBlocks)) != NULL,"chained list failure");
+    processingData_t *curMsg=(processingData_t *)NotifiedFifoData(msgToPush);
+    curMsg->UE=UE;
+    // update thread index for received subframe
+    curMsg->proc.nr_tti_rx= slot_nr;
+    curMsg->UE->current_thread_id[slot_nr] = thread_idx;
+    curMsg->proc.subframe_rx=table_sf_slot[slot_nr];
+    curMsg->proc.nr_tti_tx = (absolute_slot + DURATION_RX_TO_TX) % nb_slot_frame;
+    curMsg->proc.subframe_tx=curMsg->proc.nr_tti_rx;
+    curMsg->proc.frame_rx = ( absolute_slot/nb_slot_frame ) % MAX_FRAME_NUMBER;
+    curMsg->proc.frame_tx = ( (absolute_slot + DURATION_RX_TO_TX) /nb_slot_frame ) % MAX_FRAME_NUMBER;
+    curMsg->proc.decoded_frame_rx=-1;
+    LOG_D(PHY,"Process slot %d thread Idx %d \n", slot_nr, thread_idx);
+
+    for (int i=0; i<UE->frame_parms.nb_antennas_rx; i++)
+      rxp[i] = (void *)&UE->common_vars.rxdata[i][UE->frame_parms.ofdm_symbol_size+
+               UE->frame_parms.nb_prefix_samples0+
+               slot_nr*UE->frame_parms.samples_per_slot];
+
+    for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
+      txp[i] = (void *)&UE->common_vars.txdata[i][curMsg->proc.nr_tti_tx*UE->frame_parms.samples_per_slot];
+
+    int readBlockSize, writeBlockSize;
+
+    if (slot_nr<(nb_slot_frame - 1)) {
+      readBlockSize=UE->frame_parms.samples_per_slot;
+      writeBlockSize=UE->frame_parms.samples_per_slot;
+    } else {
+      UE->rx_offset_diff = computeSamplesShift(UE);
+      readBlockSize=UE->frame_parms.samples_per_slot -
+                    UE->frame_parms.ofdm_symbol_size -
+                    UE->frame_parms.nb_prefix_samples0 -
+                    UE->rx_offset_diff;
+      writeBlockSize=UE->frame_parms.samples_per_slot -
+                     UE->rx_offset_diff;
+    }
+
+    AssertFatal(readBlockSize ==
+                UE->rfdevice.trx_read_func(&UE->rfdevice,
+                                           &timestamp,
+                                           rxp,
+                                           readBlockSize,
+                                           UE->frame_parms.nb_antennas_rx),"");
+    AssertFatal( writeBlockSize ==
+                 UE->rfdevice.trx_write_func(&UE->rfdevice,
+                     timestamp+
+                     (2*UE->frame_parms.samples_per_slot) -
+                     UE->frame_parms.ofdm_symbol_size-UE->frame_parms.nb_prefix_samples0 -
+                     openair0_cfg[0].tx_sample_advance,
+                     txp,
+                     writeBlockSize,
+                     UE->frame_parms.nb_antennas_tx,
+                     1),"");
+
+    if( slot_nr==(nb_slot_frame-1)) {
+      // read in first symbol of next frame and adjust for timing drift
+      int first_symbols=writeBlockSize-readBlockSize;
+
+      if ( first_symbols > 0 )
+        AssertFatal(first_symbols ==
+                    UE->rfdevice.trx_read_func(&UE->rfdevice,
+                                               &timestamp,
+                                               (void **)UE->common_vars.rxdata,
+                                               first_symbols,
+                                               UE->frame_parms.nb_antennas_rx),"");
+      else
+        LOG_E(PHY,"can't compensate: diff =%d\n", first_symbols);
+    }
+
+    curMsg->proc.timestamp_tx = timestamp+
+                                (DURATION_RX_TO_TX*UE->frame_parms.samples_per_slot)-
+                                UE->frame_parms.ofdm_symbol_size-UE->frame_parms.nb_prefix_samples0;
+    notifiedFIFO_elt_t *res;
+
+    while (nbSlotProcessing >= RX_NB_TH) {
+      if ( (res=tryPullTpool(&nf, Tpool)) != NULL ) {
+        nbSlotProcessing--;
+        processingData_t *tmp=(processingData_t *)res->msgData;
+
+        if (tmp->proc.decoded_frame_rx != -1)
+          decoded_frame_rx=tmp->proc.decoded_frame_rx;
+
+        pushNotifiedFIFO_nothreadSafe(&freeBlocks,res);
+      }
+
+      usleep(200);
+    }
+
+    if (  decoded_frame_rx != curMsg->proc.frame_rx &&
+          ((decoded_frame_rx+1) % MAX_FRAME_NUMBER) != curMsg->proc.frame_rx )
+      LOG_D(PHY,"Decoded frame index (%d) is not compatible with current context (%d), UE should go back to synch mode\n",
+            decoded_frame_rx, curMsg->proc.frame_rx  );
+
+    nbSlotProcessing++;
+    msgToPush->key=slot_nr;
+    pushTpool(Tpool, msgToPush);
+
+    if (getenv("RFSIMULATOR")) {
+      // FixMe: Wait previous thread is done, because race conditions seems too bad
+      // in case of actual RF board, the overlap between threads mitigate the issue
+      // We must receive one message, that proves the slot processing is done
+      res=pullTpool(&nf, Tpool);
+      nbSlotProcessing--;
+      processingData_t *tmp=(processingData_t *)res->msgData;
+
+      if (tmp->proc.decoded_frame_rx != -1)
+        decoded_frame_rx=tmp->proc.decoded_frame_rx;
+
+      pushNotifiedFIFO_nothreadSafe(&freeBlocks,res);
+    }
+  } // while !oai_exit
+
+  return NULL;
+}
+
+void init_UE(int nb_inst) {
+  int inst;
+  NR_UE_MAC_INST_t *mac_inst;
+  pthread_t threads[nb_inst];
+
+  for (inst=0; inst < nb_inst; inst++) {
+    PHY_VARS_NR_UE *UE = PHY_vars_UE_g[inst][0];
+    AssertFatal((UE->if_inst = nr_ue_if_module_init(inst)) != NULL, "can not initial IF module\n");
+    nr_l3_init_ue();
+    nr_l2_init_ue();
+    mac_inst = get_mac_inst(inst);
+    mac_inst->if_module = UE->if_inst;
+    // Initial bandwidth part configuration -- full carrier bandwidth
+    mac_inst->initial_bwp_dl.bwp_id = 0;
+    mac_inst->initial_bwp_dl.location = 0;
+    mac_inst->initial_bwp_dl.scs = UE->frame_parms.subcarrier_spacing;
+    mac_inst->initial_bwp_dl.N_RB = UE->frame_parms.N_RB_DL;
+    mac_inst->initial_bwp_dl.cyclic_prefix = UE->frame_parms.Ncp;
+    mac_inst->initial_bwp_ul.bwp_id = 0;
+    mac_inst->initial_bwp_ul.location = 0;
+    mac_inst->initial_bwp_ul.scs = UE->frame_parms.subcarrier_spacing;
+    mac_inst->initial_bwp_ul.N_RB = UE->frame_parms.N_RB_UL;
+    mac_inst->initial_bwp_ul.cyclic_prefix = UE->frame_parms.Ncp;
+    LOG_I(PHY,"Intializing UE Threads for instance %d (%p,%p)...\n",inst,PHY_vars_UE_g[inst],PHY_vars_UE_g[inst][0]);
+    threadCreate(&threads[inst], UE_thread, (void *)UE, "UEthread", -1, OAI_PRIORITY_RT_MAX);
+  }
+
+  printf("UE threads created by %ld\n", gettid());
+}
+
diff --git a/executables/nr-uesoftmodem.c b/executables/nr-uesoftmodem.c
new file mode 100644
index 0000000000..8300f10675
--- /dev/null
+++ b/executables/nr-uesoftmodem.c
@@ -0,0 +1,775 @@
+/*
+ * 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
+ */
+
+
+#define _GNU_SOURCE             /* See feature_test_macros(7) */
+#include <sched.h>
+
+#include "T.h"
+#include "assertions.h"
+#include "PHY/types.h"
+#include "PHY/defs_nr_UE.h"
+#include "common/ran_context.h"
+#include "common/config/config_userapi.h"
+#include "common/utils/load_module_shlib.h"
+//#undef FRAME_LENGTH_COMPLEX_SAMPLES //there are two conflicting definitions, so we better make sure we don't use it at all
+
+#include "../../ARCH/COMMON/common_lib.h"
+#include "../../ARCH/ETHERNET/USERSPACE/LIB/if_defs.h"
+
+//#undef FRAME_LENGTH_COMPLEX_SAMPLES //there are two conflicting definitions, so we better make sure we don't use it at all
+
+#include "PHY/phy_vars_nr_ue.h"
+#include "PHY/LTE_TRANSPORT/transport_vars.h"
+#include "SCHED/sched_common_vars.h"
+#include "PHY/MODULATION/modulation_vars.h"
+//#include "../../SIMU/USER/init_lte.h"
+
+#include "LAYER2/MAC/mac_vars.h"
+#include "LAYER2/MAC/mac_proto.h"
+#include "RRC/LTE/rrc_vars.h"
+#include "PHY_INTERFACE/phy_interface_vars.h"
+
+#ifdef SMBV
+#include "PHY/TOOLS/smbv.h"
+unsigned short config_frames[4] = {2,9,11,13};
+#endif
+#include "common/utils/LOG/log.h"
+#include "common/utils/LOG/vcd_signal_dumper.h"
+
+#include "UTIL/OPT/opt.h"
+#include "enb_config.h"
+//#include "PHY/TOOLS/time_meas.h"
+
+#ifndef OPENAIR2
+  #include "UTIL/OTG/otg_vars.h"
+#endif
+
+#include "intertask_interface.h"
+
+#include "PHY/INIT/phy_init.h"
+#include "system.h"
+#include <openair2/RRC/NR_UE/rrc_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>
+
+#ifdef XFORMS
+#include <forms.h>
+
+/* Callbacks, globals and object handlers */
+
+extern void reset_stats( FL_OBJECT *, long );
+
+/* Forms and Objects */
+
+typedef struct {
+  FL_FORM    *stats_form;
+  void       *vdata;
+  char       *cdata;
+  long        ldata;
+  FL_OBJECT *stats_text;
+  FL_OBJECT *stats_button;
+} FD_stats_form;
+
+extern FD_stats_form *create_form_stats_form( void );
+
+#include "PHY/TOOLS/nr_phy_scope.h"
+//#include "stats.h"
+// current status is that every UE has a DL scope for a SINGLE eNB (eNB_id=0)
+// at eNB 0, an UL scope for every UE
+FD_phy_scope_nrue  *form_nrue[NUMBER_OF_UE_MAX];
+//FD_lte_phy_scope_enb *form_enb[MAX_NUM_CCs][NUMBER_OF_UE_MAX];
+//FD_stats_form                  *form_stats=NULL,*form_stats_l2=NULL;
+char title[255];
+unsigned char                   scope_enb_num_ue = 2;
+static pthread_t                forms_thread; //xforms
+#endif //XFORMS
+#include <executables/nr-uesoftmodem.h>
+
+RAN_CONTEXT_t RC;
+volatile int             start_eNB = 0;
+volatile int             start_UE = 0;
+volatile int             oai_exit = 0;
+
+static clock_source_t clock_source = internal;
+int                      single_thread_flag=1;
+
+int                      threequarter_fs=0;
+
+uint32_t                 downlink_frequency[MAX_NUM_CCs][4];
+int32_t                  uplink_frequency_offset[MAX_NUM_CCs][4];
+
+extern int16_t nr_dlsch_demod_shift;
+
+int UE_scan = 0;
+int UE_scan_carrier = 0;
+int UE_fo_compensation = 0;
+runmode_t mode = normal_txrx;
+openair0_config_t openair0_cfg[MAX_CARDS];
+
+#if MAX_NUM_CCs == 1
+rx_gain_t                rx_gain_mode[MAX_NUM_CCs][4] = {{max_gain,max_gain,max_gain,max_gain}};
+double tx_gain[MAX_NUM_CCs][4] = {{20,0,0,0}};
+double rx_gain[MAX_NUM_CCs][4] = {{110,0,0,0}};
+#else
+rx_gain_t                rx_gain_mode[MAX_NUM_CCs][4] = {{max_gain,max_gain,max_gain,max_gain},{max_gain,max_gain,max_gain,max_gain}};
+double tx_gain[MAX_NUM_CCs][4] = {{20,0,0,0},{20,0,0,0}};
+double rx_gain[MAX_NUM_CCs][4] = {{110,0,0,0},{20,0,0,0}};
+#endif
+
+double rx_gain_off = 0.0;
+
+double sample_rate=30.72e6;
+double bw = 10.0e6;
+
+static int  tx_max_power[MAX_NUM_CCs] = {0};
+
+char   rf_config_file[1024];
+
+int chain_offset=0;
+int phy_test = 0;
+uint8_t usim_test = 0;
+
+uint8_t dci_Format = 0;
+uint8_t agregation_Level =0xFF;
+
+uint8_t nb_antenna_tx = 1;
+uint8_t nb_antenna_rx = 1;
+
+char ref[128] = "internal";
+char channels[128] = "0";
+
+char *parallel_config = NULL;
+char *worker_config = NULL;
+
+static THREAD_STRUCT thread_struct;
+void set_parallel_conf(char *parallel_conf) {
+  if(strcmp(parallel_conf,"PARALLEL_SINGLE_THREAD")==0)           thread_struct.parallel_conf = PARALLEL_SINGLE_THREAD;
+  else if(strcmp(parallel_conf,"PARALLEL_RU_L1_SPLIT")==0)        thread_struct.parallel_conf = PARALLEL_RU_L1_SPLIT;
+  else if(strcmp(parallel_conf,"PARALLEL_RU_L1_TRX_SPLIT")==0)    thread_struct.parallel_conf = PARALLEL_RU_L1_TRX_SPLIT;
+
+  printf("[CONFIG] parallel conf is set to %d\n",thread_struct.parallel_conf);
+}
+void set_worker_conf(char *worker_conf) {
+  if(strcmp(worker_conf,"WORKER_DISABLE")==0)                     thread_struct.worker_conf = WORKER_DISABLE;
+  else if(strcmp(worker_conf,"WORKER_ENABLE")==0)                 thread_struct.worker_conf = WORKER_ENABLE;
+
+  printf("[CONFIG] worker conf is set to %d\n",thread_struct.worker_conf);
+}
+PARALLEL_CONF_t get_thread_parallel_conf(void) {
+  return thread_struct.parallel_conf;
+}
+WORKER_CONF_t get_thread_worker_conf(void) {
+  return thread_struct.worker_conf;
+}
+int                         rx_input_level_dBm;
+
+//static int                      online_log_messages=0;
+
+#ifdef XFORMS
+  extern int                      otg_enabled;
+  int                             do_forms=0;
+#else
+  int                             otg_enabled;
+#endif
+//int                             number_of_cards =   1;
+
+static NR_DL_FRAME_PARMS      *frame_parms[MAX_NUM_CCs];
+int16_t   node_synch_ref[MAX_NUM_CCs];
+
+uint32_t target_dl_mcs = 28; //maximum allowed mcs
+uint32_t target_ul_mcs = 20;
+uint32_t timing_advance = 0;
+uint8_t exit_missed_slots=1;
+uint64_t num_missed_slots=0; // counter for the number of missed slots
+
+
+int transmission_mode=1;
+int numerology = 0;
+
+/* flag set by eNB conf file to specify if the radio head is local or remote (default option is local) */
+//uint8_t local_remote_radio = BBU_LOCAL_RADIO_HEAD;
+/* struct for ethernet specific parameters given in eNB conf file */
+//eth_params_t *eth_params;
+
+double cpuf;
+
+char uecap_xer[1024],uecap_xer_in=0;
+
+int oaisim_flag=0;
+int emulate_rf = 0;
+
+tpool_t *Tpool;
+
+char *usrp_args=NULL;
+char *usrp_clksrc=NULL;
+
+/* forward declarations */
+void set_default_frame_parms(NR_DL_FRAME_PARMS *frame_parms[MAX_NUM_CCs]);
+
+
+/* see file openair2/LAYER2/MAC/main.c for why abstraction_flag is needed
+ * this is very hackish - find a proper solution
+ */
+uint8_t abstraction_flag=0;
+
+/*---------------------BMC: timespec helpers -----------------------------*/
+
+struct timespec min_diff_time = { .tv_sec = 0, .tv_nsec = 0 };
+struct timespec max_diff_time = { .tv_sec = 0, .tv_nsec = 0 };
+
+struct timespec clock_difftime(struct timespec start, struct timespec end) {
+  struct timespec temp;
+
+  if ((end.tv_nsec-start.tv_nsec)<0) {
+    temp.tv_sec = end.tv_sec-start.tv_sec-1;
+    temp.tv_nsec = 1000000000+end.tv_nsec-start.tv_nsec;
+  } else {
+    temp.tv_sec = end.tv_sec-start.tv_sec;
+    temp.tv_nsec = end.tv_nsec-start.tv_nsec;
+  }
+
+  return temp;
+}
+
+void print_difftimes(void) {
+  LOG_I(HW,"difftimes min = %lu ns ; max = %lu ns\n", min_diff_time.tv_nsec, max_diff_time.tv_nsec);
+}
+
+void exit_function(const char *file, const char *function, const int line, const char *s) {
+  int CC_id;
+
+  if (s != NULL) {
+    printf("%s:%d %s() Exiting OAI softmodem: %s\n",file,line, function, s);
+  }
+
+  oai_exit = 1;
+
+  if (PHY_vars_UE_g && PHY_vars_UE_g[0]) {
+    for(CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
+      if (PHY_vars_UE_g[0][CC_id] && PHY_vars_UE_g[0][CC_id]->rfdevice.trx_end_func)
+        PHY_vars_UE_g[0][CC_id]->rfdevice.trx_end_func(&PHY_vars_UE_g[0][CC_id]->rfdevice);
+    }
+  }
+
+  sleep(1); //allow lte-softmodem threads to exit first
+  itti_terminate_tasks (TASK_UNKNOWN);
+}
+
+#ifdef XFORMS
+
+
+void reset_stats(FL_OBJECT *button, long arg) {
+  //int i,j,k;
+  /*PHY_VARS_eNB *phy_vars_eNB = PHY_vars_eNB_g[0][0];
+
+  for (i=0; i<NUMBER_OF_UE_MAX; i++) {
+      for (k=0; k<8; k++) { //harq_processes
+          for (j=0; j<phy_vars_eNB->dlsch[i][0]->Mlimit; j++) {
+              phy_vars_eNB->UE_stats[i].dlsch_NAK[k][j]=0;
+              phy_vars_eNB->UE_stats[i].dlsch_ACK[k][j]=0;
+              phy_vars_eNB->UE_stats[i].dlsch_trials[k][j]=0;
+          }
+
+          phy_vars_eNB->UE_stats[i].dlsch_l2_errors[k]=0;
+          phy_vars_eNB->UE_stats[i].ulsch_errors[k]=0;
+          phy_vars_eNB->UE_stats[i].ulsch_consecutive_errors=0;
+
+          for (j=0; j<phy_vars_eNB->ulsch[i]->Mlimit; j++) {
+              phy_vars_eNB->UE_stats[i].ulsch_decoding_attempts[k][j]=0;
+              phy_vars_eNB->UE_stats[i].ulsch_decoding_attempts_last[k][j]=0;
+              phy_vars_eNB->UE_stats[i].ulsch_round_errors[k][j]=0;
+              phy_vars_eNB->UE_stats[i].ulsch_round_fer[k][j]=0;
+          }
+      }
+
+      phy_vars_eNB->UE_stats[i].dlsch_sliding_cnt=0;
+      phy_vars_eNB->UE_stats[i].dlsch_NAK_round0=0;
+      phy_vars_eNB->UE_stats[i].dlsch_mcs_offset=0;
+  }*/
+}
+
+static void *scope_thread(void *arg) {
+  sleep(5);
+
+  while (!oai_exit) {
+    phy_scope_nrUE(form_nrue[0],
+                 PHY_vars_UE_g[0][0],
+                 0,0,1);
+    usleep(100*1000);
+  }
+
+  pthread_exit((void *)arg);
+}
+#endif
+
+void init_scope(void) {
+#ifdef XFORMS
+  int fl_argc=1;
+
+  if (do_forms==1) {
+    char *name="5G-UE-scope";
+    fl_initialize (&fl_argc, &name, NULL, 0, 0);
+    int UE_id = 0;
+    form_nrue[UE_id] = create_phy_scope_nrue();
+    sprintf (title, "NR DL SCOPE UE");
+    fl_show_form (form_nrue[UE_id]->phy_scope_nrue, FL_PLACE_HOTSPOT, FL_FULLBORDER, title);
+    threadCreate(&forms_thread, scope_thread, NULL, "scope", -1, OAI_PRIORITY_RT_LOW);
+  }
+
+#endif
+}
+
+
+#if defined(ENABLE_ITTI)
+void *l2l1_task(void *arg) {
+  MessageDef *message_p = NULL;
+  int         result;
+  itti_set_task_real_time(TASK_L2L1);
+  itti_mark_task_ready(TASK_L2L1);
+
+  do {
+    // Wait for a message
+    itti_receive_msg (TASK_L2L1, &message_p);
+
+    switch (ITTI_MSG_ID(message_p)) {
+      case TERMINATE_MESSAGE:
+        oai_exit=1;
+        itti_exit_task ();
+        break;
+
+      case ACTIVATE_MESSAGE:
+        start_UE = 1;
+        break;
+
+      case DEACTIVATE_MESSAGE:
+        start_UE = 0;
+        break;
+
+      case MESSAGE_TEST:
+        LOG_I(EMU, "Received %s\n", ITTI_MSG_NAME(message_p));
+        break;
+
+      default:
+        LOG_E(EMU, "Received unexpected message %s\n", ITTI_MSG_NAME(message_p));
+        break;
+    }
+
+    result = itti_free (ITTI_MSG_ORIGIN_ID(message_p), message_p);
+    AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result);
+  } while(!oai_exit);
+
+  return NULL;
+}
+#endif
+
+int16_t dlsch_demod_shift;
+
+static void get_options(void) {
+  int CC_id;
+  int tddflag=0, nonbiotflag;
+  char *loopfile=NULL;
+  int dumpframe=0;
+  uint32_t online_log_messages;
+  uint32_t glog_level, glog_verbosity;
+  uint32_t start_telnetsrv=0;
+  paramdef_t cmdline_params[] =CMDLINE_PARAMS_DESC ;
+  paramdef_t cmdline_logparams[] =CMDLINE_LOGPARAMS_DESC ;
+  config_process_cmdline( cmdline_params,sizeof(cmdline_params)/sizeof(paramdef_t),NULL);
+
+  if (strlen(in_path) > 0) {
+    opt_type = OPT_PCAP;
+    opt_enabled=1;
+    printf("Enabling OPT for PCAP  with the following file %s \n",in_path);
+  }
+
+  if (strlen(in_ip) > 0) {
+    opt_enabled=1;
+    opt_type = OPT_WIRESHARK;
+    printf("Enabling OPT for wireshark for local interface");
+  }
+
+  config_process_cmdline( cmdline_logparams,sizeof(cmdline_logparams)/sizeof(paramdef_t),NULL);
+
+  if(config_isparamset(cmdline_logparams,CMDLINE_ONLINELOG_IDX)) {
+    set_glog_onlinelog(online_log_messages);
+  }
+
+  if(config_isparamset(cmdline_logparams,CMDLINE_GLOGLEVEL_IDX)) {
+    set_glog(glog_level);
+  }
+
+  if (start_telnetsrv) {
+    load_module_shlib("telnetsrv",NULL,0,NULL);
+  }
+
+  paramdef_t cmdline_uemodeparams[] =CMDLINE_UEMODEPARAMS_DESC;
+  paramdef_t cmdline_ueparams[] =CMDLINE_UEPARAMS_DESC;
+  config_process_cmdline( cmdline_uemodeparams,sizeof(cmdline_uemodeparams)/sizeof(paramdef_t),NULL);
+  config_process_cmdline( cmdline_ueparams,sizeof(cmdline_ueparams)/sizeof(paramdef_t),NULL);
+
+  if ( (cmdline_uemodeparams[CMDLINE_CALIBUERX_IDX].paramflags &  PARAMFLAG_PARAMSET) != 0) mode = rx_calib_ue;
+
+  if ( (cmdline_uemodeparams[CMDLINE_CALIBUERXMED_IDX].paramflags &  PARAMFLAG_PARAMSET) != 0) mode = rx_calib_ue_med;
+
+  if ( (cmdline_uemodeparams[CMDLINE_CALIBUERXBYP_IDX].paramflags &  PARAMFLAG_PARAMSET) != 0) mode = rx_calib_ue_byp;
+
+  if (cmdline_uemodeparams[CMDLINE_DEBUGUEPRACH_IDX].uptr)
+    if ( *(cmdline_uemodeparams[CMDLINE_DEBUGUEPRACH_IDX].uptr) > 0) mode = debug_prach;
+
+  if (cmdline_uemodeparams[CMDLINE_NOL2CONNECT_IDX].uptr)
+    if ( *(cmdline_uemodeparams[CMDLINE_NOL2CONNECT_IDX].uptr) > 0)  mode = no_L2_connect;
+
+  if (cmdline_uemodeparams[CMDLINE_CALIBPRACHTX_IDX].uptr)
+    if ( *(cmdline_uemodeparams[CMDLINE_CALIBPRACHTX_IDX].uptr) > 0) mode = calib_prach_tx;
+
+  if (dumpframe  > 0)  mode = rx_dump_frame;
+
+  for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
+    frame_parms[CC_id]->dl_CarrierFreq = downlink_frequency[0][0];
+  }
+
+  UE_scan=0;
+
+  if (tddflag > 0) {
+    for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++)
+      frame_parms[CC_id]->frame_type = TDD;
+  }
+
+  /*if (frame_parms[0]->N_RB_DL !=0) {
+      if ( frame_parms[0]->N_RB_DL < 6 ) {
+       frame_parms[0]->N_RB_DL = 6;
+       printf ( "%i: Invalid number of ressource blocks, adjusted to 6\n",frame_parms[0]->N_RB_DL);
+      }
+      if ( frame_parms[0]->N_RB_DL > 100 ) {
+       frame_parms[0]->N_RB_DL = 100;
+       printf ( "%i: Invalid number of ressource blocks, adjusted to 100\n",frame_parms[0]->N_RB_DL);
+      }
+      if ( frame_parms[0]->N_RB_DL > 50 && frame_parms[0]->N_RB_DL < 100 ) {
+       frame_parms[0]->N_RB_DL = 50;
+       printf ( "%i: Invalid number of ressource blocks, adjusted to 50\n",frame_parms[0]->N_RB_DL);
+      }
+      if ( frame_parms[0]->N_RB_DL > 25 && frame_parms[0]->N_RB_DL < 50 ) {
+       frame_parms[0]->N_RB_DL = 25;
+       printf ( "%i: Invalid number of ressource blocks, adjusted to 25\n",frame_parms[0]->N_RB_DL);
+      }
+      UE_scan = 0;
+      frame_parms[0]->N_RB_UL=frame_parms[0]->N_RB_DL;
+      for (CC_id=1; CC_id<MAX_NUM_CCs; CC_id++) {
+        frame_parms[CC_id]->N_RB_DL=frame_parms[0]->N_RB_DL;
+        frame_parms[CC_id]->N_RB_UL=frame_parms[0]->N_RB_UL;
+      }
+  }*/
+
+  for (CC_id=1; CC_id<MAX_NUM_CCs; CC_id++) {
+    tx_max_power[CC_id]=tx_max_power[0];
+    rx_gain[0][CC_id] = rx_gain[0][0];
+    tx_gain[0][CC_id] = tx_gain[0][0];
+  }
+
+#if T_TRACER
+  paramdef_t cmdline_ttraceparams[] =CMDLINE_TTRACEPARAMS_DESC ;
+  config_process_cmdline( cmdline_ttraceparams,sizeof(cmdline_ttraceparams)/sizeof(paramdef_t),NULL);
+#endif
+
+  if ( !(CONFIG_ISFLAGSET(CONFIG_ABORT))  && (!(CONFIG_ISFLAGSET(CONFIG_NOOOPT))) ) {
+    // Here the configuration file is the XER encoded UE capabilities
+    // Read it in and store in asn1c data structures
+    sprintf(uecap_xer,"%stargets/PROJECTS/GENERIC-LTE-EPC/CONF/UE_config.xml",getenv("OPENAIR_HOME"));
+    printf("%s\n",uecap_xer);
+    uecap_xer_in=1;
+  } /* UE with config file  */
+}
+
+#if T_TRACER
+  int T_nowait = 0;       /* by default we wait for the tracer */
+  int T_port = 2021;    /* default port to listen to to wait for the tracer */
+  int T_dont_fork = 0;  /* default is to fork, see 'T_init' to understand */
+#endif
+
+void set_default_frame_parms(NR_DL_FRAME_PARMS *frame_parms[MAX_NUM_CCs]) {
+  int CC_id;
+
+  for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
+    /* Set some default values that may be overwritten while reading options */
+    frame_parms[CC_id] = (NR_DL_FRAME_PARMS *) calloc(sizeof(NR_DL_FRAME_PARMS),1);
+    frame_parms[CC_id]->eutra_band          = 78;
+    frame_parms[CC_id]->frame_type          = FDD;
+    frame_parms[CC_id]->tdd_config          = 3;
+    //frame_parms[CC_id]->tdd_config_S        = 0;
+    frame_parms[CC_id]->N_RB_DL             = 106;
+    frame_parms[CC_id]->N_RB_UL             = 106;
+    frame_parms[CC_id]->Ncp                 = NORMAL;
+    //frame_parms[CC_id]->Ncp_UL              = NORMAL;
+    frame_parms[CC_id]->Nid_cell            = 0;
+    //frame_parms[CC_id]->num_MBSFN_config    = 0;
+    frame_parms[CC_id]->nb_antenna_ports_eNB  = 1;
+    frame_parms[CC_id]->nb_antennas_tx      = 1;
+    frame_parms[CC_id]->nb_antennas_rx      = 1;
+    //frame_parms[CC_id]->nushift             = 0;
+    // NR: Init to legacy LTE 20Mhz params
+    frame_parms[CC_id]->numerology_index  = 0;
+    frame_parms[CC_id]->ttis_per_subframe = 1;
+    frame_parms[CC_id]->slots_per_tti   = 2;
+  }
+}
+
+void init_openair0(void) {
+  int card;
+  int i;
+
+  for (card=0; card<MAX_CARDS; card++) {
+    openair0_cfg[card].configFilename = NULL;
+
+    if(frame_parms[0]->N_RB_DL == 106) {
+      if (numerology==0) {
+        if (frame_parms[0]->threequarter_fs) {
+          openair0_cfg[card].sample_rate=23.04e6;
+          openair0_cfg[card].samples_per_frame = 230400;
+          openair0_cfg[card].tx_bw = 10e6;
+          openair0_cfg[card].rx_bw = 10e6;
+        } else {
+          openair0_cfg[card].sample_rate=30.72e6;
+          openair0_cfg[card].samples_per_frame = 307200;
+          openair0_cfg[card].tx_bw = 10e6;
+          openair0_cfg[card].rx_bw = 10e6;
+        }
+      } else if (numerology==1) {
+        openair0_cfg[card].sample_rate=61.44e6;
+        openair0_cfg[card].samples_per_frame = 307200;
+        openair0_cfg[card].tx_bw = 20e6;
+        openair0_cfg[card].rx_bw = 20e6;
+      } else if (numerology==2) {
+        openair0_cfg[card].sample_rate=122.88e6;
+        openair0_cfg[card].samples_per_frame = 307200;
+        openair0_cfg[card].tx_bw = 40e6;
+        openair0_cfg[card].rx_bw = 40e6;
+      } else {
+        LOG_E(PHY,"Unsupported numerology!\n");
+        exit(-1);
+      }
+    } else if(frame_parms[0]->N_RB_DL == 50) {
+      openair0_cfg[card].sample_rate=15.36e6;
+      openair0_cfg[card].samples_per_frame = 153600;
+      openair0_cfg[card].tx_bw = 5e6;
+      openair0_cfg[card].rx_bw = 5e6;
+    } else if (frame_parms[0]->N_RB_DL == 25) {
+      openair0_cfg[card].sample_rate=7.68e6;
+      openair0_cfg[card].samples_per_frame = 76800;
+      openair0_cfg[card].tx_bw = 2.5e6;
+      openair0_cfg[card].rx_bw = 2.5e6;
+    } else if (frame_parms[0]->N_RB_DL == 6) {
+      openair0_cfg[card].sample_rate=1.92e6;
+      openair0_cfg[card].samples_per_frame = 19200;
+      openair0_cfg[card].tx_bw = 1.5e6;
+      openair0_cfg[card].rx_bw = 1.5e6;
+    }
+
+    if (frame_parms[0]->frame_type==TDD)
+      openair0_cfg[card].duplex_mode = duplex_mode_TDD;
+    else //FDD
+      openair0_cfg[card].duplex_mode = duplex_mode_FDD;
+
+    printf("HW: Configuring card %d, nb_antennas_tx/rx %d/%d\n",card,
+           PHY_vars_UE_g[0][0]->frame_parms.nb_antennas_tx,
+           PHY_vars_UE_g[0][0]->frame_parms.nb_antennas_rx);
+    openair0_cfg[card].Mod_id = 0;
+    openair0_cfg[card].num_rb_dl=frame_parms[0]->N_RB_DL;
+    openair0_cfg[card].clock_source = clock_source;
+    openair0_cfg[card].tx_num_channels=min(2,PHY_vars_UE_g[0][0]->frame_parms.nb_antennas_tx);
+    openair0_cfg[card].rx_num_channels=min(2,PHY_vars_UE_g[0][0]->frame_parms.nb_antennas_rx);
+
+    for (i=0; i<4; i++) {
+      if (i<openair0_cfg[card].tx_num_channels)
+        openair0_cfg[card].tx_freq[i] = downlink_frequency[0][i]+uplink_frequency_offset[0][i];
+      else
+        openair0_cfg[card].tx_freq[i]=0.0;
+
+      if (i<openair0_cfg[card].rx_num_channels)
+        openair0_cfg[card].rx_freq[i] = downlink_frequency[0][i];
+      else
+        openair0_cfg[card].rx_freq[i]=0.0;
+
+      openair0_cfg[card].autocal[i] = 1;
+      openair0_cfg[card].tx_gain[i] = tx_gain[0][i];
+      openair0_cfg[card].rx_gain[i] = PHY_vars_UE_g[0][0]->rx_total_gain_dB - rx_gain_off;
+      openair0_cfg[card].configFilename = rf_config_file;
+      printf("Card %d, channel %d, Setting tx_gain %f, rx_gain %f, tx_freq %f, rx_freq %f\n",
+             card,i, openair0_cfg[card].tx_gain[i],
+             openair0_cfg[card].rx_gain[i],
+             openair0_cfg[card].tx_freq[i],
+             openair0_cfg[card].rx_freq[i]);
+    }
+
+    if (usrp_args) openair0_cfg[card].sdr_addrs = usrp_args;
+
+    if (usrp_clksrc) {
+      if (strcmp(usrp_clksrc, "internal") == 0) {
+        openair0_cfg[card].clock_source = internal;
+        LOG_D(PHY, "USRP clock source set as internal\n");
+      } else if (strcmp(usrp_clksrc, "external") == 0) {
+        openair0_cfg[card].clock_source = external;
+        LOG_D(PHY, "USRP clock source set as external\n");
+      } else if (strcmp(usrp_clksrc, "gpsdo") == 0) {
+        openair0_cfg[card].clock_source = gpsdo;
+        LOG_D(PHY, "USRP clock source set as gpsdo\n");
+      } else {
+        openair0_cfg[card].clock_source = internal;
+        LOG_I(PHY, "USRP clock source unknown ('%s'). defaulting to internal\n", usrp_clksrc);
+      }
+    } else {
+      openair0_cfg[card].clock_source = internal;
+      LOG_I(PHY, "USRP clock source not specified. defaulting to internal\n");
+    }
+  }
+}
+
+
+int main( int argc, char **argv ) {
+  //uint8_t beta_ACK=0,beta_RI=0,beta_CQI=2;
+  PHY_VARS_NR_UE *UE[MAX_NUM_CCs];
+  start_background_system();
+
+  if ( load_configmodule(argc,argv) == NULL) {
+    exit_fun("[SOFTMODEM] Error, configuration module init failed\n");
+  }
+
+  CONFIG_SETRTFLAG(CONFIG_NOEXITONHELP);
+  set_default_frame_parms(frame_parms);
+  mode = normal_txrx;
+  memset(openair0_cfg,0,sizeof(openair0_config_t)*MAX_CARDS);
+  memset(tx_max_power,0,sizeof(int)*MAX_NUM_CCs);
+  // initialize logging
+  logInit();
+  // get options and fill parameters from configuration file
+  get_options (); //Command-line options, enb_properties
+#if T_TRACER
+  T_Config_Init();
+#endif
+  //randominit (0);
+  set_taus_seed (0);
+  tpool_t pool;
+  Tpool = &pool;
+  char params[]="-1,-1"; 
+  initTpool(params, Tpool, false);
+  cpuf=get_cpu_freq_GHz();
+  itti_init(TASK_MAX, THREAD_MAX, MESSAGES_ID_MAX, tasks_info, messages_info);
+
+  if (opt_type != OPT_NONE) {
+    if (init_opt(in_path, in_ip) == -1)
+      LOG_E(OPT,"failed to run OPT \n");
+  }
+
+#ifdef PDCP_USE_NETLINK
+  netlink_init();
+#if defined(PDCP_USE_NETLINK_QUEUES)
+  pdcp_netlink_init();
+#endif
+#endif
+#ifndef PACKAGE_VERSION
+#  define PACKAGE_VERSION "UNKNOWN-EXPERIMENTAL"
+#endif
+  LOG_I(HW, "Version: %s\n", PACKAGE_VERSION);
+
+  // init the parameters
+  for (int CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
+    frame_parms[CC_id]->nb_antennas_tx     = nb_antenna_tx;
+    frame_parms[CC_id]->nb_antennas_rx     = nb_antenna_rx;
+    frame_parms[CC_id]->nb_antenna_ports_eNB = 1; //initial value overwritten by initial sync later
+    LOG_I(PHY,"Set nb_rx_antenna %d , nb_tx_antenna %d \n",frame_parms[CC_id]->nb_antennas_rx, frame_parms[CC_id]->nb_antennas_tx);
+    get_band(downlink_frequency[CC_id][0], &frame_parms[CC_id]->eutra_band,   &uplink_frequency_offset[CC_id][0], &frame_parms[CC_id]->frame_type);
+  }
+
+  NB_UE_INST=1;
+  NB_INST=1;
+  PHY_vars_UE_g = malloc(sizeof(PHY_VARS_NR_UE **));
+  PHY_vars_UE_g[0] = malloc(sizeof(PHY_VARS_NR_UE *)*MAX_NUM_CCs);
+
+  for (int CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
+    printf("frame_parms %d\n",frame_parms[CC_id]->ofdm_symbol_size);
+    nr_init_frame_parms_ue(frame_parms[CC_id],numerology,NORMAL,frame_parms[CC_id]->N_RB_DL,(frame_parms[CC_id]->N_RB_DL-20)>>1,0);
+    PHY_vars_UE_g[0][CC_id] = init_nr_ue_vars(frame_parms[CC_id], 0,abstraction_flag);
+    UE[CC_id] = PHY_vars_UE_g[0][CC_id];
+
+    if (phy_test==1)
+      UE[CC_id]->mac_enabled = 0;
+    else
+      UE[CC_id]->mac_enabled = 1;
+
+    UE[CC_id]->UE_scan = UE_scan;
+    UE[CC_id]->UE_scan_carrier = UE_scan_carrier;
+    UE[CC_id]->UE_fo_compensation = UE_fo_compensation;
+    UE[CC_id]->mode    = mode;
+    printf("UE[%d]->mode = %d\n",CC_id,mode);
+
+    for (uint8_t i=0; i<RX_NB_TH_MAX; i++) {
+      if (UE[CC_id]->mac_enabled == 1)
+        UE[CC_id]->pdcch_vars[i][0]->crnti = 0x1234;
+      else
+        UE[CC_id]->pdcch_vars[i][0]->crnti = 0x1235;
+    }
+
+    UE[CC_id]->rx_total_gain_dB =  (int)rx_gain[CC_id][0] + rx_gain_off;
+    UE[CC_id]->tx_power_max_dBm = tx_max_power[CC_id];
+
+    if (frame_parms[CC_id]->frame_type==FDD) {
+      UE[CC_id]->N_TA_offset = 0;
+    } else {
+      if (frame_parms[CC_id]->N_RB_DL == 100)
+        UE[CC_id]->N_TA_offset = 624;
+      else if (frame_parms[CC_id]->N_RB_DL == 50)
+        UE[CC_id]->N_TA_offset = 624/2;
+      else if (frame_parms[CC_id]->N_RB_DL == 25)
+        UE[CC_id]->N_TA_offset = 624/4;
+    }
+  }
+
+  //  printf("tx_max_power = %d -> amp %d\n",tx_max_power[0],get_tx_amp(tx_max_poHwer,tx_max_power));
+  init_openair0();
+  // init UE_PF_PO and mutex lock
+  pthread_mutex_init(&ue_pf_po_mutex, NULL);
+  memset (&UE_PF_PO[0][0], 0, sizeof(UE_PF_PO_t)*NUMBER_OF_UE_MAX*MAX_NUM_CCs);
+  configure_linux();
+  mlockall(MCL_CURRENT | MCL_FUTURE);
+  init_scope();
+  number_of_cards = 1;
+
+  for(int CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
+    PHY_vars_UE_g[0][CC_id]->rf_map.card=0;
+    PHY_vars_UE_g[0][CC_id]->rf_map.chain=CC_id+chain_offset;
+#if defined(OAI_USRP) || defined(OAI_ADRV9371_ZC706)
+    PHY_vars_UE_g[0][CC_id]->hw_timing_advance = timing_advance;
+#else
+    PHY_vars_UE_g[0][CC_id]->hw_timing_advance = 160;
+#endif
+  }
+
+  // wait for end of program
+  printf("TYPE <CTRL-C> TO TERMINATE\n");
+  init_UE(1);
+
+  while(true)
+    sleep(3600);
+
+  return 0;
+}
diff --git a/targets/RT/USER/nr-uesoftmodem.h b/executables/nr-uesoftmodem.h
similarity index 50%
rename from targets/RT/USER/nr-uesoftmodem.h
rename to executables/nr-uesoftmodem.h
index 7f96480b2b..078a8066c3 100644
--- a/targets/RT/USER/nr-uesoftmodem.h
+++ b/executables/nr-uesoftmodem.h
@@ -6,7 +6,6 @@
 #include <fcntl.h>
 #include <getopt.h>
 #include <linux/sched.h>
-#include "rt_wrapper.h"
 #include <sched.h>
 #include <signal.h>
 #include <stdint.h>
@@ -22,22 +21,23 @@
 #include <unistd.h>
 
 #include <sys/sysinfo.h>
-#include "rt_wrapper.h"
 #include "../../ARCH/COMMON/common_lib.h"
 #undef MALLOC
 #include "assertions.h"
-#include "msc.h"
 #include "PHY/types.h"
 #include "PHY/defs_nr_UE.h"
 #include "SIMULATION/ETH_TRANSPORT/proto.h"
+#include <threadPool/thread-pool.h>
+#include <openair2/LAYER2/NR_MAC_gNB/mac_proto.h>
+
 
 #if defined(ENABLE_ITTI)
-#if defined(ENABLE_USE_MME)
-#include "s1ap_eNB.h"
-#ifdef PDCP_USE_NETLINK
-#include "SIMULATION/ETH_TRANSPORT/proto.h"
-#endif
-#endif
+  #if defined(ENABLE_USE_MME)
+    #include "s1ap_eNB.h"
+    #ifdef PDCP_USE_NETLINK
+      #include "SIMULATION/ETH_TRANSPORT/proto.h"
+    #endif
+  #endif
 #endif
 
 /* help strings definition for command line options, used in CMDLINE_XXX_DESC macros and printed when -h option is used */
@@ -55,7 +55,7 @@
 #define CONFIG_HLP_UENANTR       "set UE number of rx antennas\n"
 #define CONFIG_HLP_UENANTT       "set UE number of tx antennas\n"
 #define CONFIG_HLP_UESCAN        "set UE to scan around carrier\n"
-#define CONFIG_HLP_UEFO	         "set UE to enable estimation and compensation of frequency offset\n"
+#define CONFIG_HLP_UEFO          "set UE to enable estimation and compensation of frequency offset\n"
 #define CONFIG_HLP_DUMPFRAME     "dump UE received frame to rxsig_frame0.dat and exit\n"
 #define CONFIG_HLP_DLSHIFT       "dynamic shift for LLR compuation for TM3/4 (default 0)\n"
 #define CONFIG_HLP_UELOOP        "get softmodem (UE) to loop through memory instead of acquiring from HW\n"
@@ -105,15 +105,15 @@
 /*   optname                     helpstr                paramflags                      XXXptr        defXXXval         type       numelt   */
 /*------------------------------------------------------------------------------------------------------------------------------------------*/
 #define CMDLINE_UEMODEPARAMS_DESC {  \
-{"calib-ue-rx",                 CONFIG_HLP_CALUER,     0,		 iptr:&rx_input_level_dBm,   defintval:0,	 TYPE_INT,   0},    \
-{"calib-ue-rx-med",             CONFIG_HLP_CALUERM,    0,		 iptr:&rx_input_level_dBm,   defintval:0,	 TYPE_INT,   0},    \
-{"calib-ue-rx-byp",             CONFIG_HLP_CALUERB,    0,		 iptr:&rx_input_level_dBm,   defintval:0,	 TYPE_INT,   0},    \
-{"debug-ue-prach",              CONFIG_HLP_DBGUEPR,    PARAMFLAG_BOOL,   uptr:NULL,		     defuintval:1,	 TYPE_INT,   0},    \
-{"no-L2-connect",               CONFIG_HLP_NOL2CN,     PARAMFLAG_BOOL,   uptr:NULL,		     defuintval:1,	 TYPE_INT,   0},    \
-{"calib-prach-tx",              CONFIG_HLP_CALPRACH,   PARAMFLAG_BOOL,   uptr:NULL,		     defuintval:1,	 TYPE_INT,   0},    \
-{"loop-memory",                 CONFIG_HLP_UELOOP,     0,		 strptr:&loopfile,	     defstrval:"iqs.in", TYPE_STRING,0},    \
-{"ue-dump-frame",               CONFIG_HLP_DUMPFRAME,  PARAMFLAG_BOOL,   iptr:&dumpframe,	     defintval:0,	 TYPE_INT,   0},    \
-}
+    {"calib-ue-rx",                 CONFIG_HLP_CALUER,     0,    iptr:&rx_input_level_dBm,   defintval:0,  TYPE_INT,   0},    \
+    {"calib-ue-rx-med",             CONFIG_HLP_CALUERM,    0,    iptr:&rx_input_level_dBm,   defintval:0,  TYPE_INT,   0},    \
+    {"calib-ue-rx-byp",             CONFIG_HLP_CALUERB,    0,    iptr:&rx_input_level_dBm,   defintval:0,  TYPE_INT,   0},    \
+    {"debug-ue-prach",              CONFIG_HLP_DBGUEPR,    PARAMFLAG_BOOL,   uptr:NULL,        defuintval:1,   TYPE_INT,   0},    \
+    {"no-L2-connect",               CONFIG_HLP_NOL2CN,     PARAMFLAG_BOOL,   uptr:NULL,        defuintval:1,   TYPE_INT,   0},    \
+    {"calib-prach-tx",              CONFIG_HLP_CALPRACH,   PARAMFLAG_BOOL,   uptr:NULL,        defuintval:1,   TYPE_INT,   0},    \
+    {"loop-memory",                 CONFIG_HLP_UELOOP,     0,    strptr:&loopfile,       defstrval:"iqs.in", TYPE_STRING,0},    \
+    {"ue-dump-frame",               CONFIG_HLP_DUMPFRAME,  PARAMFLAG_BOOL,   iptr:&dumpframe,      defintval:0,  TYPE_INT,   0},    \
+  }
 #define CMDLINE_CALIBUERX_IDX                   0
 #define CMDLINE_CALIBUERXMED_IDX                1
 #define CMDLINE_CALIBUERXBYP_IDX                2
@@ -130,19 +130,19 @@
 /*   optname                     helpstr             paramflags                      XXXptr                  defXXXval       type          numelt   */
 /*--------------------------------------------------------------------------------------------------------------------------------------------------*/
 #define CMDLINE_UEPARAMS_DESC {  \
-{"ue-rxgain",        	       CONFIG_HLP_UERXG,      0,		dblptr:&(rx_gain[0][0]),	    defdblval:0,    TYPE_DOUBLE,   0},     \
-{"ue-rxgain-off",    	       CONFIG_HLP_UERXGOFF,   0,		dblptr:&rx_gain_off,		    defdblval:0,    TYPE_DOUBLE,   0},     \
-{"ue-txgain",        	       CONFIG_HLP_UETXG,      0,		dblptr:&(tx_gain[0][0]),	    defdblval:0,    TYPE_DOUBLE,   0},     \
-{"ue-nb-ant-rx",     	       CONFIG_HLP_UENANTR,    0,		u8ptr:&nb_antenna_rx,		    defuintval:1,   TYPE_UINT8,    0},     \
-{"ue-nb-ant-tx",     	       CONFIG_HLP_UENANTT,    0,		u8ptr:&nb_antenna_tx,		    defuintval:1,   TYPE_UINT8,    0},     \
-{"ue-scan-carrier",  	       CONFIG_HLP_UESCAN,     PARAMFLAG_BOOL,	iptr:&UE_scan_carrier,  	    defintval:0,    TYPE_INT,	   0},     \
-{"ue-fo-compensation", 	       CONFIG_HLP_UEFO,	      PARAMFLAG_BOOL,	iptr:&UE_fo_compensation,  	    defintval:0,    TYPE_INT,	   0},     \
-{"ue-max-power",     	       NULL,		      0,		iptr:&(tx_max_power[0]),	    defintval:90,   TYPE_INT,	   0},     \
-{"r"  ,                        CONFIG_HLP_PRB,        0,                iptr:&(frame_parms[0]->N_RB_DL),   defintval:25,   TYPE_UINT,    0},     \
-{"dlsch-demod-shift",     	 CONFIG_HLP_DLSHIFT,	0,		  iptr:(int32_t *)&dlsch_demod_shift,	defintval:0,			   TYPE_INT,	  0},			   \
-{"usrp-args",               CONFIG_HLP_USRP_ARGS,   0,                      strptr:(char **)&usrp_args,         defstrval:"type=b200",          TYPE_STRING,    0},                     \
-{"usrp-clksrc",             CONFIG_HLP_USRP_CLK_SRC,0,                      strptr:(char **)&usrp_clksrc,       defstrval:"internal",           TYPE_STRING,    0}                     \
-}
+    {"ue-rxgain",                CONFIG_HLP_UERXG,      0,    dblptr:&(rx_gain[0][0]),      defdblval:0,    TYPE_DOUBLE,   0},     \
+    {"ue-rxgain-off",            CONFIG_HLP_UERXGOFF,   0,    dblptr:&rx_gain_off,        defdblval:0,    TYPE_DOUBLE,   0},     \
+    {"ue-txgain",                CONFIG_HLP_UETXG,      0,    dblptr:&(tx_gain[0][0]),      defdblval:0,    TYPE_DOUBLE,   0},     \
+    {"ue-nb-ant-rx",             CONFIG_HLP_UENANTR,    0,    u8ptr:&nb_antenna_rx,       defuintval:1,   TYPE_UINT8,    0},     \
+    {"ue-nb-ant-tx",             CONFIG_HLP_UENANTT,    0,    u8ptr:&nb_antenna_tx,       defuintval:1,   TYPE_UINT8,    0},     \
+    {"ue-scan-carrier",          CONFIG_HLP_UESCAN,     PARAMFLAG_BOOL, iptr:&UE_scan_carrier,        defintval:0,    TYPE_INT,    0},     \
+    {"ue-fo-compensation",         CONFIG_HLP_UEFO,       PARAMFLAG_BOOL, iptr:&UE_fo_compensation,       defintval:0,    TYPE_INT,    0},     \
+    {"ue-max-power",             NULL,          0,    iptr:&(tx_max_power[0]),      defintval:90,   TYPE_INT,    0},     \
+    {"r"  ,                        CONFIG_HLP_PRB,        0,                iptr:&(frame_parms[0]->N_RB_DL),   defintval:25,   TYPE_UINT,    0},     \
+    {"dlsch-demod-shift",        CONFIG_HLP_DLSHIFT,  0,      iptr:(int32_t *)&dlsch_demod_shift, defintval:0,         TYPE_INT,    0},        \
+    {"usrp-args",               CONFIG_HLP_USRP_ARGS,   0,                      strptr:(char **)&usrp_args,         defstrval:"type=b200",          TYPE_STRING,    0},                     \
+    {"usrp-clksrc",             CONFIG_HLP_USRP_CLK_SRC,0,                      strptr:(char **)&usrp_clksrc,       defstrval:"internal",           TYPE_STRING,    0}                     \
+  }
 
 #define DEFAULT_DLF 2680000000
 
@@ -151,43 +151,31 @@
 /*   optname                     helpstr                paramflags                      XXXptr                  defXXXval                            type           numelt   */
 /*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
 #define CMDLINE_PARAMS_DESC {  \
-{"rf-config-file",          CONFIG_HLP_RFCFGF,      0,                      strptr:(char **)&rf_config_file,    defstrval:NULL,                 TYPE_STRING,    sizeof(rf_config_file)}, \
-{"ulsch-max-errors",        CONFIG_HLP_ULMAXE,      0,                      uptr:&ULSCH_max_consecutive_errors, defuintval:0,                   TYPE_UINT,      0},                     \
-{"phy-test",                CONFIG_HLP_PHYTST,      PARAMFLAG_BOOL,         iptr:&phy_test,                     defintval:0,                    TYPE_INT,       0},                     \
-{"usim-test",               CONFIG_HLP_USIM,        PARAMFLAG_BOOL,         u8ptr:&usim_test,                   defintval:0,                    TYPE_UINT8,     0},                     \
-{"mmapped-dma",             CONFIG_HLP_DMAMAP,      PARAMFLAG_BOOL,         uptr:&mmapped_dma,                  defintval:0,                    TYPE_INT,       0},                     \
-{"external-clock",          CONFIG_HLP_EXCCLK,      PARAMFLAG_BOOL,         uptr:&clock_source,                 defintval:0,                    TYPE_INT,       0},                     \
-{"wait-for-sync",           NULL,                   PARAMFLAG_BOOL,         iptr:&wait_for_sync,                defintval:0,                    TYPE_INT,       0},                     \
-{"single-thread-disable",   CONFIG_HLP_NOSNGLT,     PARAMFLAG_BOOL,         iptr:&single_thread_flag,           defintval:1,                    TYPE_INT,       0},                     \
-{"threadoffset",            NULL,                   0,                      iptr:&(threads_offset),             defintval:0,                    TYPE_INT,       0},                     \
-{"threadMain",              NULL,                   0,                      iptr:&(threads.main),               defintval:-1,                    TYPE_INT,       0},                     \
-{"threadSync",              NULL,                   0,                      iptr:&(threads.sync),               defintval:-1,                    TYPE_INT,       0},                     \
-{"threadOneSubframe",       NULL,                   0,                      iptr:&(threads.one),                defintval:-1,                    TYPE_INT,       0},                     \
-{"threadTwoSubframe",       NULL,                   0,                      iptr:&(threads.two),                defintval:-1,                    TYPE_INT,       0},                     \
-{"threadThreeSubframe",     NULL,                   0,                      iptr:&(threads.three),              defintval:-1,                    TYPE_INT,       0},                     \
-{"threadSlot1ProcOne",      NULL,                   0,                      iptr:&(threads.slot1_proc_one),     defintval:-1,                    TYPE_INT,       0},                     \
-{"threadSlot1ProcTwo",      NULL,                   0,                      iptr:&(threads.slot1_proc_two),     defintval:-1,                    TYPE_INT,       0},                     \
-{"threadSlot1ProcThree",    NULL,                   0,                      iptr:&(threads.slot1_proc_three),   defintval:-1,                    TYPE_INT,       0},                     \
-{"nr-dlsch-demod-shift",    CONFIG_HLP_DLSHIFT,     0,                      iptr:(int32_t *)&nr_dlsch_demod_shift, defintval:0,                     TYPE_INT,       0},                     \
-{"A" ,                      CONFIG_HLP_TADV,        0,                      uptr:&timing_advance,               defintval:0,                    TYPE_UINT,      0},                     \
-{"C" ,                      CONFIG_HLP_DLF,         0,                      uptr:&(downlink_frequency[0][0]),   defuintval:2680000000,          TYPE_UINT,      0},                     \
-{"a" ,                      CONFIG_HLP_CHOFF,       0,                      iptr:&chain_offset,                 defintval:0,                    TYPE_INT,       0},                     \
-{"d" ,                      CONFIG_HLP_SOFTS,       PARAMFLAG_BOOL,         iptr:&do_forms,                    defintval:0,                     TYPE_INT,      0},                     \
-{"E" ,                      CONFIG_HLP_TQFS,        PARAMFLAG_BOOL,         iptr:&threequarter_fs,             defintval:0,                     TYPE_INT,      0},                     \
-{"K" ,                      CONFIG_HLP_ITTIL,       PARAMFLAG_NOFREE,       strptr:&itti_dump_file,             defstrval:"/tmp/itti.dump",     TYPE_STRING,    0},                     \
-{"m" ,                      CONFIG_HLP_DLMCS,       0,                      uptr:&target_dl_mcs,                defintval:0,                    TYPE_UINT,      0},                     \
-{"t" ,                      CONFIG_HLP_ULMCS,       0,                      uptr:&target_ul_mcs,                defintval:0,                    TYPE_UINT,      0},                     \
-{"W" ,                      CONFIG_HLP_L2MONW,      0,                      strptr:(char **)&in_ip,             defstrval:"127.0.0.1",          TYPE_STRING,    sizeof(in_ip)},         \
-{"P" ,                      CONFIG_HLP_L2MONP,      0,                      strptr:(char **)&in_path,           defstrval:"/tmp/oai_opt.pcap",  TYPE_STRING,    sizeof(in_path)},       \
-{"q" ,                      CONFIG_HLP_STMON,       PARAMFLAG_BOOL,         iptr:&opp_enabled,                  defintval:0,                    TYPE_INT,       0},                     \
-{"S" ,                      CONFIG_HLP_MSLOTS,      PARAMFLAG_BOOL,         u8ptr:&exit_missed_slots,           defintval:1,                    TYPE_UINT8,     0},                     \
-{"T" ,                      CONFIG_HLP_TDD,         PARAMFLAG_BOOL,         iptr:&tddflag,                      defintval:0,                    TYPE_INT,       0},                     \
-{"numerology" ,             CONFIG_HLP_NUMEROLOGY,  PARAMFLAG_BOOL,         iptr:&numerology,                   defintval:0,                    TYPE_INT,       0},                     \
-{"emulate-rf" ,             CONFIG_HLP_EMULATE_RF,  PARAMFLAG_BOOL,         iptr:&emulate_rf,                   defintval:0,                    TYPE_INT,       0},                     \
-{"parallel-config",         CONFIG_HLP_PARALLEL_CMD,0,                      strptr:(char **)&parallel_config,   defstrval:NULL,                 TYPE_STRING,    0},                     \
-{"worker-config",           CONFIG_HLP_WORKER_CMD,  0,                      strptr:(char **)&worker_config,     defstrval:NULL,                 TYPE_STRING,    0},                     \
-{"nbiot-disable",           CONFIG_HLP_DISABLNBIOT, PARAMFLAG_BOOL,         iptr:&nonbiotflag,			defintval:0,			TYPE_INT,	0} \
-}
+    {"rf-config-file",          CONFIG_HLP_RFCFGF,      0,                      strptr:(char **)&rf_config_file,    defstrval:NULL,                 TYPE_STRING,    sizeof(rf_config_file)}, \
+    {"ulsch-max-errors",        CONFIG_HLP_ULMAXE,      0,                      uptr:&ULSCH_max_consecutive_errors, defuintval:0,                   TYPE_UINT,      0},                     \
+    {"phy-test",                CONFIG_HLP_PHYTST,      PARAMFLAG_BOOL,         iptr:&phy_test,                     defintval:0,                    TYPE_INT,       0},                     \
+    {"usim-test",               CONFIG_HLP_USIM,        PARAMFLAG_BOOL,         u8ptr:&usim_test,                   defintval:0,                    TYPE_UINT8,     0},                     \
+    {"external-clock",          CONFIG_HLP_EXCCLK,      PARAMFLAG_BOOL,         uptr:&clock_source,                 defintval:0,                    TYPE_INT,       0},                     \
+    {"single-thread-disable",   CONFIG_HLP_NOSNGLT,     PARAMFLAG_BOOL,         iptr:&single_thread_flag,           defintval:1,                    TYPE_INT,       0},                     \
+    {"nr-dlsch-demod-shift",    CONFIG_HLP_DLSHIFT,     0,                      iptr:(int32_t *)&nr_dlsch_demod_shift, defintval:0,                     TYPE_INT,       0},                     \
+    {"A" ,                      CONFIG_HLP_TADV,        0,                      uptr:&timing_advance,               defintval:0,                    TYPE_UINT,      0},                     \
+    {"C" ,                      CONFIG_HLP_DLF,         0,                      uptr:&(downlink_frequency[0][0]),   defuintval:2680000000,          TYPE_UINT,      0},                     \
+    {"a" ,                      CONFIG_HLP_CHOFF,       0,                      iptr:&chain_offset,                 defintval:0,                    TYPE_INT,       0},                     \
+    {"d" ,                      CONFIG_HLP_SOFTS,       PARAMFLAG_BOOL,         iptr:&do_forms,                    defintval:0,                     TYPE_INT,      0},                     \
+    {"E" ,                      CONFIG_HLP_TQFS,        PARAMFLAG_BOOL,         iptr:&threequarter_fs,             defintval:0,                     TYPE_INT,      0},                     \
+    {"m" ,                      CONFIG_HLP_DLMCS,       0,                      uptr:&target_dl_mcs,                defintval:0,                    TYPE_UINT,      0},                     \
+    {"t" ,                      CONFIG_HLP_ULMCS,       0,                      uptr:&target_ul_mcs,                defintval:0,                    TYPE_UINT,      0},                     \
+    {"W" ,                      CONFIG_HLP_L2MONW,      0,                      strptr:(char **)&in_ip,             defstrval:"127.0.0.1",          TYPE_STRING,    sizeof(in_ip)},         \
+    {"P" ,                      CONFIG_HLP_L2MONP,      0,                      strptr:(char **)&in_path,           defstrval:"/tmp/oai_opt.pcap",  TYPE_STRING,    sizeof(in_path)},       \
+    {"q" ,                      CONFIG_HLP_STMON,       PARAMFLAG_BOOL,         iptr:&opp_enabled,                  defintval:0,                    TYPE_INT,       0},                     \
+    {"S" ,                      CONFIG_HLP_MSLOTS,      PARAMFLAG_BOOL,         u8ptr:&exit_missed_slots,           defintval:1,                    TYPE_UINT8,     0},                     \
+    {"T" ,                      CONFIG_HLP_TDD,         PARAMFLAG_BOOL,         iptr:&tddflag,                      defintval:0,                    TYPE_INT,       0},                     \
+    {"numerology" ,             CONFIG_HLP_NUMEROLOGY,  PARAMFLAG_BOOL,         iptr:&numerology,                   defintval:0,                    TYPE_INT,       0},                     \
+    {"emulate-rf" ,             CONFIG_HLP_EMULATE_RF,  PARAMFLAG_BOOL,         iptr:&emulate_rf,                   defintval:0,                    TYPE_INT,       0},                     \
+    {"parallel-config",         CONFIG_HLP_PARALLEL_CMD,0,                      strptr:(char **)&parallel_config,   defstrval:NULL,                 TYPE_STRING,    0},                     \
+    {"worker-config",           CONFIG_HLP_WORKER_CMD,  0,                      strptr:(char **)&worker_config,     defstrval:NULL,                 TYPE_STRING,    0},                     \
+    {"nbiot-disable",           CONFIG_HLP_DISABLNBIOT, PARAMFLAG_BOOL,         iptr:&nonbiotflag,      defintval:0,      TYPE_INT, 0} \
+  }
 
 #define CONFIG_HLP_FLOG          "Enable online log \n"
 #define CONFIG_HLP_LOGL          "Set the global log level, valide options: (9:trace, 8/7:debug, 6:info, 4:warn, 3:error)\n"
@@ -198,11 +186,11 @@
 /*   optname                     helpstr                paramflags                      XXXptr                  defXXXval                            type           numelt   */
 /*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
 #define CMDLINE_LOGPARAMS_DESC {  \
-{"R" ,  		  	 CONFIG_HLP_FLOG,	0,                uptr:&online_log_messages,		defintval:1,			   TYPE_INT,	  0},			   \
-{"g" ,  		  	 CONFIG_HLP_LOGL,	0,		  uptr:&glog_level,			defintval:0,			   TYPE_UINT,     0},			   \
-{"G" ,                           CONFIG_HLP_LOGV,	0,		  uptr:&glog_verbosity,		        defintval:0,			   TYPE_UINT16,   0},			   \
-{"telnetsrv",    		 CONFIG_HLP_TELN,	PARAMFLAG_BOOL,	  uptr:&start_telnetsrv,		defintval:0,			   TYPE_UINT,     0},			   \
-}
+    {"R" ,           CONFIG_HLP_FLOG, 0,                uptr:&online_log_messages,    defintval:1,         TYPE_INT,    0},        \
+    {"g" ,           CONFIG_HLP_LOGL, 0,      uptr:&glog_level,     defintval:0,         TYPE_UINT,     0},        \
+    {"G" ,                           CONFIG_HLP_LOGV, 0,      uptr:&glog_verbosity,           defintval:0,         TYPE_UINT16,   0},        \
+    {"telnetsrv",        CONFIG_HLP_TELN, PARAMFLAG_BOOL,   uptr:&start_telnetsrv,    defintval:0,         TYPE_UINT,     0},        \
+  }
 #define CMDLINE_ONLINELOG_IDX     0
 #define CMDLINE_GLOGLEVEL_IDX     1
 #define CMDLINE_GLOGVERBO_IDX     2
@@ -240,19 +228,19 @@ extern int transmission_mode;
 extern double cpuf;
 
 #if defined(ENABLE_ITTI)
-extern volatile int             start_eNB;
-extern volatile int             start_UE;
+  extern volatile int             start_eNB;
+  extern volatile int             start_UE;
 #endif
 
-#include "threads_t.h"
-extern threads_t threads;
-
 // In nr-ue.c
 extern int setup_ue_buffers(PHY_VARS_NR_UE **phy_vars_ue, openair0_config_t *openair0_cfg);
 extern void fill_ue_band_info(void);
 extern void init_UE(int);
-extern void init_thread(int sched_runtime, int sched_deadline, int sched_fifo, cpu_set_t *cpuset, char * name);
 extern void reset_opp_meas(void);
 extern void print_opp_meas(void);
-
+void *UE_thread(void *arg);
+PHY_VARS_NR_UE *init_nr_ue_vars(NR_DL_FRAME_PARMS *frame_parms,
+                                uint8_t UE_id,
+                                uint8_t abstraction_flag);
+extern tpool_t *Tpool;
 #endif
diff --git a/executables/openairinterface5g_limits.h b/executables/openairinterface5g_limits.h
new file mode 100644
index 0000000000..ca29078758
--- /dev/null
+++ b/executables/openairinterface5g_limits.h
@@ -0,0 +1,89 @@
+#ifndef OPENAIRINTERFACE5G_LIMITS_H_
+#define OPENAIRINTERFACE5G_LIMITS_H_
+
+#if 1 /*defined(CBMIMO1) || defined(EXMIMO) || defined(OAI_USRP) || defined(OAI_LMSSDR) || defined(OAI_ADRV9371_ZC706)*/
+  #define NUMBER_OF_eNB_MAX 1
+  #define NUMBER_OF_gNB_MAX 1
+  #define NUMBER_OF_RU_MAX 2
+  #define NUMBER_OF_NR_RU_MAX 2
+  #ifndef PHYSIM
+    #ifndef UE_EXPANSION
+      #define NUMBER_OF_UE_MAX 4
+      #define NUMBER_OF_NR_UE_MAX 4
+      #define NUMBER_OF_CONNECTED_eNB_MAX 1
+      #define NUMBER_OF_CONNECTED_gNB_MAX 1
+    #else
+      #define NUMBER_OF_UE_MAX 256
+      #define NUMBER_OF_NR_UE_MAX 256
+      #define NUMBER_OF_CONNECTED_eNB_MAX 1
+      #define NUMBER_OF_CONNECTED_gNB_MAX 1
+    #endif
+  #else
+    #define NUMBER_OF_UE_MAX 1
+    #define NUMBER_OF_NR_UE_MAX 1
+    #define NUMBER_OF_CONNECTED_eNB_MAX 1
+    #define NUMBER_OF_CONNECTED_gNB_MAX 1
+  #endif
+#else
+  #define NUMBER_OF_eNB_MAX 7
+  #define NUMBER_OF_gNB_MAX 7
+  #define NUMBER_OF_RU_MAX 32
+  #define NUMBER_OF_NR_RU_MAX 32
+  #ifndef UE_EXPANSION
+    #define NUMBER_OF_UE_MAX 20
+    #define NUMBER_OF_NR_UE_MAX 20
+    #define NUMBER_OF_CONNECTED_eNB_MAX 3
+    #define NUMBER_OF_CONNECTED_gNB_MAX 3
+  #else
+    #define NUMBER_OF_UE_MAX 256
+    #define NUMBER_OF_NR_UE_MAX 256
+    #define NUMBER_OF_CONNECTED_eNB_MAX 1
+    #define NUMBER_OF_CONNECTED_gNB_MAX 1
+  #endif
+  #if defined(STANDALONE) && STANDALONE==1
+    #undef  NUMBER_OF_eNB_MAX
+    #undef  NUMBER_OF_gNB_MAX
+
+    #undef  NUMBER_OF_UE_MAX
+    #undef  NUMBER_OF_NR_UE_MAX
+
+    #undef  NUMBER_OF_RU_MAX
+    #undef  NUMBER_OF_NR_RU_MAX
+
+    #define NUMBER_OF_eNB_MAX 3
+    #define NUMBER_OF_gNB_MAX 3
+
+    #define NUMBER_OF_UE_MAX 3
+    #define NUMBER_OF_NR_UE_MAX 3
+
+    #define NUMBER_OF_RU_MAX 3
+    #define NUMBER_OF_NR_RU_MAX 3
+  #endif
+  #if defined(LARGE_SCALE) && LARGE_SCALE
+    #undef  NUMBER_OF_eNB_MAX
+    #undef  NUMBER_OF_gNB_MAX
+
+    #undef  NUMBER_OF_UE_MAX
+    #undef  NUMBER_OF_NR_UE_MAX
+
+    #undef  NUMBER_OF_CONNECTED_eNB_MAX
+    #undef  NUMBER_OF_CONNECTED_gNB_MAX
+
+    #undef  NUMBER_OF_RU_MAX
+    #undef  NUMBER_OF_NR_RU_MAX
+
+    #define NUMBER_OF_eNB_MAX 2
+    #define NUMBER_OF_gNB_MAX 2
+
+    #define NUMBER_OF_UE_MAX 120
+    #define NUMBER_OF_NR_UE_MAX 120
+
+    #define NUMBER_OF_RU_MAX 16
+    #define NUMBER_OF_NR_RU_MAX 16
+
+    #define NUMBER_OF_CONNECTED_eNB_MAX 1 // to save some memory
+    #define NUMBER_OF_CONNECTED_gNB_MAX 1
+  #endif
+#endif
+
+#endif /* OPENAIRINTERFACE5G_LIMITS_H_ */
diff --git a/executables/stats.h b/executables/stats.h
new file mode 100644
index 0000000000..6c847a2860
--- /dev/null
+++ b/executables/stats.h
@@ -0,0 +1,46 @@
+/*
+ * 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
+ */
+
+/* Header file generated by fdesign on Thu Aug 28 12:13:51 2014 */
+
+#ifndef FD_stats_form_h_
+#define FD_stats_form_h_
+
+#include <forms.h>
+
+/* Callbacks, globals and object handlers */
+
+extern void reset_stats( FL_OBJECT *, long );
+
+/* Forms and Objects */
+
+typedef struct {
+  FL_FORM    *stats_form;
+  void       *vdata;
+  char       *cdata;
+  long        ldata;
+  FL_OBJECT *stats_text;
+  FL_OBJECT *stats_button;
+} FD_stats_form;
+
+extern FD_stats_form *create_form_stats_form( void );
+
+#endif /* FD_stats_form_h_ */
diff --git a/executables/threads_t.h b/executables/threads_t.h
new file mode 100644
index 0000000000..0671f40988
--- /dev/null
+++ b/executables/threads_t.h
@@ -0,0 +1,21 @@
+#ifndef _THREADS_T_H_
+#define _THREADS_T_H_
+
+typedef struct threads_s {
+  int main;
+  int sync;
+  int one;
+  int two;
+  int three;
+  int slot1_proc_one;
+  int slot1_proc_two;
+  int slot1_proc_three;
+  //int dlsch_td_one;
+  //int dlsch_td_two;
+  //int dlsch_td_three;
+  //int dlsch_td1_one;
+  //int dlsch_td1_two;
+  //int dlsch_td1_three;
+} threads_t;
+
+#endif /* _THREADS_T_H_ */
diff --git a/nfapi/open-nFAPI/nfapi/public_inc/nfapi_nr_interface.h b/nfapi/open-nFAPI/nfapi/public_inc/nfapi_nr_interface.h
index 94b7121998..d53e91f666 100644
--- a/nfapi/open-nFAPI/nfapi/public_inc/nfapi_nr_interface.h
+++ b/nfapi/open-nFAPI/nfapi/public_inc/nfapi_nr_interface.h
@@ -31,12 +31,12 @@ typedef struct {
 /*typedef struct {
 	nfapi_tl_t tl;
 	int64_t value;
-} nfapi_int64_tlv_t;
+} nfapi_int64_tlv_t;*/
 
 typedef struct {
 	nfapi_tl_t tl;
 	uint64_t value;
-} nfapi_uint64_tlv_t;*/
+} nfapi_uint64_tlv_t;
 
 // nFAPI enums
 typedef enum {
@@ -75,7 +75,7 @@ typedef struct
 
   // These TLVs are used by the VNF to configure the RF in the PNF
   // nfapi_uint16_tlv_t max_transmit_power;
-  nfapi_uint16_tlv_t nrarfcn;
+  nfapi_uint32_tlv_t nrarfcn;
 
   // nfapi_nmm_frequency_bands_t nmm_gsm_frequency_bands;
   // nfapi_nmm_frequency_bands_t nmm_umts_frequency_bands;
@@ -178,8 +178,8 @@ typedef struct {
   nfapi_uint16_tlv_t  physical_cell_id;
   nfapi_uint16_tlv_t  half_frame_index;
   nfapi_uint16_tlv_t  ssb_subcarrier_offset;
-  nfapi_uint16_tlv_t  ssb_sib1_position_in_burst;
-  nfapi_uint16_tlv_t  ssb_scg_position_in_burst;
+  nfapi_uint16_tlv_t  ssb_sib1_position_in_burst; // in sib1
+  nfapi_uint64_tlv_t  ssb_scg_position_in_burst;  // in servingcellconfigcommon 
   nfapi_uint16_tlv_t  ssb_periodicity;
   nfapi_uint16_tlv_t  ss_pbch_block_power;
   nfapi_uint16_tlv_t  n_ssb_crb;
@@ -673,4 +673,45 @@ typedef struct {
   nfapi_vendor_extension_tlv_t vendor_extension;
 } nfapi_nr_dl_config_request_t;
 
+
+typedef enum {nr_pusch_freq_hopping_disabled = 0 , 
+              nr_pusch_freq_hopping_enabled = 1
+              } nr_pusch_freq_hopping_t;
+
+typedef struct{
+    uint8_t aperiodicSRS_ResourceTrigger;
+} nfapi_nr_ul_srs_config_t;
+
+typedef struct {
+    uint8_t bandwidth_part_ind;
+    uint16_t number_rbs;
+    uint16_t start_rb;
+    uint8_t frame_offset;
+    uint16_t number_symbols;
+    uint16_t start_symbol;
+    nr_pusch_freq_hopping_t pusch_freq_hopping;
+    uint8_t mcs;
+    uint8_t Qm;
+    uint8_t ndi;
+    uint8_t rv;
+    uint8_t harq_process_nbr;
+    int8_t accumulated_delta_PUSCH;
+    int8_t absolute_delta_PUSCH;
+    uint8_t n_layers;
+    uint8_t tpmi;
+    uint8_t n_dmrs_cdm_groups;
+    uint8_t dmrs_ports[4];
+    uint8_t n_front_load_symb;
+    nfapi_nr_ul_srs_config_t srs_config;
+    uint8_t csi_reportTriggerSize;
+    uint8_t maxCodeBlockGroupsPerTransportBlock;
+    uint8_t ptrs_dmrs_association_port;
+    uint8_t beta_offset_ind;
+} nfapi_nr_ul_config_ulsch_pdu_rel15_t;
+
+typedef struct {
+  uint16_t rnti;
+  nfapi_nr_ul_config_ulsch_pdu_rel15_t ulsch_pdu_rel15;
+} nfapi_nr_ul_config_ulsch_pdu;
+
 #endif
diff --git a/openair1/PHY/CODING/TESTBENCH/polartest.c b/openair1/PHY/CODING/TESTBENCH/polartest.c
index 1b46cab3c1..76cde6c3be 100644
--- a/openair1/PHY/CODING/TESTBENCH/polartest.c
+++ b/openair1/PHY/CODING/TESTBENCH/polartest.c
@@ -11,116 +11,137 @@
 #include "PHY/CODING/nrPolar_tools/nr_polar_uci_defs.h"
 #include "PHY/CODING/coding_defs.h"
 #include "SIMULATION/TOOLS/sim.h"
+//#include "PHY/NR_TRANSPORT/nr_transport.h"
+//#include "common/utils/LOG/log.h"
 
 //#define DEBUG_DCI_POLAR_PARAMS
 //#define DEBUG_POLAR_TIMING
-//#define DEBUG_CRC
+//#define DEBUG_POLARTEST
 
 int main(int argc, char *argv[]) {
-  //Initiate timing. (Results depend on CPU Frequency. Therefore, might change due to performance variances during simulation.)
-  time_stats_t timeEncoder,timeDecoder;
-  opp_enabled=1;
-  int decoder_int16=0;
-  cpu_freq_GHz = get_cpu_freq_GHz();
-  reset_meas(&timeEncoder);
-  reset_meas(&timeDecoder);
-  randominit(0);
-  crcTableInit();
   //Default simulation values (Aim for iterations = 1000000.)
+  int decoder_int16=0;
   int itr, iterations = 1000, arguments, polarMessageType = 0; //0=PBCH, 1=DCI, -1=UCI
   double SNRstart = -20.0, SNRstop = 0.0, SNRinc= 0.5; //dB
   double SNR, SNR_lin;
   int16_t nBitError = 0; // -1 = Decoding failed (All list entries have failed the CRC checks).
   uint32_t decoderState=0, blockErrorState=0; //0 = Success, -1 = Decoding failed, 1 = Block Error.
-  uint16_t testLength = 0, coderLength = 0, blockErrorCumulative=0, bitErrorCumulative=0;
+  uint16_t testLength = NR_POLAR_PBCH_PAYLOAD_BITS, coderLength = NR_POLAR_PBCH_E;
+  uint16_t blockErrorCumulative=0, bitErrorCumulative=0;
   double timeEncoderCumulative = 0, timeDecoderCumulative = 0;
-  uint8_t aggregation_level = 8, decoderListSize = 8, pathMetricAppr = 0;
+  uint8_t aggregation_level = 8, decoderListSize = 8, logFlag = 0;
+  uint16_t rnti=0;
 
-  while ((arguments = getopt (argc, argv, "s:d:f:m:i:l:a:hqg")) != -1)
+  while ((arguments = getopt (argc, argv, "s:d:f:m:i:l:a:p:hqgFL:k:")) != -1)
     switch (arguments) {
-      case 's':
-        SNRstart = atof(optarg);
-        break;
+    case 's':
+    	SNRstart = atof(optarg);
+    	break;
 
-      case 'd':
-        SNRinc = atof(optarg);
-        break;
+    case 'd':
+    	SNRinc = atof(optarg);
+    	break;
 
-      case 'f':
-        SNRstop = atof(optarg);
-        break;
+    case 'f':
+    	SNRstop = atof(optarg);
+    	break;
 
-      case 'm':
-        polarMessageType = atoi(optarg);
-        break;
+    case 'm':
+    	polarMessageType = atoi(optarg);
+    	if (polarMessageType!=0 && polarMessageType!=1 && polarMessageType!=2)
+    		printf("Illegal polar message type %d (should be 0,1 or 2)\n", polarMessageType);
+    	break;
 
-      case 'i':
-        iterations = atoi(optarg);
-        break;
+    case 'i':
+    	iterations = atoi(optarg);
+    	break;
 
-      case 'l':
-        decoderListSize = (uint8_t) atoi(optarg);
-        break;
+    case 'l':
+      decoderListSize = (uint8_t) atoi(optarg);
+      break;
 
-      case 'a':
-        pathMetricAppr = (uint8_t) atoi(optarg);
-        break;
+    case 'q':
+    	decoder_int16 = 1;
+    	break;
 
-      case 'q':
-        decoder_int16 = 1;
-        break;
+    case 'g':
+    	iterations = 1;
+    	SNRstart = -6.0;
+    	SNRstop = -6.0;
+    	decoder_int16 = 1;
+    	break;
 
-      case 'g':
-        iterations = 1;
-        SNRstart = -6.0;
-        SNRstop = -6.0;
-        decoder_int16 = 1;
-        break;
+    case 'F':
+    	logFlag = 1;
+    	break;
 
-      case 'h':
-        printf("./polartest -s SNRstart -d SNRinc -f SNRstop -m [0=PBCH|1=DCI|2=UCI] -i iterations -l decoderListSize -a pathMetricAppr\n");
-        exit(-1);
+    case 'L':
+    	aggregation_level=atoi(optarg);
+    	if (aggregation_level != 1 && aggregation_level != 2 && aggregation_level != 4 && aggregation_level != 8 && aggregation_level != 16) {
+    		printf("Illegal aggregation level %d \n",aggregation_level);
+    		exit(-1);
+    	}
+    	break;
 
-      default:
-        perror("[polartest.c] Problem at argument parsing with getopt");
-        exit(-1);
+    case 'k':
+    	testLength=atoi(optarg);
+    	if (testLength < 12 || testLength > 60) {
+    		printf("Illegal packet bitlength %d \n",testLength);
+    		exit(-1);
+    	}
+    	break;
+
+    case 'h':
+      printf("./polartest\nOptions\n-h Print this help\n-s SNRstart (dB)\n-d SNRinc (dB)\n-f SNRstop (dB)\n-m [0=PBCH|1=DCI|2=UCI]\n"
+             "-i Number of iterations\n-l decoderListSize\n-q Flag for optimized coders usage\n-F Flag for test results logging\n"
+    		 "-L aggregation level (for DCI)\n-k packet_length (bits) for DCI/UCI\n");
+      exit(-1);
+      break;
+
+    default:
+      perror("[polartest.c] Problem at argument parsing with getopt");
+      exit(-1);
+      break;
     }
 
+  //Initiate timing. (Results depend on CPU Frequency. Therefore, might change due to performance variances during simulation.)
+    time_stats_t timeEncoder,timeDecoder;
+    opp_enabled=1;
+    cpu_freq_GHz = get_cpu_freq_GHz();
+    reset_meas(&timeEncoder);
+    reset_meas(&timeDecoder);
+    randominit(0);
+    crcTableInit();
+
   if (polarMessageType == 0) { //PBCH
-    testLength = 64;//NR_POLAR_PBCH_PAYLOAD_BITS;
-    coderLength = NR_POLAR_PBCH_E;
-    aggregation_level = NR_POLAR_PBCH_AGGREGATION_LEVEL;
+	  aggregation_level = NR_POLAR_PBCH_AGGREGATION_LEVEL;
   } else if (polarMessageType == 1) { //DCI
-    //testLength = nr_get_dci_size(params_rel15->dci_format, params_rel15->rnti_type, &fp->initial_bwp_dl, cfg);
-    testLength = 41; //20;
-    coderLength = 108*8; //to be changed by aggregate level function.
+	  coderLength = 108*aggregation_level;
   } else if (polarMessageType == -1) { //UCI
-    //testLength = ;
-    //coderLength = ;
+	  printf("UCI testing not supported yet\n");
+	  exit(-1);
   }
 
   //Logging
   time_t currentTime;
-  time (&currentTime);
   char fileName[512], currentTimeInfo[25];
   char folderName[] = ".";
-  /*
-  folderName=getenv("HOME");
-  strcat(folderName,"/Desktop/polartestResults");
-  */
+  FILE *logFile;
+  /*folderName=getenv("HOME");
+    strcat(folderName,"/Desktop/polartestResults");*/
+
+if (logFlag){
+	time (&currentTime);
 #ifdef DEBUG_POLAR_TIMING
-  sprintf(fileName,"%s/TIMING_ListSize_%d_pmAppr_%d_Payload_%d_Itr_%d",folderName,decoderListSize,pathMetricAppr,testLength,iterations);
+  sprintf(fileName,"%s/TIMING_ListSize_%d_Payload_%d_Itr_%d", folderName, decoderListSize, testLength, iterations);
 #else
-  sprintf(fileName,"%s/_ListSize_%d_pmAppr_%d_Payload_%d_Itr_%d",folderName,decoderListSize,pathMetricAppr,testLength,iterations);
+  sprintf(fileName,"%s/_ListSize_%d_Payload_%d_Itr_%d", folderName, decoderListSize, testLength, iterations);
 #endif
   strftime(currentTimeInfo, 25, "_%Y-%m-%d-%H-%M-%S.csv", localtime(&currentTime));
   strcat(fileName,currentTimeInfo);
   //Create "~/Desktop/polartestResults" folder if it doesn't already exist.
-  /*
-  struct stat folder = {0};
-  if (stat(folderName, &folder) == -1) mkdir(folderName, S_IRWXU | S_IRWXG | S_IRWXO);
-  */
-  FILE *logFile;
+  /*struct stat folder = {0};
+    if (stat(folderName, &folder) == -1) mkdir(folderName, S_IRWXU | S_IRWXG | S_IRWXO);*/
   logFile = fopen(fileName, "w");
 
   if (logFile==NULL) {
@@ -129,11 +150,12 @@ int main(int argc, char *argv[]) {
   }
 
 #ifdef DEBUG_POLAR_TIMING
-  fprintf(logFile,
-          ",timeEncoderCRCByte[us],timeEncoderCRCBit[us],timeEncoderInterleaver[us],timeEncoderBitInsertion[us],timeEncoder1[us],timeEncoder2[us],timeEncoderRateMatching[us],timeEncoderByte2Bit[us]\n");
+  fprintf(logFile,",timeEncoderCRCByte[us],timeEncoderCRCBit[us],timeEncoderInterleaver[us],timeEncoderBitInsertion[us],timeEncoder1[us],timeEncoder2[us],timeEncoderRateMatching[us],timeEncoderByte2Bit[us]\n");
 #else
   fprintf(logFile,",SNR,nBitError,blockErrorState,t_encoder[us],t_decoder[us]\n");
 #endif
+}
+
   uint8_t testArrayLength = ceil(testLength / 32.0);
   uint8_t coderArrayLength = ceil(coderLength / 32.0);
   uint32_t testInput[testArrayLength]; //generate randomly
@@ -146,253 +168,156 @@ int main(int argc, char *argv[]) {
   double modulatedInput[coderLength]; //channel input
   double channelOutput[coderLength];  //add noise
   int16_t channelOutput_int16[coderLength];
+
   t_nrPolar_params *currentPtr = nr_polar_params(polarMessageType, testLength, aggregation_level);
+
 #ifdef DEBUG_DCI_POLAR_PARAMS
   uint32_t dci_pdu[4];
   memset(dci_pdu,0,sizeof(uint32_t)*4);
   dci_pdu[0]=0x01189400;
-  printf("dci_pdu: [0]->0x%08x \t [1]->0x%08x \t [2]->0x%08x \t [3]->0x%08x\n",
-         dci_pdu[0], dci_pdu[1], dci_pdu[2], dci_pdu[3]);
+  printf("dci_pdu: [0]->0x%08x \t [1]->0x%08x \t [2]->0x%08x \t [3]->0x%08x\n", dci_pdu[0], dci_pdu[1], dci_pdu[2], dci_pdu[3]);
+  uint16_t size=41;
+  rnti=3;
+  aggregation_level=8;
   uint32_t encoder_output[54];
   memset(encoder_output,0,sizeof(uint32_t)*54);
-  uint16_t size=41;
-  uint16_t rnti=3;
-  aggregation_level=8;
   t_nrPolar_params *currentPtrDCI=nr_polar_params(1, size, aggregation_level);
-  polar_encoder_dci(dci_pdu, encoder_output, currentPtrDCI, rnti);
 
-  for (int i=0; i<54; i++)
-    printf("encoder_output: [%2d]->0x%08x \n",i, encoder_output[i]);
+  polar_encoder_dci(dci_pdu, encoder_output, currentPtrDCI, rnti);
+  for (int i=0; i<54; i++) printf("encoder_output: [%2d]->0x%08x \n", i, encoder_output[i]);
 
   uint8_t *encoder_outputByte = malloc(sizeof(uint8_t) * currentPtrDCI->encoderLength);
-  double *channel_output  = malloc (sizeof(double) * currentPtrDCI->encoderLength);
-  uint32_t dci_estimation[4];
-  memset(dci_estimation,0,sizeof(uint32_t)*4);
-  printf("dci_estimation: [0]->0x%08x \t [1]->0x%08x \t [2]->0x%08x \t [3]->0x%08x\n",
-         dci_estimation[0], dci_estimation[1], dci_estimation[2], dci_estimation[3]);
-  nr_bit2byte_uint32_8_t(encoder_output, currentPtrDCI->encoderLength, encoder_outputByte);
+  double *modulated_input = malloc (sizeof(double) * currentPtrDCI->encoderLength);
+  double *channel_output = malloc (sizeof(double) * currentPtrDCI->encoderLength);
+  uint32_t dci_est[4];
+  memset(dci_est,0,sizeof(uint32_t)*4);
+  printf("dci_est: [0]->0x%08x \t [1]->0x%08x \t [2]->0x%08x \t [3]->0x%08x\n", dci_est[0], dci_est[1], dci_est[2], dci_est[3]);
+  nr_bit2byte_uint32_8(encoder_output, currentPtrDCI->encoderLength, encoder_outputByte);
   printf("[polartest] encoder_outputByte: ");
+  for (int i = 0; i < currentPtrDCI->encoderLength; i++) printf("%d-", encoder_outputByte[i]); printf("\n");
 
-  for (int i = 0; i < currentPtrDCI->encoderLength; i++) printf("%d-", encoder_outputByte[i]);
-
-  printf("\n");
-
+  SNR_lin = pow(10, 0/10); //SNR = 0 dB
   for(int i=0; i<currentPtrDCI->encoderLength; i++) {
-    if (encoder_outputByte[i] == 0) {
-      channel_output[i]=1/sqrt(2);
-    } else {
-      channel_output[i]=(-1)/sqrt(2);
-    }
+	  if (encoder_outputByte[i] == 0)
+		  modulated_input[i]=1/sqrt(2);
+	  else
+		  modulated_input[i]=(-1)/sqrt(2);
+	  channel_output[i] = modulated_input[i] + (gaussdouble(0.0,1.0) * (1/sqrt(2*SNR_lin)));
   }
-
-  decoderState = polar_decoder_dci(channel_output,
-                                   dci_estimation,
-                                   currentPtrDCI,
-                                   NR_POLAR_DECODER_LISTSIZE,
-                                   NR_POLAR_DECODER_PATH_METRIC_APPROXIMATION,
-                                   rnti);
-  printf("dci_estimation: [0]->0x%08x \t [1]->0x%08x \t [2]->0x%08x \t [3]->0x%08x\n",
-         dci_estimation[0], dci_estimation[1], dci_estimation[2], dci_estimation[3]);
+  decoderState = polar_decoder_dci(channel_output, dci_est, currentPtrDCI, NR_POLAR_DECODER_LISTSIZE, rnti);
+  printf("dci_est: [0]->0x%08x \t [1]->0x%08x \t [2]->0x%08x \t [3]->0x%08x\n", dci_est[0], dci_est[1], dci_est[2], dci_est[3]);
   free(encoder_outputByte);
   free(channel_output);
+  free(modulated_input);
   return 0;
 #endif
-#ifdef DEBUG_CRC
-  uint32_t crc;
-  unsigned int poly24c = 0xb2b11700;
-  uint32_t testInputCRC[4];
-  testInputCRC[0]=0x00291880;
-  //testInputCRC[0]=0x01189400;
-  testInputCRC[1]=0x00000000;
-  testInputCRC[2]=0x00000000;
-  testInputCRC[3]=0x00000000;
-  uint32_t testInputcrc=0x01189400;
-  uint32_t testInputcrc2=0x00291880;
-  uint8_t testInputCRC2[8];
-  nr_crc_bit2bit_uint32_8_t(testInputCRC, 32, testInputCRC2);
-  printf("testInputCRC2: [0]->%x \t [1]->%x \t [2]->%x \t [3]->%x\n"
-         "            [4]->%x \t [5]->%x \t [6]->%x \t [7]->%x\n",
-         testInputCRC2[0], testInputCRC2[1], testInputCRC2[2], testInputCRC2[3],
-         testInputCRC2[4], testInputCRC2[5], testInputCRC2[6], testInputCRC2[7]);
-  unsigned int crc41 = crc24c(testInputCRC, 32);
-  unsigned int crc65 = crc24c(testInputCRC, 56);
-  printf("crc41: [0]->0x%08x\tcrc65: [0]->0x%08x\n",crc41, crc65);
-
-  for (int i=0; i<32; i++) printf("crc41[%d]=%d\tcrc65[%d]=%d\n",i,(crc41>>i)&1,i,(crc65>>i)&1);
-
-  crc = crc24c(testInputCRC, testLength)>>8;
-
-  for (int i=0; i<24; i++) printf("[i]=%d\n",(crc>>i)&1);
-
-  printf("crc: [0]->0x%08x\n",crc);
-  //crcbit(testInputCRC, sizeof(test) - 1, poly24c));
-  testInputCRC[testLength>>3] = ((uint8_t *)&crc)[2];
-  testInputCRC[1+(testLength>>3)] = ((uint8_t *)&crc)[1];
-  testInputCRC[2+(testLength>>3)] = ((uint8_t *)&crc)[0];
-  printf("testInputCRC: [0]->0x%08x \t [1]->0x%08x \t [2]->0x%08x \t [3]->0x%08x\n",
-         testInputCRC[0], testInputCRC[1], testInputCRC[2], testInputCRC[3]);
-  //uint32_t trial32 = 0xffffffff;
-  uint32_t trial32 = 0xf10fffff;
-  uint8_t a[4];
-  //memcpy(a, &trial32, sizeof(trial32));
-  *(uint32_t *)a = trial32;
-  unsigned char trial[4];
-  trial[0]=0xff;
-  trial[1]=0xff;
-  trial[2]=0x0f;
-  trial[3]=0xf1;
-  uint32_t trialcrc = crc24c(trial, 32);
-  uint32_t trialcrc32 = crc24c((uint8_t *)&trial32, 32);
-  //uint32_t trialcrc32 = crc24c(a, 32);
-  printf("crcbit(trial = %x\n", crcbit(trial, 4, poly24c));
-  printf("trialcrc = %x\n", trialcrc);
-  printf("trialcrc32 = %x\n", trialcrc32);
-
-  for (int i=0; i<32; i++) printf("trialcrc[%2d]=%d\ttrialcrc32[%2d]=%d\n",i,(trialcrc>>i)&1,i,(trialcrc32>>i)&1);
-
-  //uint8_t nr_polar_A[32] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
-  uint8_t nr_polar_A[32] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,1};
-  uint8_t nr_polar_crc[24];
-  uint8_t **crc_generator_matrix = crc24c_generator_matrix(32);
-  nr_matrix_multiplication_uint8_1D_uint8_2D(nr_polar_A,
-      crc_generator_matrix,
-      nr_polar_crc,
-      32,
-      24);
-
-  for (uint8_t i = 0; i < 24; i++) {
-    nr_polar_crc[i] = (nr_polar_crc[i] % 2);
-    printf("nr_polar_crc[%d]=%d\n",i,nr_polar_crc[i]);
-  }
-
-  return 0;
-#endif
-#ifdef DEBUG_POLAR_TIMING
 
   for (SNR = SNRstart; SNR <= SNRstop; SNR += SNRinc) {
-    SNR_lin = pow(10, SNR / 10);
+	  printf("SNR %f\n",SNR);
+	  SNR_lin = pow(10, SNR/10);
 
-    for (itr = 1; itr <= iterations; itr++) {
-      for (int j=0; j<ceil(testLength / 32.0); j++) {
-        for(int i=0; i<32; i++) {
-          testInput[j] |= ( ((uint32_t) (rand()%2)) &1);
-          testInput[j]<<=1;
-        }
-      }
+	  for (itr = 1; itr <= iterations; itr++) {
+		  //Generate random values for all the bits of "testInput", not just as much as "currentPtr->payloadBits".
+		  for (int i = 0; i < testArrayLength; i++) {
+			  for (int j = 0; j < (sizeof(testInput[0])*8)-1; j++) {
+				  testInput[i] |= ( ((uint32_t) (rand()%2)) &1);
+				  testInput[i]<<=1;
+			  }
+			  testInput[i] |= ( ((uint32_t) (rand()%2)) &1);
+		  }
 
-      printf("testInput: [0]->0x%08x \n", testInput[0]);
-      polar_encoder_timing(testInput, encoderOutput, currentPtr, cpu_freq_GHz, logFile);
-    }
-  }
-
-  fclose(logFile);
-  free(testInput);
-  free(encoderOutput);
-  free(modulatedInput);
-  free(channelOutput);
-  free(estimatedOutput);
-  return (0);
+#ifdef DEBUG_POLARTEST
+		  //testInput[0] = 0x360f8a5c;
+		  printf("testInput: [0]->0x%08x\n", testInput[0]);
 #endif
-  // We assume no a priori knowledge available about the payload.
-  double aPrioriArray[currentPtr->payloadBits];
+		  int len_mod64=currentPtr->payloadBits&63;
+		  ((uint64_t *)testInput)[currentPtr->payloadBits/64]&=((((uint64_t)1)<<len_mod64)-1);
 
-  for (int i=0; i<currentPtr->payloadBits; i++) aPrioriArray[i] = NAN;
+		  start_meas(&timeEncoder);
+		  if (decoder_int16==1) {
+			  polar_encoder_fast((uint64_t *)testInput, encoderOutput, 0, currentPtr);
+			  //polar_encoder_fast((uint64_t*)testInput, (uint64_t*)encoderOutput,0, currentPtr);
+		  } else { //0 --> PBCH, 1 --> DCI, -1 --> UCI
+			  if (polarMessageType == 0)
+				  polar_encoder(testInput, encoderOutput, currentPtr);
+			  else if (polarMessageType == 1)
+				  polar_encoder_dci(testInput, encoderOutput, currentPtr, rnti);
+		  }
+		  stop_meas(&timeEncoder);
 
-  for (SNR = SNRstart; SNR <= SNRstop; SNR += SNRinc) {
-    printf("SNR %f\n",SNR);
-    SNR_lin = pow(10, SNR/10);
+#ifdef DEBUG_POLARTEST
+		  printf("encoderOutput: [0]->0x%08x\n", encoderOutput[0]);
+		  //for (int i=1;i<coderArrayLength;i++) printf("encoderOutput: [i]->0x%08x\n", i, encoderOutput[1]);
+#endif
 
-    for (itr = 1; itr <= iterations; itr++) {
-      for (int i = 0; i < testArrayLength; i++) {
-        for (int j = 0; j < (sizeof(testInput[0])*8)-1; j++) {
-          testInput[i] |= ( ((uint32_t) (rand()%2)) &1);
-          testInput[i]<<=1;
-        }
-
-        testInput[i] |= ( ((uint32_t) (rand()%2)) &1);
-      }
-
-      /*printf("testInput: [0]->0x%08x\n", testInput[0]);
-      for (int i=0; i<32; i++)
-        printf("%d\n",(testInput[0]>>i)&1);*/
-      int len_mod64=currentPtr->payloadBits&63;
-      ((uint64_t *)testInput)[currentPtr->payloadBits/64]&=((((uint64_t)1)<<len_mod64)-1);
-      start_meas(&timeEncoder);
-
-      if (decoder_int16==0)
-        polar_encoder(testInput, encoderOutput, currentPtr);
-      else
-        polar_encoder_fast((uint64_t *)testInput, encoderOutput,0, currentPtr);
-
-      //polar_encoder_fast((uint64_t*)testInput, (uint64_t*)encoderOutput,0, currentPtr);
-      stop_meas(&timeEncoder);
-      /*printf("encoderOutput: [0]->0x%08x\n", encoderOutput[0]);
-      printf("encoderOutput: [1]->0x%08x\n", encoderOutput[1]);*/
       //Bit-to-byte:
-      nr_bit2byte_uint32_8_t(encoderOutput, coderLength, encoderOutputByte);
+      nr_bit2byte_uint32_8(encoderOutput, coderLength, encoderOutputByte);
 
       //BPSK modulation
       for(int i=0; i<coderLength; i++) {
-        if (encoderOutputByte[i] == 0)
-          modulatedInput[i]=1/sqrt(2);
-        else
-          modulatedInput[i]=(-1)/sqrt(2);
+    	  if (encoderOutputByte[i] == 0)
+    		  modulatedInput[i]=1/sqrt(2);
+    	  else
+    		  modulatedInput[i]=(-1)/sqrt(2);
 
-        channelOutput[i] = modulatedInput[i] + (gaussdouble(0.0,1.0) * (1/sqrt(2*SNR_lin)));
+    	  channelOutput[i] = modulatedInput[i] + (gaussdouble(0.0,1.0) * (1/sqrt(2*SNR_lin)));
 
-        if (decoder_int16==1) {
-          if (channelOutput[i] > 15) channelOutput_int16[i] = 127;
-          else if (channelOutput[i] < -16) channelOutput_int16[i] = -128;
-          else channelOutput_int16[i] = (int16_t) (8*channelOutput[i]);
-        }
+    	  if (decoder_int16==1) {
+    		  if (channelOutput[i] > 15) channelOutput_int16[i] = 127;
+    		  else if (channelOutput[i] < -16) channelOutput_int16[i] = -128;
+    		  else channelOutput_int16[i] = (int16_t) (8*channelOutput[i]);
+    	  }
       }
 
       start_meas(&timeDecoder);
 
-      /*decoderState = polar_decoder(channelOutput,
-                     estimatedOutput,
-                     currentPtr,
-                     NR_POLAR_DECODER_LISTSIZE,
-                     aPrioriArray,
-                     NR_POLAR_DECODER_PATH_METRIC_APPROXIMATION);*/
-      if (decoder_int16==0)
-        decoderState = polar_decoder_aPriori(channelOutput,
-                                             estimatedOutput,
-                                             currentPtr,
-                                             NR_POLAR_DECODER_LISTSIZE,
-                                             NR_POLAR_DECODER_PATH_METRIC_APPROXIMATION,
-                                             aPrioriArray);
-      else
-        decoderState = polar_decoder_int16(channelOutput_int16,
-                                           (uint64_t *)estimatedOutput,
-                                           currentPtr);
-
+      if (decoder_int16==1) {
+    	  decoderState = polar_decoder_int16(channelOutput_int16, (uint64_t *)estimatedOutput, currentPtr);
+      } else { //0 --> PBCH, 1 --> DCI, -1 --> UCI
+    	  if (polarMessageType == 0) {
+    		  decoderState = polar_decoder(channelOutput,
+    				                       estimatedOutput,
+										   currentPtr,
+										   decoderListSize);
+    	  } else if (polarMessageType == 1) {
+    		  decoderState = polar_decoder_dci(channelOutput,
+    				  	  	  	  	  	  	   estimatedOutput,
+											   currentPtr,
+											   decoderListSize,
+											   rnti);
+    	  }
+      }
       stop_meas(&timeDecoder);
-      /*printf("testInput: [0]->0x%08x\n", testInput[0]);
-      printf("estimatedOutput: [0]->0x%08x\n", estimatedOutput[0]);*/
+      
+#ifdef DEBUG_POLARTEST
+      printf("estimatedOutput: [0]->0x%08x\n", estimatedOutput[0]);
+#endif
 
       //calculate errors
       if (decoderState!=0) {
-        blockErrorState=-1;
-        nBitError=-1;
+    	  blockErrorState=-1;
+    	  nBitError=-1;
       } else {
-        for (int j = 0; j < currentPtr->payloadBits; j++) {
-          if (((estimatedOutput[0]>>j) & 1) != ((testInput[0]>>j) & 1)) nBitError++;
-
-          //          printf("bit %d: %d => %d\n",j,(testInput[0]>>j)&1,(estimatedOutput[0]>>j)&1);
-        }
-
-        if (nBitError>0) {
-          blockErrorState=1;
-          //          printf("Error: Input %x, Output %x\n",testInput[0],estimatedOutput[0]);
-        }
+    	  for (int i = 0; i < (testArrayLength-1); i++) {
+    	  		for (int j = 0; j < 32; j++) {
+    	  			if ( ((estimatedOutput[i]>>j) & 1) != ((testInput[i]>>j) & 1) )
+    	  				nBitError++;
+    	  		}
+    	  	}
+    	  for (int j = 0; j < testLength - ((testArrayLength-1) * 32); j++)
+    		  if ( ((estimatedOutput[(testArrayLength-1)]>>j) & 1) != ((testInput[(testArrayLength-1)]>>j) & 1) )
+    			  nBitError++;
       }
+      if (nBitError>0) blockErrorState=1;
+#ifdef DEBUG_POLARTEST
+          		  for (int i = 0; i < testArrayLength; i++)
+          			  printf("[polartest/decoderState=%d] testInput[%d]=0x%08x, estimatedOutput[%d]=0x%08x\n",decoderState, i, testInput[i], i, estimatedOutput[i]);
+#endif
 
       //Iteration times are in microseconds.
       timeEncoderCumulative+=(timeEncoder.diff/(cpu_freq_GHz*1000.0));
       timeDecoderCumulative+=(timeDecoder.diff/(cpu_freq_GHz*1000.0));
-      fprintf(logFile,",%f,%d,%d,%f,%f\n", SNR, nBitError, blockErrorState,
-              (timeEncoder.diff/(cpu_freq_GHz*1000.0)), (timeDecoder.diff/(cpu_freq_GHz*1000.0)));
+      if (logFlag) fprintf(logFile,",%f,%d,%d,%f,%f\n", SNR, nBitError, blockErrorState, (timeEncoder.diff/(cpu_freq_GHz*1000.0)), (timeDecoder.diff/(cpu_freq_GHz*1000.0)));
 
       if (nBitError<0) {
         blockErrorCumulative++;
@@ -405,17 +330,19 @@ int main(int argc, char *argv[]) {
       decoderState=0;
       nBitError=0;
       blockErrorState=0;
+	  memset(testInput,0,sizeof(uint32_t) * testArrayLength);
+	  memset(encoderOutput,0,sizeof(uint32_t) * coderArrayLength);
+	  memset(estimatedOutput,0,sizeof(uint32_t) * testArrayLength);
     }
 
     //Calculate error statistics for the SNR.
-    printf("[ListSize=%d, Appr=%d] SNR=%+8.3f, BLER=%9.6f, BER=%12.9f, t_Encoder=%9.3fus, t_Decoder=%9.3fus\n",
-           decoderListSize, pathMetricAppr, SNR, ((double)blockErrorCumulative/iterations),
+    printf("[ListSize=%d] SNR=%+8.3f, BLER=%9.6f, BER=%12.9f, t_Encoder=%9.3fus, t_Decoder=%9.3fus\n",
+           decoderListSize, SNR, ((double)blockErrorCumulative/iterations),
            ((double)bitErrorCumulative / (iterations*testLength)),
            (double)timeEncoder.diff/timeEncoder.trials/(cpu_freq_GHz*1000.0),(double)timeDecoder.diff/timeDecoder.trials/(cpu_freq_GHz*1000.0));
     //(timeEncoderCumulative/iterations),timeDecoderCumulative/iterations);
 
-    if (blockErrorCumulative==0 && bitErrorCumulative==0)
-      break;
+    if (blockErrorCumulative==0 && bitErrorCumulative==0) break;
 
     blockErrorCumulative = 0;
     bitErrorCumulative = 0;
@@ -425,6 +352,6 @@ int main(int argc, char *argv[]) {
 
   print_meas(&timeEncoder,"polar_encoder",NULL,NULL);
   print_meas(&timeDecoder,"polar_decoder",NULL,NULL);
-  fclose(logFile);
+  if (logFlag) fclose(logFile);
   return (0);
 }
diff --git a/openair1/PHY/CODING/TESTBENCH/smallblocktest.c b/openair1/PHY/CODING/TESTBENCH/smallblocktest.c
new file mode 100644
index 0000000000..ee1a228ab8
--- /dev/null
+++ b/openair1/PHY/CODING/TESTBENCH/smallblocktest.c
@@ -0,0 +1,166 @@
+#include "PHY/CODING/nrSmallBlock/nr_small_block_defs.h"
+#include "SIMULATION/TOOLS/sim.h"
+#include <getopt.h>
+
+//#define DEBUG_SMALLBLOCKTEST
+
+signed char quantize(double D, double x, unsigned char B)
+{
+	double qxd;
+	short maxlev;
+	qxd = floor(x/D);
+
+	maxlev = 1<<(B-1);//(char)(pow(2,B-1));
+
+	if (qxd <= -maxlev)
+		qxd = -maxlev;
+	else if (qxd >= maxlev)
+		qxd = maxlev-1;
+
+	return((char)qxd);
+}
+
+int main(int argc, char *argv[]) {
+
+	time_stats_t timeEncoder,timeDecoder;
+	opp_enabled=1;
+	cpu_freq_GHz = get_cpu_freq_GHz();
+	reset_meas(&timeEncoder);
+	reset_meas(&timeDecoder);
+	randominit(0);
+
+	int arguments, iterations = 1000, messageLength = 11;
+	//int matlabDebug = 0;
+	uint32_t testInput, encoderOutput, codingDifference, nBitError=0, blockErrorState = 0, blockErrorCumulative=0, bitErrorCumulative=0;
+	uint16_t estimatedOutput;
+	double SNRstart = -20.0, SNRstop = 5.0, SNRinc= 0.5; //dB
+	double SNR, SNR_lin, sigma;
+	double modulatedInput[NR_SMALL_BLOCK_CODED_BITS], channelOutput[NR_SMALL_BLOCK_CODED_BITS];
+	//int16_t channelOutput_int16[NR_SMALL_BLOCK_CODED_BITS];
+	int8_t channelOutput_int8[NR_SMALL_BLOCK_CODED_BITS];
+	unsigned char qbits=8;
+
+	while ((arguments = getopt (argc, argv, "s:d:f:l:i:mhg")) != -1)
+	switch (arguments)
+	{
+		case 's':
+			SNRstart = atof(optarg);
+			break;
+
+		case 'd':
+			SNRinc = atof(optarg);
+			break;
+
+		case 'f':
+			SNRstop = atof(optarg);
+			break;
+
+		case 'l':
+			messageLength = atoi(optarg);
+			break;
+
+		case 'i':
+			iterations = atoi(optarg);
+			break;
+
+		/*case 'm':
+			matlabDebug = 1;
+			//#define DEBUG_POLAR_MATLAB
+			break;*/
+
+		case 'g':
+			iterations = 1;
+			SNRstart = -6.0;
+			SNRstop = -6.0;
+			messageLength = 11;
+			break;
+
+		case 'h':
+			//printf("./smallblocktest -s SNRstart -d SNRinc -f SNRstop -l messageLength -i iterations -m Matlab Debug\n");
+			printf("./smallblocktest -s SNRstart -d SNRinc -f SNRstop -l messageLength -i iterations\n");
+			exit(-1);
+
+		default:
+			perror("[smallblocktest.c] Problem at argument parsing with getopt");
+			exit(-1);
+	}
+
+
+	uint16_t mask = 0x07ff >> (11-messageLength);
+	for (SNR = SNRstart; SNR <= SNRstop; SNR += SNRinc) {
+		printf("SNR %f\n",SNR);
+		SNR_lin = pow(10, SNR/10.0);
+		sigma = 1.0/sqrt(SNR_lin);
+
+		for (int itr = 1; itr <= iterations; itr++) {
+
+			//Generate random test input of length "messageLength"
+			testInput = 0;
+			for (int i = 1; i < messageLength; i++) {
+				testInput |= ( ((uint32_t) (rand()%2)) &1);
+				testInput<<=1;
+				}
+			testInput |= ( ((uint32_t) (rand()%2)) &1);
+			//Encoding
+			start_meas(&timeEncoder);
+			encoderOutput = encodeSmallBlock((uint16_t*)&testInput, (uint8_t)messageLength);
+			stop_meas(&timeEncoder);
+
+			for (int i=0; i<NR_SMALL_BLOCK_CODED_BITS; i++) {
+				//BPSK modulation
+				if ((encoderOutput>>i) & 1 ) {
+					modulatedInput[i]=-1;
+				} else {
+					modulatedInput[i]=1;
+				}
+
+				//AWGN
+				channelOutput[i] = modulatedInput[i] + ( gaussdouble(0.0,1.0) * ( 1/sqrt(SNR_lin) ) );
+
+				//Quantization
+				channelOutput_int8[i] = quantize(sigma/16.0, channelOutput[i], qbits);
+			}
+
+			//Decoding
+			start_meas(&timeDecoder);
+			estimatedOutput = decodeSmallBlock(channelOutput_int8, (uint8_t)messageLength);
+			stop_meas(&timeDecoder);
+
+#ifdef DEBUG_SMALLBLOCKTEST
+			printf("[smallblocktest] Input = 0x%x, Output = 0x%x, DecoderOutput = 0x%x\n", testInput, encoderOutput, estimatedOutput);
+			for (int i=0;i<32;i++)
+				printf("[smallblocktest] Input[%d] = %d, Output[%d] = %d, codingDifference[%d]=%d, Mask[%d] = %d\n", i, (testInput>>i)&1, i, (estimatedOutput>>i)&1, i, (codingDifference>>i)&1, i, (mask>>i)&1);
+#endif
+
+			//Error Calculation
+			estimatedOutput &= mask;
+			codingDifference = ((uint32_t)estimatedOutput) ^ testInput; // Count the # of 1's in codingDifference by Brian Kernighan’s algorithm.
+
+			for (nBitError = 0; codingDifference; nBitError++)
+				codingDifference &= codingDifference - 1;
+
+			blockErrorState = (nBitError > 0) ? 1 : 0;
+
+			blockErrorCumulative+=blockErrorState;
+			bitErrorCumulative+=nBitError;
+
+			nBitError = 0; blockErrorState = 0;
+		}
+
+		//Error statistics for the SNR; iteration times are in nanoseconds and microseconds, respectively.
+		printf("[smallblocktest] SNR=%+7.3f, BER=%9.6f, BLER=%9.6f, t_Encoder=%9.3fns, t_Decoder=%7.3fus\n",
+				SNR,
+				((double)bitErrorCumulative / (iterations*messageLength)),
+				((double)blockErrorCumulative/iterations),
+				((double)timeEncoder.diff/timeEncoder.trials)/(cpu_freq_GHz),
+				((double)timeDecoder.diff/timeDecoder.trials)/(cpu_freq_GHz*1000.0));
+
+		blockErrorCumulative=0;
+		bitErrorCumulative=0;
+	}
+
+	print_meas(&timeEncoder, "smallblock_encoder", NULL, NULL);
+	print_meas(&timeDecoder, "smallblock_decoder", NULL, NULL);
+
+	return (0);
+}
diff --git a/openair1/PHY/CODING/coding_defs.h b/openair1/PHY/CODING/coding_defs.h
index 0f316e7869..0c1dbfae35 100644
--- a/openair1/PHY/CODING/coding_defs.h
+++ b/openair1/PHY/CODING/coding_defs.h
@@ -453,7 +453,7 @@ int32_t nr_segmentation(unsigned char *input_buffer,
                      unsigned int B,
                      unsigned int *C,
                      unsigned int *K,
-					 unsigned int *Zout,
+                     unsigned int *Zout,
                      unsigned int *F);
 
 uint32_t nr_compute_tbs(uint8_t mcs,
diff --git a/openair1/PHY/CODING/crc_byte.c b/openair1/PHY/CODING/crc_byte.c
index d728d6b9ad..ee5c302adb 100644
--- a/openair1/PHY/CODING/crc_byte.c
+++ b/openair1/PHY/CODING/crc_byte.c
@@ -32,6 +32,7 @@
 
 
 #include "coding_defs.h"
+#include "assertions.h"
 
 /*ref 36-212 v8.6.0 , pp 8-9 */
 /* the highest degree is set by default */
@@ -105,17 +106,6 @@ void crcTableInit (void)
   } while (++c);
 }
 
-//Generic version
-void crcTable256Init (uint32_t poly, uint32_t* crc256Table)
-{
-        unsigned char c = 0;
-
-        do {
-                crc256Table[c] = crcbit(&c, 1, poly);
-        } while (++c);
-
-}
-
 /*********************************************************
 
 Byte by byte implementations,
@@ -235,30 +225,10 @@ crc8 (unsigned char * inptr, int bitlen)
   return crc;
 }
 
-//Generic version
-unsigned int crcPayload(unsigned char * inptr, int bitlen, uint32_t* crc256Table)
-{
-        int octetlen, resbit;
-        unsigned int crc = 0;
-        octetlen = bitlen/8; // Change in bytes
-        resbit = (bitlen % 8);
-
-        while (octetlen-- > 0)
-        {
-                crc = (crc << 8) ^ crc256Table[(*inptr++) ^ (crc >> 24)];
-        }
-
-        if (resbit > 0)
-        {
-                crc = (crc << resbit) ^ crc256Table[((*inptr) >> (8 - resbit)) ^ (crc >> (32 - resbit))];
-        }
-        return crc;
-}
-
 int check_crc(uint8_t* decoded_bytes, uint32_t n, uint32_t F, uint8_t crc_type)
 {
   uint32_t crc=0,oldcrc=0;
-  uint8_t crc_len,temp;
+  uint8_t crc_len=0;
 
   switch (crc_type) {
   case CRC24_A:
@@ -275,7 +245,7 @@ int check_crc(uint8_t* decoded_bytes, uint32_t n, uint32_t F, uint8_t crc_type)
     break;
 
   default:
-    crc_len=3;
+    AssertFatal(1,"Invalid crc_type \n");
   }
 
   for (int i=0; i<crc_len; i++)
@@ -309,6 +279,9 @@ int check_crc(uint8_t* decoded_bytes, uint32_t n, uint32_t F, uint8_t crc_type)
       crc = crc8(decoded_bytes,
                  n-8)>>24;
       break;
+
+    default:
+      AssertFatal(1,"Invalid crc_type \n");
     }
 
     if (crc == oldcrc)
@@ -331,7 +304,7 @@ main()
 {
   unsigned char test[] = "Thebigredfox";
   crcTableInit();
-  printf("%x\n", crcbit(test, sizeof(test) - 1, poly24));
+  printf("%x\n", crcbit(test, sizeof(test) - 1, poly24a));
   printf("%x\n", crc24(test, (sizeof(test) - 1)*8));
   printf("%x\n", crcbit(test, sizeof(test) - 1, poly8));
   printf("%x\n", crc8(test, (sizeof(test) - 1)*8));
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/time_meas.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/time_meas.c
deleted file mode 100644
index c784188071..0000000000
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/time_meas.c
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
- * 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
- */
-
-#include <stdio.h>
-#include "time_meas.h"
-#include <math.h>
-#include <unistd.h>
-
-// global var for openair performance profiler
-extern int opp_enabled;
-
-
-double get_cpu_freq_GHz(void) {
-
-  time_stats_t ts = {0};
-  reset_meas(&ts);
-  ts.trials++;
-  ts.in = rdtsc_oai();
-  sleep(1);
-  ts.diff = (rdtsc_oai()-ts.in);
-  cpu_freq_GHz = (double)ts.diff/1000000000;
-  printf("CPU Freq is %f \n", cpu_freq_GHz);
-  return cpu_freq_GHz; 
-}
-
-void print_meas_now(time_stats_t *ts, const char* name, FILE* file_name){
-
-  if (opp_enabled) {
-
-    //static double cpu_freq_GHz = 3.2;
-
-    //if (cpu_freq_GHz == 0.0)
-      //cpu_freq_GHz = get_cpu_freq_GHz(); // super slow
-
-    if (ts->trials>0) {
-
-      //fprintf(file_name,"Name %25s: Processing %15.3f ms for SF %d, diff_now %15.3f \n", name,(ts->diff_now/(cpu_freq_GHz*1000000.0)),subframe,ts->diff_now);
-      fprintf(file_name,"%15.3f ms, diff_now %15.3f \n",(ts->diff_now/(cpu_freq_GHz*1000000.0)),(double)ts->diff_now);
-      
-    }
-  }
-}
-
-void print_meas(time_stats_t *ts, const char* name, time_stats_t * total_exec_time, time_stats_t * sf_exec_time)
-{
-
-  if (opp_enabled) {
-
-    static int first_time = 0;
-    static double cpu_freq_GHz = 0.0;
-
-    if (cpu_freq_GHz == 0.0)
-      cpu_freq_GHz = get_cpu_freq_GHz();
-
-    if (first_time == 0) {
-      first_time=1;
-
-      if ((total_exec_time == NULL) || (sf_exec_time== NULL))
-        fprintf(stderr, "%25s  %25s  %25s  %25s %25s %6f\n","Name","Total","Per Trials",   "Num Trials","CPU_F_GHz", cpu_freq_GHz);
-      else
-        fprintf(stderr, "%25s  %25s  %25s  %20s %15s %6f\n","Name","Total","Average/Frame","Trials",    "CPU_F_GHz", cpu_freq_GHz);
-    }
-
-    if (ts->trials>0) {
-      //printf("%20s: total: %10.3f ms, average: %10.3f us (%10d trials)\n", name, ts->diff/cpu_freq_GHz/1000000.0, ts->diff/ts->trials/cpu_freq_GHz/1000.0, ts->trials);
-
-      if ((total_exec_time == NULL) || (sf_exec_time== NULL)) {
-        fprintf(stderr, "%25s:  %15.3f ms ;  %15.3f us; %15d;\n",
-                name,
-                (ts->diff/cpu_freq_GHz/1000000.0),
-                (ts->diff/ts->trials/cpu_freq_GHz/1000.0),
-                ts->trials);
-      } else {
-        fprintf(stderr, "%25s:  %15.3f ms (%5.2f%%); %15.3f us (%5.2f%%); %15d;\n",
-                name,
-                (ts->diff/cpu_freq_GHz/1000000.0),
-                ((ts->diff/cpu_freq_GHz/1000000.0)/(total_exec_time->diff/cpu_freq_GHz/1000000.0))*100,  // percentage
-                (ts->diff/ts->trials/cpu_freq_GHz/1000.0),
-                ((ts->diff/ts->trials/cpu_freq_GHz/1000.0)/(sf_exec_time->diff/sf_exec_time->trials/cpu_freq_GHz/1000.0))*100,  // percentage
-                ts->trials);
-      }
-    }
-  }
-
-}
-
-double get_time_meas_us(time_stats_t *ts)
-{
-
-  static double cpu_freq_GHz = 0.0;
-
-  if (cpu_freq_GHz == 0.0)
-    cpu_freq_GHz = get_cpu_freq_GHz();
-
-  if (ts->trials>0)
-    return  (ts->diff/ts->trials/cpu_freq_GHz/1000.0);
-
-  return 0;
-}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/time_meas.h b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/time_meas.h
deleted file mode 100644
index e6bec31176..0000000000
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/time_meas.h
+++ /dev/null
@@ -1,156 +0,0 @@
-/*
- * 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
- */
-
-#ifndef __TIME_MEAS_DEFS__H__
-#define __TIME_MEAS_DEFS__H__
-
-#include <unistd.h>
-#include <math.h>
-#include <stdint.h>
-#include <time.h>
-#include <errno.h>
-#include <stdio.h>
-#include <pthread.h>
-#include <linux/kernel.h>
-#include <linux/types.h>
-// global var to enable openair performance profiler
-static int opp_enabled = 1;
-double cpu_freq_GHz;
-#if defined(__x86_64__) || defined(__i386__)
-
-typedef struct {
-
-  long long in;
-  long long diff;
-  long long diff_now;
-  long long p_time; /*!< \brief absolute process duration */
-  long long diff_square; /*!< \brief process duration square */
-  long long max;
-  int trials;
-  int meas_flag;
-} time_stats_t;
-#elif defined(__arm__)
-typedef struct {
-  uint32_t in;
-  uint32_t diff_now;
-  uint32_t diff;
-  uint32_t p_time; /*!< \brief absolute process duration */
-  uint32_t diff_square; /*!< \brief process duration square */
-  uint32_t max;
-  int trials;
-} time_stats_t;
-
-#endif
-static inline void start_meas(time_stats_t *ts) __attribute__((always_inline));
-static inline void stop_meas(time_stats_t *ts) __attribute__((always_inline));
-
-
-void print_meas_now(time_stats_t *ts, const char* name, FILE* file_name);
-//void print_meas(time_stats_t *ts, const char* name, time_stats_t * total_exec_time, time_stats_t * sf_exec_time);
-double get_time_meas_us(time_stats_t *ts);
-double get_cpu_freq_GHz(void);
-
-#if defined(__i386__)
-static inline unsigned long long rdtsc_oai(void) __attribute__((always_inline));
-static inline unsigned long long rdtsc_oai(void)
-{
-  unsigned long long int x;
-  __asm__ volatile (".byte 0x0f, 0x31" : "=A" (x));
-  return x;
-}
-#elif defined(__x86_64__)
-static inline unsigned long long rdtsc_oai(void) __attribute__((always_inline));
-static inline unsigned long long rdtsc_oai(void)
-{
-  unsigned long long a, d;
-  __asm__ volatile ("rdtsc" : "=a" (a), "=d" (d));
-  return (d<<32) | a;
-}
-
-#elif defined(__arm__)
-static inline uint32_t rdtsc_oai(void) __attribute__((always_inline));
-static inline uint32_t rdtsc_oai(void)
-{
-  uint32_t r = 0;
-  asm volatile("mrc p15, 0, %0, c9, c13, 0" : "=r"(r) );
-  return r;
-}
-#endif
-
-static inline void start_meas(time_stats_t *ts)
-{
-
-  if (opp_enabled) {
-    if (ts->meas_flag==0) {
-      ts->trials++;
-      ts->in = rdtsc_oai();
-      ts->meas_flag=1;
-    }
-    else {
-      ts->in = rdtsc_oai();
-    }
-  }
-}
-
-static inline void stop_meas(time_stats_t *ts)
-{
-
-  if (opp_enabled) {
-    long long out = rdtsc_oai();
-
-    ts->diff_now = (out-ts->in);
-
-    ts->diff_now = (out-ts->in);
-    ts->diff += (out-ts->in);
-    /// process duration is the difference between two clock points
-    ts->p_time = (out-ts->in);
-    ts->diff_square += (out-ts->in)*(out-ts->in);
-
-    if ((out-ts->in) > ts->max)
-      ts->max = out-ts->in;
-
-    ts->meas_flag=0;
-  }
-}
-
-static inline void reset_meas(time_stats_t *ts) {
-
-  ts->trials=0;
-  ts->diff=0;
-  ts->diff_now=0;
-  ts->p_time=0;
-  ts->diff_square=0;
-  ts->max=0;
-  ts->meas_flag=0;
-
-}
-
-static inline void copy_meas(time_stats_t *dst_ts,time_stats_t *src_ts)
-{
-
-  if (opp_enabled) {
-    dst_ts->trials=src_ts->trials;
-    dst_ts->diff=src_ts->diff;
-    dst_ts->max=src_ts->max;
-  }
-}
-
-#endif
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_types.h b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_types.h
index ae32f6ffb6..a61a15459c 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_types.h
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_types.h
@@ -31,7 +31,7 @@
 #ifndef __NR_LDPC_TYPES__H__
 #define __NR_LDPC_TYPES__H__
 
-#include "./nrLDPC_tools/time_meas.h"
+#include "PHY/TOOLS/time_meas.h"
 
 // ==============================================================================
 // TYPES
diff --git a/openair1/PHY/CODING/nrPolar_tools/nr_bitwise_operations.c b/openair1/PHY/CODING/nrPolar_tools/nr_bitwise_operations.c
index beabeead36..fdba4e1b65 100644
--- a/openair1/PHY/CODING/nrPolar_tools/nr_bitwise_operations.c
+++ b/openair1/PHY/CODING/nrPolar_tools/nr_bitwise_operations.c
@@ -19,9 +19,20 @@
  *      contact@openairinterface.org
  */
 
+/*!\file PHY/CODING/nrPolar_tools/nr_bitwise_operations.c
+ * \brief
+ * \author Turker Yilmaz
+ * \date 2018
+ * \version 0.1
+ * \company EURECOM
+ * \email turker.yilmaz@eurecom.fr
+ * \note
+ * \warning
+*/
+
 #include "PHY/CODING/nrPolar_tools/nr_polar_defs.h"
 
-void nr_bit2byte_uint32_8_t(uint32_t *in, uint16_t arraySize, uint8_t *out) {
+void nr_bit2byte_uint32_8(uint32_t *in, uint16_t arraySize, uint8_t *out) {
 	uint8_t arrayInd = ceil(arraySize / 32.0);
 	for (int i = 0; i < (arrayInd-1); i++) {
 		for (int j = 0; j < 32; j++) {
@@ -29,10 +40,11 @@ void nr_bit2byte_uint32_8_t(uint32_t *in, uint16_t arraySize, uint8_t *out) {
 		}
 	}
 
-	for (int j = 0; j < arraySize - ((arrayInd-1) * 32); j++) out[j + ((arrayInd-1) * 32)] = (in[(arrayInd-1)] >> j) & 1;
+	for (int j = 0; j < arraySize - ((arrayInd-1) * 32); j++)
+		out[j + ((arrayInd-1) * 32)] = (in[(arrayInd-1)] >> j) & 1;
 }
 
-void nr_byte2bit_uint8_32_t(uint8_t *in, uint16_t arraySize, uint32_t *out) {
+void nr_byte2bit_uint8_32(uint8_t *in, uint16_t arraySize, uint32_t *out) {
 	uint8_t arrayInd = ceil(arraySize / 32.0);
 	for (int i = 0; i < arrayInd; i++) {
 		out[i]=0;
@@ -43,16 +55,3 @@ void nr_byte2bit_uint8_32_t(uint8_t *in, uint16_t arraySize, uint32_t *out) {
 		out[i]|=in[(i*32)];
 	}
 }
-
-void nr_crc_bit2bit_uint32_8_t(uint32_t *in, uint16_t arraySize, uint8_t *out) {
-	out[0]=0xff;
-	out[1]=0xff;
-	out[2]=0xff;
-	uint8_t arrayInd = ceil(arraySize / 32.0);
-	for (int i = 0; i < arrayInd; i++) {
-		out[3+i*4] = ((in[i] & (0x0000000f))<<4) | ((in[i] & (0x000000f0))>>4);
-		out[4+i*4] = (((in[i] & (0x00000f00))<<4) | ((in[i] & (0x0000f000))>>4))>>8;
-		out[5+i*4] = (((in[i] & (0x000f0000))<<4) | ((in[i] & (0x00f00000))>>4))>>16;
-		out[6+i*4] = (((in[i] & (0x0f000000))<<4) | ((in[i] & (0xf0000000))>>4))>>24;
-	}
-}
diff --git a/openair1/PHY/CODING/nrPolar_tools/nr_crc_byte.c b/openair1/PHY/CODING/nrPolar_tools/nr_crc_byte.c
index ef329b3aaa..461eb7d6f6 100644
--- a/openair1/PHY/CODING/nrPolar_tools/nr_crc_byte.c
+++ b/openair1/PHY/CODING/nrPolar_tools/nr_crc_byte.c
@@ -21,43 +21,36 @@
 
 #include "PHY/CODING/nrPolar_tools/nr_polar_defs.h"
 
-
 // ----- Old implementation ----
 uint8_t **crc24c_generator_matrix(uint16_t payloadSizeBits){
 
 	uint8_t crcPolynomialPattern[25] = {1,1,0,1,1,0,0,1,0,1,0,1,1,0,0,0,1,0,0,0,1,0,1,1,1};
 	// 1011 0010 1011 0001 0001 0111 D^24 + D^23 + D^21 + D^20 + D^17 + D^15 + D^13 + D^12 + D^8 + D^4 + D^2 + D + 1
-	uint8_t crcPolynomialSize = 24;// 24 because crc24c
+	uint8_t crcPolynomialSize = 24;
 	uint8_t temp1[crcPolynomialSize], temp2[crcPolynomialSize];
 
 	uint8_t **crc_generator_matrix = malloc(payloadSizeBits * sizeof(uint8_t *));
 	if (crc_generator_matrix)
-	{
 	  for (int i = 0; i < payloadSizeBits; i++)
-	  {
 		  crc_generator_matrix[i] = malloc(crcPolynomialSize * sizeof(uint8_t));
-	  }
-	}
 
 	for (int i = 0; i < crcPolynomialSize; i++) crc_generator_matrix[payloadSizeBits-1][i]=crcPolynomialPattern[i+1];
 
 	for (int i = payloadSizeBits-2; i >= 0; i--){
-
 		for (int j = 0; j < crcPolynomialSize-1; j++) temp1[j]=crc_generator_matrix[i+1][j+1];
+
 		temp1[crcPolynomialSize-1]=0;
 
-		for (int j = 0; j < crcPolynomialSize; j++) temp2[j]=crc_generator_matrix[i+1][0]*crcPolynomialPattern[j+1];
+		for (int j = 0; j < crcPolynomialSize; j++)
+			temp2[j]=crc_generator_matrix[i+1][0]*crcPolynomialPattern[j+1];
 
 		for (int j = 0; j < crcPolynomialSize; j++){
-			if(temp1[j]+temp2[j] == 1){
+			if(temp1[j]+temp2[j] == 1)
 				crc_generator_matrix[i][j]=1;
-			} else {
+			else
 				crc_generator_matrix[i][j]=0;
-			}
 		}
-
 	}
-
 	return crc_generator_matrix;
 }
 
@@ -70,30 +63,26 @@ uint8_t **crc11_generator_matrix(uint16_t payloadSizeBits){
 
 	uint8_t **crc_generator_matrix = malloc(payloadSizeBits * sizeof(uint8_t *));
 	if (crc_generator_matrix)
-	{
 	  for (int i = 0; i < payloadSizeBits; i++)
-	  {
 		  crc_generator_matrix[i] = malloc(crcPolynomialSize * sizeof(uint8_t));
-	  }
-	}
 
 	for (int i = 0; i < crcPolynomialSize; i++) crc_generator_matrix[payloadSizeBits-1][i]=crcPolynomialPattern[i+1];
 
 	for (int i = payloadSizeBits-2; i >= 0; i--){
+		for (int j = 0; j < crcPolynomialSize-1; j++)
+			temp1[j]=crc_generator_matrix[i+1][j+1];
 
-		for (int j = 0; j < crcPolynomialSize-1; j++) temp1[j]=crc_generator_matrix[i+1][j+1];
 		temp1[crcPolynomialSize-1]=0;
 
-		for (int j = 0; j < crcPolynomialSize; j++) temp2[j]=crc_generator_matrix[i+1][0]*crcPolynomialPattern[j+1];
+		for (int j = 0; j < crcPolynomialSize; j++)
+			temp2[j]=crc_generator_matrix[i+1][0]*crcPolynomialPattern[j+1];
 
 		for (int j = 0; j < crcPolynomialSize; j++){
-			if(temp1[j]+temp2[j] == 1){
+			if(temp1[j]+temp2[j] == 1)
 				crc_generator_matrix[i][j]=1;
-			} else {
+			else
 				crc_generator_matrix[i][j]=0;
-			}
 		}
-
 	}
 
 	return crc_generator_matrix;
@@ -105,33 +94,30 @@ uint8_t **crc6_generator_matrix(uint16_t payloadSizeBits){
 	// 0110 0001 D^6 + D^5 + 1
 	uint8_t crcPolynomialSize = 6;
 	uint8_t temp1[crcPolynomialSize], temp2[crcPolynomialSize];
-
 	uint8_t **crc_generator_matrix = malloc(payloadSizeBits * sizeof(uint8_t *));
-	if (crc_generator_matrix)
-	{
-	  for (int i = 0; i < payloadSizeBits; i++)
-	  {
-		  crc_generator_matrix[i] = malloc(crcPolynomialSize * sizeof(uint8_t));
-	  }
-	}
 
-	for (int i = 0; i < crcPolynomialSize; i++) crc_generator_matrix[payloadSizeBits-1][i]=crcPolynomialPattern[i+1];
+	if (crc_generator_matrix)
+	  for (int i = 0; i < payloadSizeBits; i++)
+		  crc_generator_matrix[i] = malloc(crcPolynomialSize * sizeof(uint8_t));
+
+	for (int i = 0; i < crcPolynomialSize; i++)
+		crc_generator_matrix[payloadSizeBits-1][i]=crcPolynomialPattern[i+1];
 
 	for (int i = payloadSizeBits-2; i >= 0; i--){
+		for (int j = 0; j < crcPolynomialSize-1; j++)
+			temp1[j]=crc_generator_matrix[i+1][j+1];
 
-		for (int j = 0; j < crcPolynomialSize-1; j++) temp1[j]=crc_generator_matrix[i+1][j+1];
 		temp1[crcPolynomialSize-1]=0;
 
-		for (int j = 0; j < crcPolynomialSize; j++) temp2[j]=crc_generator_matrix[i+1][0]*crcPolynomialPattern[j+1];
+		for (int j = 0; j < crcPolynomialSize; j++)
+			temp2[j]=crc_generator_matrix[i+1][0]*crcPolynomialPattern[j+1];
 
 		for (int j = 0; j < crcPolynomialSize; j++){
-			if(temp1[j]+temp2[j] == 1){
+			if(temp1[j]+temp2[j] == 1)
 				crc_generator_matrix[i][j]=1;
-			} else {
+			else
 				crc_generator_matrix[i][j]=0;
-			}
 		}
-
 	}
 
 	return crc_generator_matrix;
diff --git a/openair1/PHY/CODING/nrPolar_tools/nr_polar_decoder.c b/openair1/PHY/CODING/nrPolar_tools/nr_polar_decoder.c
index cc90247c12..66d0fc481c 100644
--- a/openair1/PHY/CODING/nrPolar_tools/nr_polar_decoder.c
+++ b/openair1/PHY/CODING/nrPolar_tools/nr_polar_decoder.c
@@ -21,11 +21,11 @@
 
 /*!\file PHY/CODING/nrPolar_tools/nr_polar_decoder.c
  * \brief
- * \author Turker Yilmaz
+ * \author Raymond Knopp, Turker Yilmaz
  * \date 2018
  * \version 0.1
  * \company EURECOM
- * \email turker.yilmaz@eurecom.fr
+ * \email raymond.knopp@eurecom.fr, turker.yilmaz@eurecom.fr
  * \note
  * \warning
 */
@@ -39,12 +39,11 @@
 #include "PHY/CODING/nrPolar_tools/nr_polar_defs.h"
 #include "assertions.h"
 
-int8_t polar_decoder(
-  double *input,
-  uint8_t *out,
-  t_nrPolar_params *polarParams,
-  uint8_t listSize,
-  uint8_t pathMetricAppr) {
+int8_t polar_decoder(double *input,
+					 uint32_t *out,
+					 t_nrPolar_params *polarParams,
+					 uint8_t listSize)
+{
   //Assumes no a priori knowledge.
   uint8_t ***bit = nr_alloc_uint8_3D_array(polarParams->N, (polarParams->n+1), 2*listSize);
   uint8_t **bitUpdated = nr_alloc_uint8_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
@@ -118,12 +117,12 @@ int8_t polar_decoder(
   uint8_t listIndex[2*listSize], copyIndex;
 
   for (uint16_t currentBit=0; currentBit<polarParams->N; currentBit++) {
-    updateLLR(llr, llrUpdated, bit, bitUpdated, currentListSize, currentBit, 0, polarParams->N, (polarParams->n+1), pathMetricAppr);
+    updateLLR(llr, llrUpdated, bit, bitUpdated, currentListSize, currentBit, 0, polarParams->N, (polarParams->n+1));
 
     if (polarParams->information_bit_pattern[currentBit]==0) { //Frozen bit.
-      updatePathMetric(pathMetric, llr, currentListSize, 0, currentBit, pathMetricAppr); //approximation=0 --> 11b, approximation=1 --> 12
+      updatePathMetric(pathMetric, llr, currentListSize, 0, currentBit);
     } else { //Information or CRC bit.
-      updatePathMetric2(pathMetric, llr, currentListSize, currentBit, pathMetricAppr);
+      updatePathMetric2(pathMetric, llr, currentListSize, currentBit);
 
       for (int i = 0; i < currentListSize; i++) {
         for (int j = 0; j < polarParams->N; j++) {
@@ -293,567 +292,14 @@ int8_t polar_decoder(
   /*
    * Return bits.
    */
-  //nr_byte2bit_uint8_32_t(polarParams->nr_polar_A, polarParams->payloadBits, out);
+  nr_byte2bit_uint8_32(polarParams->nr_polar_A, polarParams->payloadBits, out);
   return(0);
 }
 
-int8_t polar_decoder_aPriori(double *input,
-                             uint32_t *out,
-                             t_nrPolar_params *polarParams,
-                             uint8_t listSize,
-                             uint8_t pathMetricAppr,
-                             double *aPrioriPayload) {
-  uint8_t ***bit = nr_alloc_uint8_3D_array(polarParams->N, (polarParams->n+1), 2*listSize);
-  uint8_t **bitUpdated = nr_alloc_uint8_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
-  uint8_t **llrUpdated = nr_alloc_uint8_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
-  double ***llr = nr_alloc_double_3D_array(polarParams->N, (polarParams->n+1), 2*listSize);
-  uint8_t **crcChecksum = nr_alloc_uint8_2D_array(polarParams->crcParityBits, 2*listSize);
-  double *pathMetric = malloc(sizeof(double)*(2*listSize));
-  uint8_t *crcState = malloc(sizeof(uint8_t)*(2*listSize)); //0=False, 1=True
-
-  for (int i=0; i<(2*listSize); i++) {
-    pathMetric[i] = 0;
-    crcState[i]=1;
-  }
-
-  for (int i=0; i<polarParams->N; i++) {
-    llrUpdated[i][polarParams->n]=1;
-    bitUpdated[i][0]=((polarParams->information_bit_pattern[i]+1) % 2);
-  }
-
-  uint8_t **extended_crc_generator_matrix = malloc(polarParams->K * sizeof(uint8_t *)); //G_P3
-  uint8_t **tempECGM = malloc(polarParams->K * sizeof(uint8_t *)); //G_P2
-
-  for (int i = 0; i < polarParams->K; i++) {
-    extended_crc_generator_matrix[i] = malloc(polarParams->crcParityBits * sizeof(uint8_t));
-    tempECGM[i] = malloc(polarParams->crcParityBits * sizeof(uint8_t));
-  }
-
-  for (int i=0; i<polarParams->payloadBits; i++) {
-    for (int j=0; j<polarParams->crcParityBits; j++) {
-      tempECGM[i][j]=polarParams->crc_generator_matrix[i][j];
-    }
-  }
-
-  for (int i=polarParams->payloadBits; i<polarParams->K; i++) {
-    for (int j=0; j<polarParams->crcParityBits; j++) {
-      if( (i-polarParams->payloadBits) == j ) {
-        tempECGM[i][j]=1;
-      } else {
-        tempECGM[i][j]=0;
-      }
-    }
-  }
-
-  for (int i=0; i<polarParams->K; i++) {
-    for (int j=0; j<polarParams->crcParityBits; j++) {
-      extended_crc_generator_matrix[i][j]=tempECGM[polarParams->interleaving_pattern[i]][j];
-    }
-  }
-
-  //The index of the last 1-valued bit that appears in each column.
-  uint16_t last1ind[polarParams->crcParityBits];
-
-  for (int j=0; j<polarParams->crcParityBits; j++) {
-    for (int i=0; i<polarParams->K; i++) {
-      if (extended_crc_generator_matrix[i][j]==1) last1ind[j]=i;
-    }
-  }
-
-  double *d_tilde = malloc(sizeof(double) * polarParams->N);
-  nr_polar_rate_matching(input, d_tilde, polarParams->rate_matching_pattern, polarParams->K, polarParams->N, polarParams->encoderLength);
-
-  for (int j = 0; j < polarParams->N; j++) llr[j][polarParams->n][0]=d_tilde[j];
-
-  /*
-   * SCL polar decoder.
-   */
-  uint32_t nonFrozenBit=0;
-  uint8_t currentListSize=1;
-  uint8_t decoderIterationCheck=0;
-  int16_t checkCrcBits=-1;
-  uint8_t listIndex[2*listSize], copyIndex;
-
-  for (uint16_t currentBit=0; currentBit<polarParams->N; currentBit++) {
-    updateLLR(llr, llrUpdated, bit, bitUpdated, currentListSize, currentBit, 0, polarParams->N, (polarParams->n+1), pathMetricAppr);
-
-    if (polarParams->information_bit_pattern[currentBit]==0) { //Frozen bit.
-      updatePathMetric(pathMetric, llr, currentListSize, 0, currentBit, pathMetricAppr); //approximation=0 --> 11b, approximation=1 --> 12
-    } else { //Information or CRC bit.
-      if ( (polarParams->interleaving_pattern[nonFrozenBit] <= polarParams->payloadBits) &&
-           (aPrioriPayload[polarParams->interleaving_pattern[nonFrozenBit]] == 0) ) {
-        //Information bit with known value of "0".
-        updatePathMetric(pathMetric, llr, currentListSize, 0, currentBit, pathMetricAppr);
-        bitUpdated[currentBit][0]=1; //0=False, 1=True
-      } else if ( (polarParams->interleaving_pattern[nonFrozenBit] <= polarParams->payloadBits) &&
-                  (aPrioriPayload[polarParams->interleaving_pattern[nonFrozenBit]] == 1) ) {
-        //Information bit with known value of "1".
-        updatePathMetric(pathMetric, llr, currentListSize, 1, currentBit, pathMetricAppr);
-
-        for (uint8_t i=0; i<currentListSize; i++) bit[currentBit][0][i]=1;
-
-        bitUpdated[currentBit][0]=1;
-        updateCrcChecksum(crcChecksum, extended_crc_generator_matrix, currentListSize, nonFrozenBit, polarParams->crcParityBits);
-      } else {
-        updatePathMetric2(pathMetric, llr, currentListSize, currentBit, pathMetricAppr);
-
-        for (int i = 0; i < currentListSize; i++) {
-          for (int j = 0; j < polarParams->N; j++) {
-            for (int k = 0; k < (polarParams->n+1); k++) {
-              bit[j][k][i+currentListSize]=bit[j][k][i];
-              llr[j][k][i+currentListSize]=llr[j][k][i];
-            }
-          }
-        }
-
-        for (int i = 0; i < currentListSize; i++) {
-          bit[currentBit][0][i]=0;
-          crcState[i+currentListSize]=crcState[i];
-        }
-
-        for (int i = currentListSize; i < 2*currentListSize; i++) bit[currentBit][0][i]=1;
-
-        bitUpdated[currentBit][0]=1;
-        updateCrcChecksum2(crcChecksum, extended_crc_generator_matrix, currentListSize, nonFrozenBit, polarParams->crcParityBits);
-        currentListSize*=2;
-
-        //Keep only the best "listSize" number of entries.
-        if (currentListSize > listSize) {
-          for (uint8_t i = 0; i < 2*listSize; i++) listIndex[i]=i;
-
-          nr_sort_asc_double_1D_array_ind(pathMetric, listIndex, currentListSize);
-          //sort listIndex[listSize, ..., 2*listSize-1] in descending order.
-          uint8_t swaps, tempInd;
-
-          for (uint8_t i = 0; i < listSize; i++) {
-            swaps = 0;
-
-            for (uint8_t j = listSize; j < (2*listSize - i) - 1; j++) {
-              if (listIndex[j+1] > listIndex[j]) {
-                tempInd = listIndex[j];
-                listIndex[j] = listIndex[j + 1];
-                listIndex[j + 1] = tempInd;
-                swaps++;
-              }
-            }
-
-            if (swaps == 0)
-              break;
-          }
-
-          //First, backup the best "listSize" number of entries.
-          for (int k=(listSize-1); k>0; k--) {
-            for (int i=0; i<polarParams->N; i++) {
-              for (int j=0; j<(polarParams->n+1); j++) {
-                bit[i][j][listIndex[(2*listSize-1)-k]]=bit[i][j][listIndex[k]];
-                llr[i][j][listIndex[(2*listSize-1)-k]]=llr[i][j][listIndex[k]];
-              }
-            }
-          }
-
-          for (int k=(listSize-1); k>0; k--) {
-            for (int i = 0; i < polarParams->crcParityBits; i++) {
-              crcChecksum[i][listIndex[(2*listSize-1)-k]] = crcChecksum[i][listIndex[k]];
-            }
-          }
-
-          for (int k=(listSize-1); k>0; k--) crcState[listIndex[(2*listSize-1)-k]]=crcState[listIndex[k]];
-
-          //Copy the best "listSize" number of entries to the first indices.
-          for (int k = 0; k < listSize; k++) {
-            if (k > listIndex[k]) {
-              copyIndex = listIndex[(2*listSize-1)-k];
-            } else { //Use the backup.
-              copyIndex = listIndex[k];
-            }
-
-            for (int i = 0; i < polarParams->N; i++) {
-              for (int j = 0; j < (polarParams->n + 1); j++) {
-                bit[i][j][k] = bit[i][j][copyIndex];
-                llr[i][j][k] = llr[i][j][copyIndex];
-              }
-            }
-          }
-
-          for (int k = 0; k < listSize; k++) {
-            if (k > listIndex[k]) {
-              copyIndex = listIndex[(2*listSize-1)-k];
-            } else { //Use the backup.
-              copyIndex = listIndex[k];
-            }
-
-            for (int i = 0; i < polarParams->crcParityBits; i++) {
-              crcChecksum[i][k]=crcChecksum[i][copyIndex];
-            }
-          }
-
-          for (int k = 0; k < listSize; k++) {
-            if (k > listIndex[k]) {
-              copyIndex = listIndex[(2*listSize-1)-k];
-            } else { //Use the backup.
-              copyIndex = listIndex[k];
-            }
-
-            crcState[k]=crcState[copyIndex];
-          }
-
-          currentListSize = listSize;
-        }
-      }
-
-      for (int i=0; i<polarParams->crcParityBits; i++) {
-        if (last1ind[i]==nonFrozenBit) {
-          checkCrcBits=i;
-          break;
-        }
-      }
-
-      if ( checkCrcBits > (-1) ) {
-        for (uint8_t i = 0; i < currentListSize; i++) {
-          if (crcChecksum[checkCrcBits][i]==1) {
-            crcState[i]=0; //0=False, 1=True
-          }
-        }
-      }
-
-      for (uint8_t i = 0; i < currentListSize; i++) decoderIterationCheck+=crcState[i];
-
-      if (decoderIterationCheck==0) {
-        //perror("[SCL polar decoder] All list entries have failed the CRC checks.");
-        free(d_tilde);
-        free(pathMetric);
-        free(crcState);
-        nr_free_uint8_3D_array(bit, polarParams->N, (polarParams->n+1));
-        nr_free_double_3D_array(llr, polarParams->N, (polarParams->n+1));
-        nr_free_uint8_2D_array(crcChecksum, polarParams->crcParityBits);
-        return(-1);
-      }
-
-      nonFrozenBit++;
-      decoderIterationCheck=0;
-      checkCrcBits=-1;
-    }
-  }
-
-  for (uint8_t i = 0; i < 2*listSize; i++) listIndex[i]=i;
-
-  nr_sort_asc_double_1D_array_ind(pathMetric, listIndex, currentListSize);
-
-  for (uint8_t i = 0; i < fmin(listSize, (pow(2,polarParams->crcCorrectionBits)) ); i++) {
-    if ( crcState[listIndex[i]] == 1 ) {
-      for (int j = 0; j < polarParams->N; j++) polarParams->nr_polar_U[j]=bit[j][0][listIndex[i]];
-
-      //Extract the information bits (û to ĉ)
-      nr_polar_info_bit_extraction(polarParams->nr_polar_U, polarParams->nr_polar_CPrime, polarParams->information_bit_pattern, polarParams->N);
-      //Deinterleaving (ĉ to b)
-      nr_polar_deinterleaver(polarParams->nr_polar_CPrime, polarParams->nr_polar_B, polarParams->interleaving_pattern, polarParams->K);
-
-      //Remove the CRC (â)
-      for (int j = 0; j < polarParams->payloadBits; j++)
-        polarParams->nr_polar_A[j]=polarParams->nr_polar_B[j];
-
-      break;
-    }
-  }
-
-  free(d_tilde);
-  free(pathMetric);
-  free(crcState);
-  nr_free_uint8_3D_array(bit, polarParams->N, (polarParams->n+1));
-  nr_free_double_3D_array(llr, polarParams->N, (polarParams->n+1));
-  nr_free_uint8_2D_array(crcChecksum, polarParams->crcParityBits);
-  nr_free_uint8_2D_array(extended_crc_generator_matrix, polarParams->K);
-  nr_free_uint8_2D_array(tempECGM, polarParams->K);
-  /*
-   * Return bits.
-   */
-  nr_byte2bit_uint8_32_t(polarParams->nr_polar_A, polarParams->payloadBits, out);
-  return(0);
-}
-
-
-
-int8_t polar_decoder_aPriori_timing(double *input,
-                                    uint32_t *out,
-                                    t_nrPolar_params *polarParams,
-                                    uint8_t listSize,
-                                    uint8_t pathMetricAppr,
-                                    double *aPrioriPayload,
-                                    double cpuFreqGHz,
-                                    FILE *logFile) {
-  uint8_t ***bit = nr_alloc_uint8_3D_array(polarParams->N, (polarParams->n+1), 2*listSize);
-  uint8_t **bitUpdated = nr_alloc_uint8_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
-  uint8_t **llrUpdated = nr_alloc_uint8_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
-  double ***llr = nr_alloc_double_3D_array(polarParams->N, (polarParams->n+1), 2*listSize);
-  uint8_t **crcChecksum = nr_alloc_uint8_2D_array(polarParams->crcParityBits, 2*listSize);
-  double *pathMetric = malloc(sizeof(double)*(2*listSize));
-  uint8_t *crcState = malloc(sizeof(uint8_t)*(2*listSize)); //0=False, 1=True
-
-  for (int i=0; i<(2*listSize); i++) {
-    pathMetric[i] = 0;
-    crcState[i]=1;
-  }
-
-  for (int i=0; i<polarParams->N; i++) {
-    llrUpdated[i][polarParams->n]=1;
-    bitUpdated[i][0]=((polarParams->information_bit_pattern[i]+1) % 2);
-  }
-
-  uint8_t **extended_crc_generator_matrix = malloc(polarParams->K * sizeof(uint8_t *)); //G_P3
-  uint8_t **tempECGM = malloc(polarParams->K * sizeof(uint8_t *)); //G_P2
-
-  for (int i = 0; i < polarParams->K; i++) {
-    extended_crc_generator_matrix[i] = malloc(polarParams->crcParityBits * sizeof(uint8_t));
-    tempECGM[i] = malloc(polarParams->crcParityBits * sizeof(uint8_t));
-  }
-
-  for (int i=0; i<polarParams->payloadBits; i++) {
-    for (int j=0; j<polarParams->crcParityBits; j++) {
-      tempECGM[i][j]=polarParams->crc_generator_matrix[i][j];
-    }
-  }
-
-  for (int i=polarParams->payloadBits; i<polarParams->K; i++) {
-    for (int j=0; j<polarParams->crcParityBits; j++) {
-      if( (i-polarParams->payloadBits) == j ) {
-        tempECGM[i][j]=1;
-      } else {
-        tempECGM[i][j]=0;
-      }
-    }
-  }
-
-  for (int i=0; i<polarParams->K; i++) {
-    for (int j=0; j<polarParams->crcParityBits; j++) {
-      extended_crc_generator_matrix[i][j]=tempECGM[polarParams->interleaving_pattern[i]][j];
-    }
-  }
-
-  //The index of the last 1-valued bit that appears in each column.
-  uint16_t last1ind[polarParams->crcParityBits];
-
-  for (int j=0; j<polarParams->crcParityBits; j++) {
-    for (int i=0; i<polarParams->K; i++) {
-      if (extended_crc_generator_matrix[i][j]==1) last1ind[j]=i;
-    }
-  }
-
-  double *d_tilde = malloc(sizeof(double) * polarParams->N);
-  nr_polar_rate_matching(input, d_tilde, polarParams->rate_matching_pattern, polarParams->K, polarParams->N, polarParams->encoderLength);
-
-  for (int j = 0; j < polarParams->N; j++) llr[j][polarParams->n][0]=d_tilde[j];
-
-  /*
-   * SCL polar decoder.
-   */
-  uint32_t nonFrozenBit=0;
-  uint8_t currentListSize=1;
-  uint8_t decoderIterationCheck=0;
-  int16_t checkCrcBits=-1;
-  uint8_t listIndex[2*listSize], copyIndex;
-
-  for (uint16_t currentBit=0; currentBit<polarParams->N; currentBit++) {
-    updateLLR(llr, llrUpdated, bit, bitUpdated, currentListSize, currentBit, 0, polarParams->N, (polarParams->n+1), pathMetricAppr);
-
-    if (polarParams->information_bit_pattern[currentBit]==0) { //Frozen bit.
-      updatePathMetric(pathMetric, llr, currentListSize, 0, currentBit, pathMetricAppr); //approximation=0 --> 11b, approximation=1 --> 12
-    } else { //Information or CRC bit.
-      if ( (polarParams->interleaving_pattern[nonFrozenBit] <= polarParams->payloadBits) &&
-           (aPrioriPayload[polarParams->interleaving_pattern[nonFrozenBit]] == 0) ) {
-        //Information bit with known value of "0".
-        updatePathMetric(pathMetric, llr, currentListSize, 0, currentBit, pathMetricAppr);
-        bitUpdated[currentBit][0]=1; //0=False, 1=True
-      } else if ( (polarParams->interleaving_pattern[nonFrozenBit] <= polarParams->payloadBits) &&
-                  (aPrioriPayload[polarParams->interleaving_pattern[nonFrozenBit]] == 1) ) {
-        //Information bit with known value of "1".
-        updatePathMetric(pathMetric, llr, currentListSize, 1, currentBit, pathMetricAppr);
-
-        for (uint8_t i=0; i<currentListSize; i++) bit[currentBit][0][i]=1;
-
-        bitUpdated[currentBit][0]=1;
-        updateCrcChecksum(crcChecksum, extended_crc_generator_matrix, currentListSize, nonFrozenBit, polarParams->crcParityBits);
-      } else {
-        updatePathMetric2(pathMetric, llr, currentListSize, currentBit, pathMetricAppr);
-
-        for (int i = 0; i < currentListSize; i++) {
-          for (int j = 0; j < polarParams->N; j++) {
-            for (int k = 0; k < (polarParams->n+1); k++) {
-              bit[j][k][i+currentListSize]=bit[j][k][i];
-              llr[j][k][i+currentListSize]=llr[j][k][i];
-            }
-          }
-        }
-
-        for (int i = 0; i < currentListSize; i++) {
-          bit[currentBit][0][i]=0;
-          crcState[i+currentListSize]=crcState[i];
-        }
-
-        for (int i = currentListSize; i < 2*currentListSize; i++) bit[currentBit][0][i]=1;
-
-        bitUpdated[currentBit][0]=1;
-        updateCrcChecksum2(crcChecksum, extended_crc_generator_matrix, currentListSize, nonFrozenBit, polarParams->crcParityBits);
-        currentListSize*=2;
-
-        //Keep only the best "listSize" number of entries.
-        if (currentListSize > listSize) {
-          for (uint8_t i = 0; i < 2*listSize; i++) listIndex[i]=i;
-
-          nr_sort_asc_double_1D_array_ind(pathMetric, listIndex, currentListSize);
-          //sort listIndex[listSize, ..., 2*listSize-1] in descending order.
-          uint8_t swaps, tempInd;
-
-          for (uint8_t i = 0; i < listSize; i++) {
-            swaps = 0;
-
-            for (uint8_t j = listSize; j < (2*listSize - i) - 1; j++) {
-              if (listIndex[j+1] > listIndex[j]) {
-                tempInd = listIndex[j];
-                listIndex[j] = listIndex[j + 1];
-                listIndex[j + 1] = tempInd;
-                swaps++;
-              }
-            }
-
-            if (swaps == 0)
-              break;
-          }
-
-          //First, backup the best "listSize" number of entries.
-          for (int k=(listSize-1); k>0; k--) {
-            for (int i=0; i<polarParams->N; i++) {
-              for (int j=0; j<(polarParams->n+1); j++) {
-                bit[i][j][listIndex[(2*listSize-1)-k]]=bit[i][j][listIndex[k]];
-                llr[i][j][listIndex[(2*listSize-1)-k]]=llr[i][j][listIndex[k]];
-              }
-            }
-          }
-
-          for (int k=(listSize-1); k>0; k--) {
-            for (int i = 0; i < polarParams->crcParityBits; i++) {
-              crcChecksum[i][listIndex[(2*listSize-1)-k]] = crcChecksum[i][listIndex[k]];
-            }
-          }
-
-          for (int k=(listSize-1); k>0; k--) crcState[listIndex[(2*listSize-1)-k]]=crcState[listIndex[k]];
-
-          //Copy the best "listSize" number of entries to the first indices.
-          for (int k = 0; k < listSize; k++) {
-            if (k > listIndex[k]) {
-              copyIndex = listIndex[(2*listSize-1)-k];
-            } else { //Use the backup.
-              copyIndex = listIndex[k];
-            }
-
-            for (int i = 0; i < polarParams->N; i++) {
-              for (int j = 0; j < (polarParams->n + 1); j++) {
-                bit[i][j][k] = bit[i][j][copyIndex];
-                llr[i][j][k] = llr[i][j][copyIndex];
-              }
-            }
-          }
-
-          for (int k = 0; k < listSize; k++) {
-            if (k > listIndex[k]) {
-              copyIndex = listIndex[(2*listSize-1)-k];
-            } else { //Use the backup.
-              copyIndex = listIndex[k];
-            }
-
-            for (int i = 0; i < polarParams->crcParityBits; i++) {
-              crcChecksum[i][k]=crcChecksum[i][copyIndex];
-            }
-          }
-
-          for (int k = 0; k < listSize; k++) {
-            if (k > listIndex[k]) {
-              copyIndex = listIndex[(2*listSize-1)-k];
-            } else { //Use the backup.
-              copyIndex = listIndex[k];
-            }
-
-            crcState[k]=crcState[copyIndex];
-          }
-
-          currentListSize = listSize;
-        }
-      }
-
-      for (int i=0; i<polarParams->crcParityBits; i++) {
-        if (last1ind[i]==nonFrozenBit) {
-          checkCrcBits=i;
-          break;
-        }
-      }
-
-      if ( checkCrcBits > (-1) ) {
-        for (uint8_t i = 0; i < currentListSize; i++) {
-          if (crcChecksum[checkCrcBits][i]==1) {
-            crcState[i]=0; //0=False, 1=True
-          }
-        }
-      }
-
-      for (uint8_t i = 0; i < currentListSize; i++) decoderIterationCheck+=crcState[i];
-
-      if (decoderIterationCheck==0) {
-        //perror("[SCL polar decoder] All list entries have failed the CRC checks.");
-        free(d_tilde);
-        free(pathMetric);
-        free(crcState);
-        nr_free_uint8_3D_array(bit, polarParams->N, (polarParams->n+1));
-        nr_free_double_3D_array(llr, polarParams->N, (polarParams->n+1));
-        nr_free_uint8_2D_array(crcChecksum, polarParams->crcParityBits);
-        return(-1);
-      }
-
-      nonFrozenBit++;
-      decoderIterationCheck=0;
-      checkCrcBits=-1;
-    }
-  }
-
-  for (uint8_t i = 0; i < 2*listSize; i++) listIndex[i]=i;
-
-  nr_sort_asc_double_1D_array_ind(pathMetric, listIndex, currentListSize);
-
-  for (uint8_t i = 0; i < fmin(listSize, (pow(2,polarParams->crcCorrectionBits)) ); i++) {
-    if ( crcState[listIndex[i]] == 1 ) {
-      for (int j = 0; j < polarParams->N; j++) polarParams->nr_polar_U[j]=bit[j][0][listIndex[i]];
-
-      //Extract the information bits (û to ĉ)
-      nr_polar_info_bit_extraction(polarParams->nr_polar_U, polarParams->nr_polar_CPrime, polarParams->information_bit_pattern, polarParams->N);
-      //Deinterleaving (ĉ to b)
-      nr_polar_deinterleaver(polarParams->nr_polar_CPrime, polarParams->nr_polar_B, polarParams->interleaving_pattern, polarParams->K);
-
-      //Remove the CRC (â)
-      for (int j = 0; j < polarParams->payloadBits; j++) polarParams->nr_polar_A[j]=polarParams->nr_polar_B[j];
-
-      break;
-    }
-  }
-
-  free(d_tilde);
-  free(pathMetric);
-  free(crcState);
-  nr_free_uint8_3D_array(bit, polarParams->N, (polarParams->n+1));
-  nr_free_double_3D_array(llr, polarParams->N, (polarParams->n+1));
-  nr_free_uint8_2D_array(crcChecksum, polarParams->crcParityBits);
-  nr_free_uint8_2D_array(extended_crc_generator_matrix, polarParams->K);
-  nr_free_uint8_2D_array(tempECGM, polarParams->K);
-  /*
-   * Return bits.
-   */
-  nr_byte2bit_uint8_32_t(polarParams->nr_polar_A, polarParams->payloadBits, out);
-  return(0);
-}
-
-
 int8_t polar_decoder_dci(double *input,
                          uint32_t *out,
                          t_nrPolar_params *polarParams,
                          uint8_t listSize,
-                         uint8_t pathMetricAppr,
                          uint16_t n_RNTI) {
   uint8_t ***bit = nr_alloc_uint8_3D_array(polarParams->N, (polarParams->n+1), 2*listSize);
   uint8_t **bitUpdated = nr_alloc_uint8_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
@@ -941,12 +387,12 @@ int8_t polar_decoder_dci(double *input,
   uint8_t listIndex[2*listSize], copyIndex;
 
   for (uint16_t currentBit=0; currentBit<polarParams->N; currentBit++) {
-    updateLLR(llr, llrUpdated, bit, bitUpdated, currentListSize, currentBit, 0, polarParams->N, (polarParams->n+1), pathMetricAppr);
+    updateLLR(llr, llrUpdated, bit, bitUpdated, currentListSize, currentBit, 0, polarParams->N, (polarParams->n+1));
 
     if (polarParams->information_bit_pattern[currentBit]==0) { //Frozen bit.
-      updatePathMetric(pathMetric, llr, currentListSize, 0, currentBit, pathMetricAppr); //approximation=0 --> 11b, approximation=1 --> 12
+      updatePathMetric(pathMetric, llr, currentListSize, 0, currentBit);
     } else { //Information or CRC bit.
-      updatePathMetric2(pathMetric, llr, currentListSize, currentBit, pathMetricAppr);
+      updatePathMetric2(pathMetric, llr, currentListSize, currentBit);
 
       for (int i = 0; i < currentListSize; i++) {
         for (int j = 0; j < polarParams->N; j++) {
@@ -1116,7 +562,7 @@ int8_t polar_decoder_dci(double *input,
   /*
    * Return bits.
    */
-  nr_byte2bit_uint8_32_t(polarParams->nr_polar_A, polarParams->payloadBits, out);
+  nr_byte2bit_uint8_32(polarParams->nr_polar_A, polarParams->payloadBits, out);
   return(0);
 }
 
diff --git a/openair1/PHY/CODING/nrPolar_tools/nr_polar_decoding_tools.c b/openair1/PHY/CODING/nrPolar_tools/nr_polar_decoding_tools.c
index bec322b946..bf8a90e0d9 100644
--- a/openair1/PHY/CODING/nrPolar_tools/nr_polar_decoding_tools.c
+++ b/openair1/PHY/CODING/nrPolar_tools/nr_polar_decoding_tools.c
@@ -37,27 +37,26 @@
 //#define DEBUG_NEW_IMPL 1
 
 void updateLLR(double ***llr,
-	       uint8_t **llrU,
-	       uint8_t ***bit,
-	       uint8_t **bitU,
-	       uint8_t listSize,
-	       uint16_t row,
-	       uint16_t col,
-	       uint16_t xlen,
-	       uint8_t ylen,
-	       uint8_t approximation)
+			   uint8_t **llrU,
+			   uint8_t ***bit,
+			   uint8_t **bitU,
+			   uint8_t listSize,
+			   uint16_t row,
+			   uint16_t col,
+			   uint16_t xlen,
+			   uint8_t ylen)
 {
 	uint16_t offset = (xlen/(pow(2,(ylen-col-1))));
 	for (uint8_t i=0; i<listSize; i++) {
 		if (( (row) % (2*offset) ) >= offset ) {
 			if(bitU[row-offset][col]==0) updateBit(bit, bitU, listSize, (row-offset), col, xlen, ylen);
-			if(llrU[row-offset][col+1]==0) updateLLR(llr, llrU, bit, bitU, listSize, (row-offset), (col+1), xlen, ylen, approximation);
-			if(llrU[row][col+1]==0) updateLLR(llr, llrU, bit, bitU, listSize, row, (col+1), xlen, ylen, approximation);
+			if(llrU[row-offset][col+1]==0) updateLLR(llr, llrU, bit, bitU, listSize, (row-offset), (col+1), xlen, ylen);
+			if(llrU[row][col+1]==0) updateLLR(llr, llrU, bit, bitU, listSize, row, (col+1), xlen, ylen);
 			llr[row][col][i] = (pow((-1),bit[row-offset][col][i])*llr[row-offset][col+1][i]) + llr[row][col+1][i];
 		} else {
-			if(llrU[row][col+1]==0) updateLLR(llr, llrU, bit, bitU, listSize, row, (col+1), xlen, ylen, approximation);
-			if(llrU[row+offset][col+1]==0) updateLLR(llr, llrU, bit, bitU, listSize, (row+offset), (col+1), xlen, ylen, approximation);
-			computeLLR(llr, row, col, i, offset, approximation);
+			if(llrU[row][col+1]==0) updateLLR(llr, llrU, bit, bitU, listSize, row, (col+1), xlen, ylen);
+			if(llrU[row+offset][col+1]==0) updateLLR(llr, llrU, bit, bitU, listSize, (row+offset), (col+1), xlen, ylen);
+			computeLLR(llr, row, col, i, offset);
 		}
 	}
 	llrU[row][col]=1;
@@ -73,7 +72,6 @@ void updateBit(uint8_t ***bit,
 			   uint16_t xlen,
 			   uint8_t ylen)
 {
-
 	uint16_t offset = ( xlen/(pow(2,(ylen-col))) );
 
 	for (uint8_t i=0; i<listSize; i++) {
@@ -91,78 +89,47 @@ void updateBit(uint8_t ***bit,
 }
 
 void updatePathMetric(double *pathMetric,
-					  double ***llr,
+		              double ***llr,
 					  uint8_t listSize,
 					  uint8_t bitValue,
-					  uint16_t row,
-					  uint8_t approximation)
+					  uint16_t row)
 {
-	if (approximation) { //eq. (12)
-		for (uint8_t i=0; i<listSize; i++) {
-			if ((2*bitValue) != ( 1 - copysign(1.0,llr[row][0][i]) )) pathMetric[i] += fabs(llr[row][0][i]);
-		}
-	} else { //eq. (11b)
-		int8_t multiplier = (2*bitValue) - 1;
-		for (uint8_t i=0; i<listSize; i++) pathMetric[i] += log ( 1 + exp(multiplier*llr[row][0][i]) ) ;
-	}
-}
+	int8_t multiplier = (2*bitValue) - 1;
+	for (uint8_t i=0; i<listSize; i++)
+		pathMetric[i] += log ( 1 + exp(multiplier*llr[row][0][i]) ) ; //eq. (11b)
 
+}
 
 void updatePathMetric2(double *pathMetric,
 					   double ***llr,
 					   uint8_t listSize,
-					   uint16_t row,
-					   uint8_t appr)
+					   uint16_t row)
 {
 	double *tempPM = malloc(sizeof(double) * listSize);
-	for (int i=0; i < listSize; i++) tempPM[i]=pathMetric[i];
-
+	memcpy(tempPM, pathMetric, (sizeof(double) * listSize));
 
 	uint8_t bitValue = 0;
-	if (appr) { //eq. (12)
-		for (uint8_t i = 0; i < listSize; i++) {
-			if ((2 * bitValue) != (1 - copysign(1.0, llr[row][0][i]))) pathMetric[i] += fabs(llr[row][0][i]);
-		}
-	} else { //eq. (11b)
-		int8_t multiplier = (2 * bitValue) - 1;
-		for (uint8_t i = 0; i < listSize; i++) pathMetric[i] += log(1 + exp(multiplier * llr[row][0][i]));
-	}
+	int8_t multiplier = (2 * bitValue) - 1;
+	for (uint8_t i = 0; i < listSize; i++)
+		pathMetric[i] += log(1 + exp(multiplier * llr[row][0][i])); //eq. (11b)
 
 	bitValue = 1;
-	if (appr) { //eq. (12)
-		for (uint8_t i = listSize; i < 2*listSize; i++) {
-			if ((2 * bitValue) != (1 - copysign(1.0, llr[row][0][(i-listSize)]))) pathMetric[i] = tempPM[(i-listSize)] + fabs(llr[row][0][(i-listSize)]);
-		}
-	} else { //eq. (11b)
-		int8_t multiplier = (2 * bitValue) - 1;
-		for (uint8_t i = listSize; i < 2*listSize; i++) pathMetric[i] = tempPM[(i-listSize)] + log(1 + exp(multiplier * llr[row][0][(i-listSize)]));
-	}
+	multiplier = (2 * bitValue) - 1;
+	for (uint8_t i = listSize; i < 2*listSize; i++)
+		pathMetric[i] = tempPM[(i-listSize)] + log(1 + exp(multiplier * llr[row][0][(i-listSize)])); //eq. (11b)
 
 	free(tempPM);
-
-
-
-  }
+}
 
 void computeLLR(double ***llr,
 				uint16_t row,
 				uint16_t col,
 				uint8_t i,
-				uint16_t offset,
-				uint8_t approximation)
+				uint16_t offset)
 {
 	double a = llr[row][col + 1][i];
-	double absA = fabs(a);
 	double b = llr[row + offset][col + 1][i];
-	double absB = fabs(b);
-
-	if (approximation || isinf(absA) || isinf(absB)) { //eq. (9)
-		llr[row][col][i] = copysign(1.0, a) * copysign(1.0, b) * fmin(absA, absB);
-	} else { //eq. (8a)
-		llr[row][col][i] = log((exp(a + b) + 1) / (exp(a) + exp(b)));
-	}
-
-
+	llr[row][col][i] = log((exp(a + b) + 1) / (exp(a) + exp(b))); //eq. (8a)
 }
 
 void updateCrcChecksum(uint8_t **crcChecksum,
@@ -193,7 +160,7 @@ void updateCrcChecksum2(uint8_t **crcChecksum,
 
 
 
-decoder_node_t *new_decoder_node(int first_leaf_index,int level) {
+decoder_node_t *new_decoder_node(int first_leaf_index, int level) {
 
   decoder_node_t *node=(decoder_node_t *)malloc(sizeof(decoder_node_t));
 
@@ -208,32 +175,34 @@ decoder_node_t *new_decoder_node(int first_leaf_index,int level) {
   node->beta   = (int16_t*)malloc16(node->Nv*sizeof(int16_t));
   memset((void*)node->beta,-1,node->Nv*sizeof(int16_t));
   
-
   return(node);
 }
 
-decoder_node_t *add_nodes(int level,int first_leaf_index,t_nrPolar_params *pp) {
+decoder_node_t *add_nodes(int level, int first_leaf_index, t_nrPolar_params *polarParams) {
 
-  int all_frozen_below=1;
+  int all_frozen_below = 1;
   int Nv = 1<<level;
-  decoder_node_t *new_node = new_decoder_node(first_leaf_index,level);
+  decoder_node_t *new_node = new_decoder_node(first_leaf_index, level);
 #ifdef DEBUG_NEW_IMPL
-  printf("New node %d order %d, level %d\n",pp->tree.num_nodes,Nv,level);
+  printf("New node %d order %d, level %d\n",polarParams->tree.num_nodes,Nv,level);
 #endif
-  pp->tree.num_nodes++;
+  polarParams->tree.num_nodes++;
   if (level==0) {
 #ifdef DEBUG_NEW_IMPL
-    printf("leaf %d (%s)\n",first_leaf_index,pp->information_bit_pattern[first_leaf_index]==1 ? "information or crc" : "frozen");
+    printf("leaf %d (%s)\n", first_leaf_index, polarParams->information_bit_pattern[first_leaf_index]==1 ? "information or crc" : "frozen");
 #endif
     new_node->leaf=1;
-    new_node->all_frozen = pp->information_bit_pattern[first_leaf_index]==0 ? 1 : 0;
+    new_node->all_frozen = polarParams->information_bit_pattern[first_leaf_index]==0 ? 1 : 0;
     return new_node; // this is a leaf node
   }
 
   for (int i=0;i<Nv;i++) {
-    if (pp->information_bit_pattern[i+first_leaf_index]>0) all_frozen_below=0; 
+    if (polarParams->information_bit_pattern[i+first_leaf_index]>0)
+    	all_frozen_below=0;
   }
-  if (all_frozen_below==0) new_node->left=add_nodes(level-1,first_leaf_index,pp);
+
+  if (all_frozen_below==0)
+	  new_node->left=add_nodes(level-1, first_leaf_index, polarParams);
   else {
 #ifdef DEBUG_NEW_IMPL
     printf("aggregating frozen bits %d ... %d at level %d (%s)\n",first_leaf_index,first_leaf_index+Nv-1,level,((first_leaf_index/Nv)&1)==0?"left":"right");
@@ -241,21 +210,22 @@ decoder_node_t *add_nodes(int level,int first_leaf_index,t_nrPolar_params *pp) {
     new_node->leaf=1;
     new_node->all_frozen=1;
   }
-  if (all_frozen_below==0) new_node->right=add_nodes(level-1,first_leaf_index+(Nv/2),pp);
+  if (all_frozen_below==0)
+	  new_node->right=add_nodes(level-1,first_leaf_index+(Nv/2),polarParams);
 
 #ifdef DEBUG_NEW_IMPL
   printf("new_node (%d): first_leaf_index %d, left %p, right %p\n",Nv,first_leaf_index,new_node->left,new_node->right);
-#endif  
+#endif
+
   return(new_node);
 }
 
-
-void build_decoder_tree(t_nrPolar_params *pp) {
-
-  pp->tree.num_nodes=0;
-  pp->tree.root = add_nodes(pp->n,0,pp);
+void build_decoder_tree(t_nrPolar_params *polarParams)
+{
+  polarParams->tree.num_nodes=0;
+  polarParams->tree.root = add_nodes(polarParams->n,0,polarParams);
 #ifdef DEBUG_NEW_IMPL
-  printf("root : left %p, right %p\n",pp->tree.root->left,pp->tree.root->right);
+  printf("root : left %p, right %p\n",polarParams->tree.root->left,polarParams->tree.root->right);
 #endif
 }
 
@@ -271,7 +241,7 @@ void build_decoder_tree(t_nrPolar_params *pp) {
 #define _mm_subs_pi16(a,b) vsub_s16(a,b)
 #endif
 
-void applyFtoleft(t_nrPolar_params *pp,decoder_node_t *node) {
+void applyFtoleft(const t_nrPolar_params *pp, decoder_node_t *node) {
   int16_t *alpha_v=node->alpha;
   int16_t *alpha_l=node->left->alpha;
   int16_t *betal = node->left->beta;
@@ -368,18 +338,18 @@ void applyFtoleft(t_nrPolar_params *pp,decoder_node_t *node) {
 
     else
 #endif
-    { // equvalent scalar code to above, activated only on non x86/ARM architectures
+    { // equivalent scalar code to above, activated only on non x86/ARM architectures
       for (int i=0;i<node->Nv/2;i++) {
-	a=alpha_v[i];
-	b=alpha_v[i+(node->Nv/2)];
-	maska=a>>15;
-	maskb=b>>15;
-	absa=(a+maska)^maska;
-	absb=(b+maskb)^maskb;
-	minabs = absa<absb ? absa : absb;
-	alpha_l[i] = (maska^maskb)==0 ? minabs : -minabs;
-	//	printf("alphal[%d] %d (%d,%d)\n",i,alpha_l[i],a,b);
-      }
+    	  a=alpha_v[i];
+    	  b=alpha_v[i+(node->Nv/2)];
+    	  maska=a>>15;
+    	  maskb=b>>15;
+    	  absa=(a+maska)^maska;
+    	  absb=(b+maskb)^maskb;
+    	  minabs = absa<absb ? absa : absb;
+    	  alpha_l[i] = (maska^maskb)==0 ? minabs : -minabs;
+    	  //	printf("alphal[%d] %d (%d,%d)\n",i,alpha_l[i],a,b);
+    	  }
     }
     if (node->Nv == 2) { // apply hard decision on left node
       betal[0] = (alpha_l[0]>0) ? -1 : 1;
@@ -394,7 +364,7 @@ void applyFtoleft(t_nrPolar_params *pp,decoder_node_t *node) {
   }
 }
 
-void applyGtoright(t_nrPolar_params *pp,decoder_node_t *node) {
+void applyGtoright(const t_nrPolar_params *pp,decoder_node_t *node) {
 
   int16_t *alpha_v=node->alpha;
   int16_t *alpha_r=node->right->alpha;
@@ -448,7 +418,7 @@ void applyGtoright(t_nrPolar_params *pp,decoder_node_t *node) {
     }
     else 
 #endif
-      {// equvalent scalar code to above, activated only on non x86/ARM architectures or Nv=1,2
+      {// equivalent scalar code to above, activated only on non x86/ARM architectures or Nv=1,2
 	for (int i=0;i<node->Nv/2;i++) {
 	  alpha_r[i] = alpha_v[i+(node->Nv/2)] - (betal[i]*alpha_v[i]);
 	}
@@ -463,13 +433,9 @@ void applyGtoright(t_nrPolar_params *pp,decoder_node_t *node) {
   }
 }
 
+int16_t all1[16] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
 
-int16_t all1[16] = {1,1,1,1,
-		    1,1,1,1,
-		    1,1,1,1,
-		    1,1,1,1};
-
-void computeBeta(t_nrPolar_params *pp,decoder_node_t *node) {
+void computeBeta(const t_nrPolar_params *pp,decoder_node_t *node) {
 
   int16_t *betav = node->beta;
   int16_t *betal = node->left->beta;
@@ -504,38 +470,37 @@ void computeBeta(t_nrPolar_params *pp,decoder_node_t *node) {
       int ssr4len = node->Nv/2/8;
       register __m128i allones=*((__m128i*)all1);
       for (int i=0;i<sse4len;i++) {
-      ((__m256i*)betav)[i] = _mm_or_si128(_mm_cmpeq_epi16(((__m128i*)betar)[i],
-							  ((__m128i*)betal)[i]),allones));
+      ((__m256i*)betav)[i] = _mm_or_si128(_mm_cmpeq_epi16(((__m128i*)betar)[i], ((__m128i*)betal)[i]),allones));
       }
     }
     else if (sse4mod == 4) {
-      ((__m64*)betav)[0] = _mm_or_si64(_mm_cmpeq_pi16(((__m64*)betar)[0],
-						      ((__m64*)betal)[0]),*((__m64*)all1));
+      ((__m64*)betav)[0] = _mm_or_si64(_mm_cmpeq_pi16(((__m64*)betar)[0], ((__m64*)betal)[0]),*((__m64*)all1));
     }
     else
 #endif
       {
 	for (int i=0;i<node->Nv/2;i++) {
-	  betav[i] = (betal[i] != betar[i]) ? 1 : -1;
+		betav[i] = (betal[i] != betar[i]) ? 1 : -1;
 	}
       }
   }
   else memcpy((void*)&betav[0],betar,(node->Nv/2)*sizeof(int16_t));
   memcpy((void*)&betav[node->Nv/2],betar,(node->Nv/2)*sizeof(int16_t));
-  
 }
 
-void generic_polar_decoder(t_nrPolar_params *pp,decoder_node_t *node) {
+void generic_polar_decoder(const t_nrPolar_params *pp,decoder_node_t *node) {
 
 
   // Apply F to left
-  applyFtoleft(pp,node);
+  applyFtoleft(pp, node);
   // if left is not a leaf recurse down to the left
-  if (node->left->leaf==0) generic_polar_decoder(pp,node->left);
+  if (node->left->leaf==0)
+    generic_polar_decoder(pp, node->left);
 
-  applyGtoright(pp,node);
-  if (node->right->leaf==0) generic_polar_decoder(pp,node->right);	
+  applyGtoright(pp, node);
+  if (node->right->leaf==0) generic_polar_decoder(pp, node->right);
 
-  computeBeta(pp,node);
+  computeBeta(pp, node);
 
 } 
+
diff --git a/openair1/PHY/CODING/nrPolar_tools/nr_polar_defs.h b/openair1/PHY/CODING/nrPolar_tools/nr_polar_defs.h
index d42e8bb6fc..2c37462f75 100644
--- a/openair1/PHY/CODING/nrPolar_tools/nr_polar_defs.h
+++ b/openair1/PHY/CODING/nrPolar_tools/nr_polar_defs.h
@@ -21,11 +21,11 @@
 
 /*!\file PHY/CODING/nrPolar_tools/nr_polar_defs.h
  * \brief
- * \author Turker Yilmaz
+ * \author Raymond Knopp, Turker Yilmaz
  * \date 2018
  * \version 0.1
  * \company EURECOM
- * \email turker.yilmaz@eurecom.fr
+ * \email raymond.knopp@eurecom.fr, turker.yilmaz@eurecom.fr
  * \note
  * \warning
 */
@@ -46,7 +46,6 @@
 //#include "SIMULATION/TOOLS/sim.h"
 
 #define NR_POLAR_DECODER_LISTSIZE 8 //uint8_t
-#define NR_POLAR_DECODER_PATH_METRIC_APPROXIMATION 0 //uint8_t; 0 --> eq. (8a) and (11b), 1 --> eq. (9) and (12)
 
 #define NR_POLAR_AGGREGATION_LEVEL_1_PRIME 149 //uint16_t
 #define NR_POLAR_AGGREGATION_LEVEL_2_PRIME 151 //uint16_t
@@ -54,12 +53,13 @@
 #define NR_POLAR_AGGREGATION_LEVEL_8_PRIME 163 //uint16_t
 #define NR_POLAR_AGGREGATION_LEVEL_16_PRIME 167 //uint16_t
 
-static const uint8_t nr_polar_subblock_interleaver_pattern[32] = { 0, 1, 2, 4, 3, 5, 6, 7, 8, 16, 9, 17, 10, 18, 11, 19, 12, 20, 13, 21, 14, 22, 15, 23, 24, 25, 26, 28, 27, 29, 30, 31 };
-
+static const uint8_t nr_polar_subblock_interleaver_pattern[32] = {0,1,2,4,3,5,6,7,8,16,9,17,10,18,11,19,12,20,13,21,14,22,15,23,24,25,26,28,27,29,30,31};
 
 #define Nmax 1024
 #define nmax 10
 
+#define uint128_t __uint128_t
+
 typedef struct decoder_node_t_s {
   struct decoder_node_t_s *left;
   struct decoder_node_t_s *right;
@@ -106,18 +106,17 @@ struct nrPolar_params {
   int16_t *Q_PC_N;
   uint8_t *information_bit_pattern;
   uint16_t *channel_interleaver_pattern;
-  uint32_t crc_polynomial;
+  //uint32_t crc_polynomial;
 
   uint8_t **crc_generator_matrix; //G_P
   uint8_t **G_N;
   uint64_t **G_N_tab;
   int groupsize;
-  int     *rm_tab;
+  int *rm_tab;
   uint64_t cprime_tab0[32][256];
   uint64_t cprime_tab1[32][256];
   uint64_t B_tab0[32][256];
   uint64_t B_tab1[32][256];
-  uint32_t *crc256Table;
   uint8_t **extended_crc_generator_matrix;
   //lowercase: bits, Uppercase: Bits stored in bytes
   //polar_encoder vectors
@@ -152,40 +151,31 @@ void polar_encoder_fast(uint64_t *A,
                         t_nrPolar_params *polarParams);
 
 int8_t polar_decoder(double *input,
-                     uint8_t *output,
+					 uint32_t *output,
                      t_nrPolar_params *polarParams,
-                     uint8_t listSize,
-                     uint8_t pathMetricAppr);
+                     uint8_t listSize);
 
 uint32_t polar_decoder_int16(int16_t *input,
                              uint64_t *out,
                              const t_nrPolar_params *polarParams);
 
-int8_t polar_decoder_aPriori(double *input,
-                             uint32_t *output,
-                             t_nrPolar_params *polarParams,
-                             uint8_t listSize,
-                             uint8_t pathMetricAppr,
-                             double *aPrioriPayload);
-
-int8_t polar_decoder_aPriori_timing(double *input,
-                                    uint32_t *output,
-                                    t_nrPolar_params *polarParams,
-                                    uint8_t listSize,
-                                    uint8_t pathMetricAppr,
-                                    double *aPrioriPayload,
-                                    double cpuFreqGHz,
-                                    FILE *logFile);
-
 int8_t polar_decoder_dci(double *input,
                          uint32_t *out,
                          t_nrPolar_params *polarParams,
                          uint8_t listSize,
-                         uint8_t pathMetricAppr,
                          uint16_t n_RNTI);
 
-void generic_polar_decoder(t_nrPolar_params *,
-                           decoder_node_t *);
+void generic_polar_decoder(const t_nrPolar_params *pp,
+						   decoder_node_t *node);
+
+void applyFtoleft(const t_nrPolar_params *pp,
+				  decoder_node_t *node);
+
+void applyGtoright(const t_nrPolar_params *pp,
+				   decoder_node_t *node);
+
+void computeBeta(const t_nrPolar_params *pp,
+				 decoder_node_t *node);
 
 void build_decoder_tree(t_nrPolar_params *pp);
 void build_polar_tables(t_nrPolar_params *polarParams);
@@ -193,9 +183,9 @@ void init_polar_deinterleaver_table(t_nrPolar_params *polarParams);
 
 void nr_polar_print_polarParams(t_nrPolar_params *polarParams);
 
-t_nrPolar_params *nr_polar_params ( int8_t messageType,
-                                    uint16_t messageLength,
-                                    uint8_t aggregation_level);
+t_nrPolar_params *nr_polar_params (int8_t messageType,
+                                   uint16_t messageLength,
+                                   uint8_t aggregation_level);
 
 uint16_t nr_polar_aggregation_prime (uint8_t aggregation_level);
 
@@ -256,17 +246,19 @@ void nr_polar_info_bit_extraction(uint8_t *input,
                                   uint8_t *pattern,
                                   uint16_t size);
 
-void nr_bit2byte_uint32_8_t(uint32_t *in,
-                            uint16_t arraySize,
-                            uint8_t *out);
+void nr_bit2byte_uint32_8(uint32_t *in,
+                          uint16_t arraySize,
+                          uint8_t *out);
 
-void nr_byte2bit_uint8_32_t(uint8_t *in,
-                            uint16_t arraySize,
-                            uint32_t *out);
+void nr_byte2bit_uint8_32(uint8_t *in,
+                          uint16_t arraySize,
+                          uint32_t *out);
 
-void nr_crc_bit2bit_uint32_8_t(uint32_t *in,
-                               uint16_t arraySize,
-                               uint8_t *out);
+uint8_t **crc24c_generator_matrix(uint16_t payloadSizeBits);
+
+uint8_t **crc11_generator_matrix(uint16_t payloadSizeBits);
+
+uint8_t **crc6_generator_matrix(uint16_t payloadSizeBits);
 
 void nr_polar_bit_insertion(uint8_t *input,
                             uint8_t *output,
@@ -320,7 +312,6 @@ void nr_sort_asc_int16_1D_array_ind(int32_t *matrix,
 
 void nr_free_double_2D_array(double **input, uint16_t xlen);
 
-
 void updateLLR(double ***llr,
                uint8_t **llrU,
                uint8_t ***bit,
@@ -329,8 +320,7 @@ void updateLLR(double ***llr,
                uint16_t row,
                uint16_t col,
                uint16_t xlen,
-               uint8_t ylen,
-               uint8_t approximation);
+               uint8_t ylen);
 
 void updateBit(uint8_t ***bit,
                uint8_t **bitU,
@@ -344,21 +334,18 @@ void updatePathMetric(double *pathMetric,
                       double ***llr,
                       uint8_t listSize,
                       uint8_t bitValue,
-                      uint16_t row,
-                      uint8_t approximation);
+                      uint16_t row);
 
 void updatePathMetric2(double *pathMetric,
                        double ***llr,
                        uint8_t listSize,
-                       uint16_t row,
-                       uint8_t approximation);
+                       uint16_t row);
 
 void computeLLR(double ***llr,
                 uint16_t row,
                 uint16_t col,
                 uint8_t i,
-                uint16_t offset,
-                uint8_t approximation);
+                uint16_t offset);
 
 void updateCrcChecksum(uint8_t **crcChecksum,
                        uint8_t **crcGen,
@@ -372,12 +359,6 @@ void updateCrcChecksum2(uint8_t **crcChecksum,
                         uint32_t i2,
                         uint8_t len);
 
-uint8_t **crc24c_generator_matrix(uint16_t payloadSizeBits);
-
-uint8_t **crc11_generator_matrix(uint16_t payloadSizeBits);
-
-uint8_t **crc6_generator_matrix(uint16_t payloadSizeBits);
-
 //Also nr_polar_rate_matcher
 static inline void nr_polar_interleaver(uint8_t *input,
                                         uint8_t *output,
@@ -387,14 +368,10 @@ static inline void nr_polar_interleaver(uint8_t *input,
 }
 
 static inline void nr_polar_deinterleaver(uint8_t *input,
-    uint8_t *output,
-    uint16_t *pattern,
-    uint16_t size) {
-  for (int i=0; i<size; i++) {
-    output[pattern[i]]=input[i];
-  }
+										  uint8_t *output,
+										  uint16_t *pattern,
+										  uint16_t size) {
+	for (int i=0; i<size; i++) output[pattern[i]]=input[i];
 }
 
-void build_decoder_tree(t_nrPolar_params *pp);
-
 #endif
diff --git a/openair1/PHY/CODING/nrPolar_tools/nr_polar_encoder.c b/openair1/PHY/CODING/nrPolar_tools/nr_polar_encoder.c
index a9bef7ca38..9858f16cb0 100644
--- a/openair1/PHY/CODING/nrPolar_tools/nr_polar_encoder.c
+++ b/openair1/PHY/CODING/nrPolar_tools/nr_polar_encoder.c
@@ -32,10 +32,11 @@
 
 //#define DEBUG_POLAR_ENCODER
 //#define DEBUG_POLAR_ENCODER_DCI
-//#define DEBUG_POLAR_ENCODER_TIMING
+//#define DEBUG_POLAR_MATLAB
 
 #include "PHY/CODING/nrPolar_tools/nr_polar_defs.h"
 #include "assertions.h"
+#include <stdint.h>
 
 //input  [a_31 a_30 ... a_0]
 //output [f_31 f_30 ... f_0] [f_63 f_62 ... f_32] ...
@@ -43,23 +44,23 @@
 void polar_encoder(uint32_t *in,
                    uint32_t *out,
                    t_nrPolar_params *polarParams) {
-  if (polarParams->idx == 0) { //PBCH
+  if (1) {//polarParams->idx == 0 || polarParams->idx == 1) { //PBCH or PDCCH
     /*
     uint64_t B = (((uint64_t)*in)&((((uint64_t)1)<<32)-1)) | (((uint64_t)crc24c((uint8_t*)in,polarParams->payloadBits)>>8)<<polarParams->payloadBits);
     #ifdef DEBUG_POLAR_ENCODER
     printf("polar_B %llx (crc %x)\n",B,crc24c((uint8_t*)in,polarParams->payloadBits)>>8);
     #endif
     nr_bit2byte_uint32_8_t((uint32_t*)&B, polarParams->K, polarParams->nr_polar_B);*/
-    nr_bit2byte_uint32_8_t((uint32_t *)in, polarParams->payloadBits, polarParams->nr_polar_A);
+    nr_bit2byte_uint32_8(in, polarParams->payloadBits, polarParams->nr_polar_A);
     /*
      * Bytewise operations
      */
     //Calculate CRC.
     nr_matrix_multiplication_uint8_1D_uint8_2D(polarParams->nr_polar_A,
-        polarParams->crc_generator_matrix,
-        polarParams->nr_polar_crc,
-        polarParams->payloadBits,
-        polarParams->crcParityBits);
+    										   polarParams->crc_generator_matrix,
+											   polarParams->nr_polar_crc,
+											   polarParams->payloadBits,
+											   polarParams->crcParityBits);
 
     for (uint8_t i = 0; i < polarParams->crcParityBits; i++)
       polarParams->nr_polar_crc[i] = (polarParams->nr_polar_crc[i] % 2);
@@ -77,6 +78,8 @@ void polar_encoder(uint32_t *in,
     for (int i = 0; i<polarParams->K; i++) B2 = B2 | ((uint64_t)polarParams->nr_polar_B[i] << i);
 
     printf("polar_B %llx\n",B2);
+    for (int i=0; i< polarParams->payloadBits; i++) printf("a[%d]=%d\n", i, polarParams->nr_polar_A[i]);
+    for (int i=0; i< polarParams->K; i++) printf("b[%d]=%d\n", i, polarParams->nr_polar_B[i]);
 #endif
     /*    for (int j=0;j<polarParams->crcParityBits;j++) {
       for (int i=0;i<polarParams->payloadBits;i++)
@@ -115,10 +118,10 @@ void polar_encoder(uint32_t *in,
   polarParams->nr_polar_U[247]=1;
   polarParams->nr_polar_U[253]=1;*/
   nr_matrix_multiplication_uint8_1D_uint8_2D(polarParams->nr_polar_U,
-      polarParams->G_N,
-      polarParams->nr_polar_D,
-      polarParams->N,
-      polarParams->N);
+		  	  	  	  	  	  	  	  	     polarParams->G_N,
+											 polarParams->nr_polar_D,
+											 polarParams->N,
+											 polarParams->N);
 
   for (uint16_t i = 0; i < polarParams->N; i++)
     polarParams->nr_polar_D[i] = (polarParams->nr_polar_D[i] % 2);
@@ -146,7 +149,7 @@ void polar_encoder(uint32_t *in,
   for (int i=0; i< polarParams->encoderLength; i++) printf("f[%d]=%d\n", i, polarParams->nr_polar_E[i]);
 
 #endif
-  nr_byte2bit_uint8_32_t(polarParams->nr_polar_E, polarParams->encoderLength, out);
+  nr_byte2bit_uint8_32(polarParams->nr_polar_E, polarParams->encoderLength, out);
 }
 
 void polar_encoder_dci(uint32_t *in,
@@ -160,7 +163,7 @@ void polar_encoder_dci(uint32_t *in,
    * Bytewise operations
    */
   //(a to a')
-  nr_bit2byte_uint32_8_t(in, polarParams->payloadBits, polarParams->nr_polar_A);
+  nr_bit2byte_uint32_8(in, polarParams->payloadBits, polarParams->nr_polar_A);
 
   for (int i=0; i<polarParams->crcParityBits; i++) polarParams->nr_polar_APrime[i]=1;
 
@@ -168,35 +171,29 @@ void polar_encoder_dci(uint32_t *in,
 
 #ifdef DEBUG_POLAR_ENCODER_DCI
   printf("[polar_encoder_dci] A: ");
-
   for (int i=0; i<polarParams->payloadBits; i++) printf("%d-", polarParams->nr_polar_A[i]);
-
   printf("\n");
+
   printf("[polar_encoder_dci] APrime: ");
-
   for (int i=0; i<polarParams->K; i++) printf("%d-", polarParams->nr_polar_APrime[i]);
-
   printf("\n");
+
   printf("[polar_encoder_dci] GP: ");
-
   for (int i=0; i<polarParams->crcParityBits; i++) printf("%d-", polarParams->crc_generator_matrix[0][i]);
-
   printf("\n");
 #endif
   //Calculate CRC.
   nr_matrix_multiplication_uint8_1D_uint8_2D(polarParams->nr_polar_APrime,
-      polarParams->crc_generator_matrix,
-      polarParams->nr_polar_crc,
-      polarParams->K,
-      polarParams->crcParityBits);
+		  	  	  	  	  	  	  	  	  	 polarParams->crc_generator_matrix,
+											 polarParams->nr_polar_crc,
+											 polarParams->K,
+											 polarParams->crcParityBits);
 
   for (uint8_t i = 0; i < polarParams->crcParityBits; i++) polarParams->nr_polar_crc[i] = (polarParams->nr_polar_crc[i] % 2);
 
 #ifdef DEBUG_POLAR_ENCODER_DCI
   printf("[polar_encoder_dci] CRC: ");
-
   for (int i=0; i<polarParams->crcParityBits; i++) printf("%d-", polarParams->nr_polar_crc[i]);
-
   printf("\n");
 #endif
 
@@ -208,55 +205,16 @@ void polar_encoder_dci(uint32_t *in,
     polarParams->nr_polar_B[i]= polarParams->nr_polar_crc[i-(polarParams->payloadBits)];
 
   //Scrambling (b to c)
-  for (int i=0; i<16; i++) {
-    polarParams->nr_polar_B[polarParams->payloadBits+8+i] =
-      ( polarParams->nr_polar_B[polarParams->payloadBits+8+i] + ((n_RNTI>>(15-i))&1) ) % 2;
-  }
+  for (int i=0; i<16; i++)
+	polarParams->nr_polar_B[polarParams->payloadBits+8+i]=( polarParams->nr_polar_B[polarParams->payloadBits+8+i] + ((n_RNTI>>(15-i))&1) ) % 2;
 
-  /*  //(a to a')
-  nr_crc_bit2bit_uint32_8_t(in, polarParams->payloadBits, polarParams->nr_polar_aPrime);
-  //Parity bits computation (p)
-  polarParams->crcBit = crc24c(polarParams->nr_polar_aPrime, (polarParams->payloadBits+polarParams->crcParityBits));
-  #ifdef DEBUG_POLAR_ENCODER_DCI
-  printf("[polar_encoder_dci] crc: 0x%08x\n", polarParams->crcBit);
-  for (int i=0; i<32; i++)
-  {
-  printf("%d\n",((polarParams->crcBit)>>i)&1);
-  }
-  #endif
-  //(a to b)
-  //
-  // Bytewise operations
-  //
-  uint8_t arrayInd = ceil(polarParams->payloadBits / 8.0);
-  for (int i=0; i<arrayInd-1; i++){
-  for (int j=0; j<8; j++) {
-  polarParams->nr_polar_B[j+(i*8)] = ((polarParams->nr_polar_aPrime[3+i]>>(7-j)) & 1);
-  }
-  }
-  for (int i=0; i<((polarParams->payloadBits)%8); i++) {
-  polarParams->nr_polar_B[i+(arrayInd-1)*8] = ((polarParams->nr_polar_aPrime[3+(arrayInd-1)]>>(7-i)) & 1);
-  }
-  for (int i=0; i<8; i++) {
-  polarParams->nr_polar_B[polarParams->payloadBits+i] = ((polarParams->crcBit)>>(31-i))&1;
-  }
-  //Scrambling (b to c)
-  for (int i=0; i<16; i++) {
-  polarParams->nr_polar_B[polarParams->payloadBits+8+i] =
-  ( (((polarParams->crcBit)>>(23-i))&1) + ((n_RNTI>>(15-i))&1) ) % 2;
-  }*/
 #ifdef DEBUG_POLAR_ENCODER_DCI
   printf("[polar_encoder_dci] B: ");
-
   for (int i = 0; i < polarParams->K; i++) printf("%d-", polarParams->nr_polar_B[i]);
-
   printf("\n");
 #endif
   //Interleaving (c to c')
-  nr_polar_interleaver(polarParams->nr_polar_B,
-                       polarParams->nr_polar_CPrime,
-                       polarParams->interleaving_pattern,
-                       polarParams->K);
+  nr_polar_interleaver(polarParams->nr_polar_B, polarParams->nr_polar_CPrime, polarParams->interleaving_pattern, polarParams->K);
   //Bit insertion (c' to u)
   nr_polar_bit_insertion(polarParams->nr_polar_CPrime,
                          polarParams->nr_polar_U,
@@ -267,13 +225,11 @@ void polar_encoder_dci(uint32_t *in,
                          polarParams->n_pc);
   //Encoding (u to d)
   nr_matrix_multiplication_uint8_1D_uint8_2D(polarParams->nr_polar_U,
-      polarParams->G_N,
-      polarParams->nr_polar_D,
-      polarParams->N,
-      polarParams->N);
-
-  for (uint16_t i = 0; i < polarParams->N; i++)
-    polarParams->nr_polar_D[i] = (polarParams->nr_polar_D[i] % 2);
+		  	  	  	  	  	  	  	  	  	 polarParams->G_N,
+											 polarParams->nr_polar_D,
+											 polarParams->N,
+											 polarParams->N);
+  for (uint16_t i = 0; i < polarParams->N; i++) polarParams->nr_polar_D[i] = (polarParams->nr_polar_D[i] % 2);
 
   //Rate matching
   //Sub-block interleaving (d to y) and Bit selection (y to e)
@@ -284,28 +240,54 @@ void polar_encoder_dci(uint32_t *in,
   /*
    * Return bits.
    */
-  nr_byte2bit_uint8_32_t(polarParams->nr_polar_E, polarParams->encoderLength, out);
+  nr_byte2bit_uint8_32(polarParams->nr_polar_E, polarParams->encoderLength, out);
 #ifdef DEBUG_POLAR_ENCODER_DCI
   printf("[polar_encoder_dci] E: ");
-
   for (int i = 0; i < polarParams->encoderLength; i++) printf("%d-", polarParams->nr_polar_E[i]);
 
   uint8_t outputInd = ceil(polarParams->encoderLength / 32.0);
   printf("\n[polar_encoder_dci] out: ");
-
-  for (int i = 0; i < outputInd; i++) {
-    printf("[%d]->0x%08x\t", i, out[i]);
-  }
-
+  for (int i = 0; i < outputInd; i++) printf("[%d]->0x%08x\t", i, out[i]);
 #endif
 }
 
 static inline void polar_rate_matching(t_nrPolar_params *polarParams,void *in,void *out) __attribute__((always_inline));
 
 static inline void polar_rate_matching(t_nrPolar_params *polarParams,void *in,void *out) {
-  if (polarParams->groupsize == 8)
+
+  // handle rate matching with a single 128 bit word using bit shuffling
+  // can be done with SIMD intrisics if needed
+  if (polarParams->groupsize < 8)  {
+    AssertFatal(polarParams->encoderLength<=128,"Need to handle groupsize<8 and N>128\n");
+    uint128_t *out128=(uint128_t*)out;
+    uint128_t *in128=(uint128_t*)in;
+    *out128=0;
+    uint128_t tmp0;
+#ifdef DEBUG_POLAR_ENCODER
+    uint128_t tmp1;
+#endif
+    for (int i=0; i<polarParams->encoderLength; i++) {
+#ifdef DEBUG_POLAR_ENCODER
+      printf("%u<-%u : %llx.%llx =>",i,polarParams->rate_matching_pattern[i],((uint64_t *)out)[1],((uint64_t *)out)[0]);
+#endif
+      tmp0 = (*in128&(((uint128_t)1)<<polarParams->rate_matching_pattern[i]));
+      if (tmp0!=0) {
+	*out128 = *out128 | ((uint128_t)1)<<i;
+#ifdef DEBUG_POLAR_ENCODER
+	tmp1 = ((uint128_t)1)<<i;
+	printf("%llx.%llx<->%llx.%llx => %llx.%llx\n",
+	       ((uint64_t *)&tmp0)[1],((uint64_t *)&tmp0)[0],
+	       ((uint64_t *)&tmp1)[1],((uint64_t *)&tmp1)[0],
+	       ((uint64_t *)out)[1],((uint64_t *)out)[0]);
+#endif
+      }
+    }
+
+  }					     
+  // These are based on LUTs for byte and short word groups
+  else if (polarParams->groupsize == 8)
     for (int i=0; i<polarParams->encoderLength>>3; i++) ((uint8_t *)out)[i] = ((uint8_t *)in)[polarParams->rm_tab[i]];
-  else
+  else // groupsize==16
     for (int i=0; i<polarParams->encoderLength>>4; i++) {
       ((uint16_t *)out)[i] = ((uint16_t *)in)[polarParams->rm_tab[i]];
     }
@@ -342,7 +324,7 @@ void build_polar_tables(t_nrPolar_params *polarParams) {
     }
   }
 
-  AssertFatal(polarParams->N==512,"N = %d, not done yet\n",polarParams->N);
+  AssertFatal(polarParams->N==512 || polarParams->N==256 || polarParams->N==128,"N = %d, not done yet\n",polarParams->N);
   // build G bit vectors for information bit positions and convert the bit as bytes tables in nr_polar_kronecker_power_matrices.c to 64 bit packed vectors.
   // keep only rows of G which correspond to information/crc bits
   polarParams->G_N_tab = (uint64_t **)malloc(polarParams->K * sizeof(int64_t *));
@@ -371,14 +353,18 @@ void build_polar_tables(t_nrPolar_params *polarParams) {
   int iplast=polarParams->rate_matching_pattern[0];
   int ccnt=0;
   int groupcnt=0;
+#ifdef DEBUG_POLAR_ENCODER
   int firstingroup_out=0;
   int firstingroup_in=iplast;
+#endif
   int mingroupsize = 1024;
 
   // compute minimum group size of rate-matching pattern
   for (int outpos=1; outpos<polarParams->encoderLength; outpos++) {
     ip=polarParams->rate_matching_pattern[outpos];
-
+#ifdef DEBUG_POLAR_ENCODER
+    printf("rm: outpos %d, inpos %d\n",outpos,ip);
+#endif
     if ((ip - iplast) == 1) ccnt++;
     else {
       groupcnt++;
@@ -391,18 +377,27 @@ void build_polar_tables(t_nrPolar_params *polarParams) {
       if ((ccnt+1)<mingroupsize) mingroupsize=ccnt+1;
 
       ccnt=0;
+#ifdef DEBUG_POLAR_ENCODER
       firstingroup_out=outpos;
       firstingroup_in=ip;
+#endif
     }
 
     iplast=ip;
   }
-
-  AssertFatal(mingroupsize==8 || mingroupsize==16,"mingroupsize %d, needs to be handled\n",mingroupsize);
+  groupcnt++;
+  if ((ccnt+1)<mingroupsize) mingroupsize=ccnt+1;
+#ifdef DEBUG_POLAR_ENCODER
+  printf("group %d (size %d): (%d:%d) => (%d:%d)\n",groupcnt,ccnt+1,
+             firstingroup_in,firstingroup_in+ccnt,
+             firstingroup_out,firstingroup_out+ccnt);
+#endif
+  AssertFatal(mingroupsize==4 || mingroupsize==8 || mingroupsize==16,"mingroupsize %d, needs to be handled\n",mingroupsize);
   polarParams->groupsize=mingroupsize;
   int shift=3;
 
   if (mingroupsize == 16) shift=4;
+  else if (mingroupsize == 4) shift=2;
 
   polarParams->rm_tab=(int *)malloc(sizeof(int)*polarParams->encoderLength/mingroupsize);
   // rerun again to create groups
@@ -427,10 +422,11 @@ void polar_encoder_fast(uint64_t *A,
   //int bitlen0=bitlen;
   uint64_t tcrc=0;
 
-  // A bitstring should be stored as a_{N-1} a_{N-2} ... a_{N-A} 0 .... 0, where N=64,128,192,..., N is smallest multiple of 64 greater than or equal to A
+  // A bit string should be stored as 0, 0, ..., 0, a'_0, a'_1, ..., a'_A-1,
+  //???a'_{N-1} a'_{N-2} ... a'_{N-A} 0 .... 0, where N=64,128,192,..., N is smallest multiple of 64 greater than or equal to A
 
   // First flip A bitstring byte endian for CRC routines (optimized for DLSCH/ULSCH, not PBCH/PDCCH)
-  // CRC reads in each byte in bit positions 7 downto 0, for PBCH/PDCCH we need to read in a_{A-1} downto a_{0}, A = length of bit string (e.g. 32 for PBCH)
+  // CRC reads in each byte in bit positions 7 down to 0, for PBCH/PDCCH we need to read in a_{A-1} down to a_{0}, A = length of bit string (e.g. 32 for PBCH)
   if (bitlen<=32) {
     uint8_t A32_flip[4];
     uint32_t Aprime= (uint32_t)(((uint32_t)*A)<<(32-bitlen));
@@ -452,6 +448,19 @@ void polar_encoder_fast(uint64_t *A,
     A64_flip[7]=((uint8_t *)&Aprime)[0];
     tcrc = (uint64_t)((crcmask^(crc24c(A64_flip,bitlen)>>8)));
   }
+  else if (bitlen<=128) {
+    uint8_t A128_flip[16];
+    uint128_t Aprime= (uint32_t)(((uint128_t)*A)<<(128-bitlen));
+    A128_flip[0]=((uint8_t*)&Aprime)[15];	  A128_flip[1]=((uint8_t*)&Aprime)[14];
+    A128_flip[2]=((uint8_t*)&Aprime)[13];	  A128_flip[3]=((uint8_t*)&Aprime)[12];
+    A128_flip[4]=((uint8_t*)&Aprime)[11];	  A128_flip[5]=((uint8_t*)&Aprime)[10];
+    A128_flip[6] =((uint8_t*)&Aprime)[9];	  A128_flip[7] =((uint8_t*)&Aprime)[8];
+    A128_flip[8] =((uint8_t*)&Aprime)[7];	  A128_flip[9] =((uint8_t*)&Aprime)[6];
+    A128_flip[10]=((uint8_t*)&Aprime)[5];	  A128_flip[11]=((uint8_t*)&Aprime)[4];
+    A128_flip[12]=((uint8_t*)&Aprime)[3];	  A128_flip[13]=((uint8_t*)&Aprime)[2];
+    A128_flip[14]=((uint8_t*)&Aprime)[1];	  A128_flip[15]=((uint8_t*)&Aprime)[0];
+    tcrc = (uint64_t)((crcmask^(crc24c(A128_flip,bitlen)>>8)));
+  }
 
   int n;
   // this is number of quadwords in the bit string
@@ -459,11 +468,14 @@ void polar_encoder_fast(uint64_t *A,
 
   if ((polarParams->K&63) > 0) quadwlen++;
 
-  // Create the B bitstring as
-  // b_{N'-1} b_{N'-2} ... b_{N'-A} b_{N'-A-1} ... b_{N'-A-Nparity} = a_{N-1} a_{N-2} ... a_{N-A} p_{N_parity-1} ... p_0
+  // Create the B bit string as
+  // 0, 0, ..., 0, a'_0, a'_1, ..., a'_A-1, p_0, p_1, ..., p_{N_parity-1}
+
+  //??? b_{N'-1} b_{N'-2} ... b_{N'-A} b_{N'-A-1} ... b_{N'-A-Nparity} = a_{N-1} a_{N-2} ... a_{N-A} p_{N_parity-1} ... p_0
+
 
   for (n=0; n<quadwlen; n++) if (n==0) B[n] = (A[n] << polarParams->crcParityBits) | tcrc;
-    else      B[n] = (A[n] << polarParams->crcParityBits) | (A[n-1]>>(64-polarParams->crcParityBits));
+                             else      B[n] = (A[n] << polarParams->crcParityBits) | (A[n-1]>>(64-polarParams->crcParityBits));
 
   uint8_t *Bbyte = (uint8_t *)B;
 
@@ -484,6 +496,11 @@ void polar_encoder_fast(uint64_t *A,
     }
   }
 
+#ifdef DEBUG_POLAR_MATLAB
+  // Cprime = pbchCprime
+  for (int i = 0; i < quadwlen; i++) printf("[polar_encoder_fast]C'[%d]= 0x%llx\n", i, (unsigned long long)(Cprime[i]));
+#endif
+
 #ifdef DEBUG_POLAR_ENCODER
 
   if (polarParams->K<65)
@@ -536,45 +553,104 @@ void polar_encoder_fast(uint64_t *A,
   int off=0;
   int len=polarParams->K;
 
-  for (int j=0; j<(1+(polarParams->K>>6)); j++,off+=64,len-=64) {
-    for (int i=0; i<((len>63) ? 64 : len); i++) {
-      Cprime_i = -((Cprime[j]>>i)&1); // this converts bit 0 as, 0 => 0000x00, 1 => 1111x11
-      /*
-      #ifdef DEBUG_POLAR_ENCODER
-      printf("%llx Cprime_%d (%llx) G %llx,%llx,%llx,%llx,%llx,%llx,%llx,%llx\n",
-       Cprime_i,off+i,(Cprime[j]>>i) &1,
-       polarParams->G_N_tab[off+i][0],
-       polarParams->G_N_tab[off+i][1],
-       polarParams->G_N_tab[off+i][2],
-       polarParams->G_N_tab[off+i][3],
-       polarParams->G_N_tab[off+i][4],
-       polarParams->G_N_tab[off+i][5],
-       polarParams->G_N_tab[off+i][6],
-       polarParams->G_N_tab[off+i][7]);
-      #endif
-      */
-      uint64_t *Gi=polarParams->G_N_tab[off+i];
-      D[0] ^= (Cprime_i & Gi[0]);
-      D[1] ^= (Cprime_i & Gi[1]);
-      D[2] ^= (Cprime_i & Gi[2]);
-      D[3] ^= (Cprime_i & Gi[3]);
-      D[4] ^= (Cprime_i & Gi[4]);
-      D[5] ^= (Cprime_i & Gi[5]);
-      D[6] ^= (Cprime_i & Gi[6]);
-      D[7] ^= (Cprime_i & Gi[7]);
+  if (polarParams->N==512) {
+    for (int j=0; j<(1+(polarParams->K>>6)); j++,off+=64,len-=64) {
+      for (int i=0; i<((len>63) ? 64 : len); i++) {
+	Cprime_i = -((Cprime[j]>>i)&1); // this converts bit 0 as, 0 => 0000x00, 1 => 1111x11
+	/*
+	  #ifdef DEBUG_POLAR_ENCODER
+	  printf("%llx Cprime_%d (%llx) G %llx,%llx,%llx,%llx,%llx,%llx,%llx,%llx\n",
+	  Cprime_i,off+i,(Cprime[j]>>i) &1,
+	  polarParams->G_N_tab[off+i][0],
+	  polarParams->G_N_tab[off+i][1],
+	  polarParams->G_N_tab[off+i][2],
+	  polarParams->G_N_tab[off+i][3],
+	  polarParams->G_N_tab[off+i][4],
+	  polarParams->G_N_tab[off+i][5],
+	  polarParams->G_N_tab[off+i][6],
+	  polarParams->G_N_tab[off+i][7]);
+	  #endif
+	*/
+	uint64_t *Gi=polarParams->G_N_tab[off+i];
+	D[0] ^= (Cprime_i & Gi[0]);
+	D[1] ^= (Cprime_i & Gi[1]);
+	D[2] ^= (Cprime_i & Gi[2]);
+	D[3] ^= (Cprime_i & Gi[3]);
+	D[4] ^= (Cprime_i & Gi[4]);
+	D[5] ^= (Cprime_i & Gi[5]);
+	D[6] ^= (Cprime_i & Gi[6]);
+	D[7] ^= (Cprime_i & Gi[7]);
+      
+#ifdef DEBUG_POLAR_ENCODER
+	printf("D %llx,%llx,%llx,%llx,%llx,%llx,%llx,%llx\n",
+	       D[0],
+	       D[1],
+	       D[2],
+	       D[3],
+	       D[4],
+	       D[5],
+	       D[6],
+	       D[7]);
+#endif
+      }
     }
   }
-
+  else if (polarParams->N==256) {
+    for (int j=0; j<(1+(polarParams->K>>6)); j++,off+=64,len-=64) {
+      for (int i=0; i<((len>63) ? 64 : len); i++) {
+	Cprime_i = -((Cprime[j]>>i)&1); // this converts bit 0 as, 0 => 0000x00, 1 => 1111x11
+	/*
+	  #ifdef DEBUG_POLAR_ENCODER
+	  printf("%llx Cprime_%d (%llx) G %llx,%llx,%llx,%llx\n",
+	  Cprime_i,off+i,(Cprime[j]>>i) &1,
+	  polarParams->G_N_tab[off+i][0],
+	  polarParams->G_N_tab[off+i][1],
+	  polarParams->G_N_tab[off+i][2],
+	  polarParams->G_N_tab[off+i][3],
+	  #endif
+	*/
+	uint64_t *Gi=polarParams->G_N_tab[off+i];
+	D[0] ^= (Cprime_i & Gi[0]);
+	D[1] ^= (Cprime_i & Gi[1]);
+	D[2] ^= (Cprime_i & Gi[2]);
+	D[3] ^= (Cprime_i & Gi[3]);
+      
+	
 #ifdef DEBUG_POLAR_ENCODER
-  printf("D %llx,%llx,%llx,%llx,%llx,%llx,%llx,%llx\n",
-         D[0],
-         D[1],
-         D[2],
-         D[3],
-         D[4],
-         D[5],
-         D[6],
-         D[7]);
+	printf("D %llx,%llx,%llx,%llx\n",
+	  D[0],
+	  D[1],
+	  D[2],
+	  D[3]);
 #endif
+      }
+    }
+  }
+  else if (polarParams->N==128) {
+    for (int j=0; j<(1+(polarParams->K>>6)); j++,off+=64,len-=64) {
+      for (int i=0; i<((len>63) ? 64 : len); i++) {
+	Cprime_i = -((Cprime[j]>>i)&1); // this converts bit 0 as, 0 => 0000x00, 1 => 1111x11
+	
+	  #ifdef DEBUG_POLAR_ENCODER
+	  printf("%llx Cprime_%d (%d+%d) (%llx) G %llx,%llx\n",
+	  Cprime_i,off+i,off,i,(Cprime[j]>>i) &1,
+	  polarParams->G_N_tab[off+i][0],
+	  polarParams->G_N_tab[off+i][1]);
+	  #endif
+	
+	uint64_t *Gi=polarParams->G_N_tab[off+i];
+	D[0] ^= (Cprime_i & Gi[0]);
+	D[1] ^= (Cprime_i & Gi[1]);
+     
+      
+#ifdef DEBUG_POLAR_ENCODER
+	printf("D %llx,%llx\n",
+	  D[0],
+	  D[1]);
+#endif
+      }
+    }
+  }
+  memset((void*)out,0,polarParams->encoderLength>>3);
   polar_rate_matching(polarParams,(void *)D,(void *)out);
 }
diff --git a/openair1/PHY/CODING/nrPolar_tools/nr_polar_procedures.c b/openair1/PHY/CODING/nrPolar_tools/nr_polar_procedures.c
index 985266447b..26832fd70c 100644
--- a/openair1/PHY/CODING/nrPolar_tools/nr_polar_procedures.c
+++ b/openair1/PHY/CODING/nrPolar_tools/nr_polar_procedures.c
@@ -28,7 +28,7 @@
  * \email turker.yilmaz@eurecom.fr
  * \note
  * \warning
-*/
+ */
 
 #include "PHY/CODING/nrPolar_tools/nr_polar_defs.h"
 
@@ -43,295 +43,305 @@ void nr_polar_bit_insertion(uint8_t *input,
   uint16_t k=0;
   uint8_t flag;
 
-	if (n_PC>0) {
-		/*
-		 *
-		 */
-	} else {
-		for (int n=0; n<=N-1; n++) {
-			flag=0;
-			for (int m=0; m<=(K+n_PC)-1; m++) {
-				if ( n == Q_I_N[m]) {
-					flag=1;
-					break;
-				}
-			}
-			if (flag) { // n ϵ Q_I_N
-				output[n]=input[k];
-				k++;
-			} else {
-				output[n] = 0;
-			}
-		}
+  if (n_PC>0) {
+    /*
+     *
+     */
+  } else {
+    for (int n=0; n<=N-1; n++) {
+      flag=0;
+      for (int m=0; m<=(K+n_PC)-1; m++) {
+	if ( n == Q_I_N[m]) {
+	  flag=1;
+	  break;
 	}
+      }
+      if (flag) { // n ϵ Q_I_N
+	output[n]=input[k];
+	k++;
+      } else {
+	output[n] = 0;
+      }
+    }
+  }
 
 }
 
 
 uint32_t nr_polar_output_length(uint16_t K,
-								uint16_t E,
-								uint8_t n_max)
+				uint16_t E,
+				uint8_t n_max)
 {
-	uint8_t n_1, n_2, n_min=5, n;
-	double R_min=1.0/8;
+  uint8_t n_1, n_2, n_min=5, n;
+  double R_min=1.0/8;
+  
+  if ( (E <= (9.0/8)*pow(2,ceil(log2(E))-1)) && (K/E < 9.0/16) ) {
+    n_1 = ceil(log2(E))-1;
+  } else {
+    n_1 = ceil(log2(E));
+  }
+  
+  n_2 = ceil(log2(K/R_min));
+  
+  n=n_max;
+  if (n>n_1) n=n_1;
+  if (n>n_2) n=n_2;
+  if (n<n_min) n=n_min;
 
-	if ( (E <= (9.0/8)*pow(2,ceil(log2(E))-1)) && (K/E < 9.0/16) ) {
-		n_1 = ceil(log2(E))-1;
-	} else {
-		n_1 = ceil(log2(E));
-	}
-
-	n_2 = ceil(log2(K/R_min));
-
-	n=n_max;
-	if (n>n_1) n=n_1;
-	if (n>n_2) n=n_2;
-	if (n<n_min) n=n_min;
-
-	return ((uint32_t) pow(2.0,n)); //=polar_code_output_length
+  /*printf("nr_polar_output_length: K %d, E %d, n %d (n_max %d,n_min %d, n_1 %d,n_2 %d)\n",
+	 K,E,n,n_max,n_min,n_1,n_2);
+	 exit(-1);*/
+  return ((uint32_t) pow(2.0,n)); //=polar_code_output_length
 }
 
 
 void nr_polar_channel_interleaver_pattern(uint16_t *cip,
-										  uint8_t I_BIL,
-										  uint16_t E)
+					  uint8_t I_BIL,
+					  uint16_t E)
 {
-	if (I_BIL == 1) {
-		uint16_t T=0, k;
-		while( ((T/2)*(T+1)) < E ) T++;
-
-		int16_t **v = malloc(T * sizeof(*v));
-		for (int i = 0; i <= T-1; i++) v[i] = malloc((T-i) * sizeof(*(v[i])));
-
-		k=0;
-		for (int i = 0; i <= T-1; i++) {
-			for (int j = 0; j <= (T-1)-i; j++) {
-				if (k<E) {
-					v[i][j] = k;
-				} else {
-					v[i][j] = (-1);
-				}
-				k++;
-			}
-		}
-
-		k=0;
-		for (int j = 0; j <= T-1; j++) {
-					for (int i = 0; i <= (T-1)-j; i++) {
-						if ( v[i][j] != (-1) ) {
-							cip[k]=v[i][j];
-							k++;
-						}
-					}
-				}
-
-		for (int i = 0; i <= T-1; i++) free(v[i]);
-		free(v);
-
+  if (I_BIL == 1) {
+    uint16_t T=0, k;
+    while( ((T/2)*(T+1)) < E ) T++;
+    
+    int16_t **v = malloc(T * sizeof(*v));
+    for (int i = 0; i <= T-1; i++) v[i] = malloc((T-i) * sizeof(*(v[i])));
+    
+    k=0;
+    for (int i = 0; i <= T-1; i++) {
+      for (int j = 0; j <= (T-1)-i; j++) {
+	if (k<E) {
+	  v[i][j] = k;
 	} else {
-		for (int i=0; i<=E-1; i++) cip[i]=i;
+	  v[i][j] = (-1);
 	}
-
+	k++;
+      }
+    }
+    
+    k=0;
+    for (int j = 0; j <= T-1; j++) {
+      for (int i = 0; i <= (T-1)-j; i++) {
+	if ( v[i][j] != (-1) ) {
+	  cip[k]=v[i][j];
+	  k++;
+	}
+      }
+    }
+    
+    for (int i = 0; i <= T-1; i++) free(v[i]);
+    free(v);
+    
+  } else {
+    for (int i=0; i<=E-1; i++) cip[i]=i;
+  }
 }
 
 
 void nr_polar_info_bit_pattern(uint8_t *ibp,
-							   int16_t *Q_I_N,
-							   int16_t *Q_F_N,
-							   uint16_t *J,
-							   const uint16_t *Q_0_Nminus1,
-							   uint16_t K,
-							   uint16_t N,
-							   uint16_t E,
-							   uint8_t n_PC)
+			       int16_t *Q_I_N,
+			       int16_t *Q_F_N,
+			       uint16_t *J,
+			       const uint16_t *Q_0_Nminus1,
+			       uint16_t K,
+			       uint16_t N,
+			       uint16_t E,
+			       uint8_t n_PC)
 {
-	int16_t *Q_Ftmp_N = malloc(sizeof(int16_t) * (N + 1)); // Last element shows the final
-	int16_t *Q_Itmp_N = malloc(sizeof(int16_t) * (N + 1)); // array index assigned a value.
+  int16_t *Q_Ftmp_N = malloc(sizeof(int16_t) * (N + 1)); // Last element shows the final
+  int16_t *Q_Itmp_N = malloc(sizeof(int16_t) * (N + 1)); // array index assigned a value.
 
-	for (int i = 0; i <= N; i++) {
-		Q_Ftmp_N[i] = -1; // Empty array.
-		Q_Itmp_N[i] = -1;
+  for (int i = 0; i <= N; i++) {
+    Q_Ftmp_N[i] = -1; // Empty array.
+    Q_Itmp_N[i] = -1;
+  }
+
+  uint8_t flag;
+  uint16_t limit, ind;
+
+  if (E < N) {
+    if ((K / (double) E) <= (7.0 / 16)) { //puncturing
+      for (int n = 0; n <= N - E - 1; n++) {
+	ind = Q_Ftmp_N[N] + 1;
+	Q_Ftmp_N[ind] = J[n];
+	Q_Ftmp_N[N] = Q_Ftmp_N[N] + 1;
+      }
+
+      if ((E / (double) N) >= (3.0 / 4)) {
+	limit = ceil((double) (3 * N - 2 * E) / 4);
+	for (int n = 0; n <= limit - 1; n++) {
+	  ind = Q_Ftmp_N[N] + 1;
+	  Q_Ftmp_N[ind] = n;
+	  Q_Ftmp_N[N] = Q_Ftmp_N[N] + 1;
 	}
-
-	uint8_t flag;
-	uint16_t limit, ind;
-
-	if (E < N) {
-		if ((K / (double) E) <= (7.0 / 16)) { //puncturing
-			for (int n = 0; n <= N - E - 1; n++) {
-				ind = Q_Ftmp_N[N] + 1;
-				Q_Ftmp_N[ind] = J[n];
-				Q_Ftmp_N[N] = Q_Ftmp_N[N] + 1;
-			}
-
-			if ((E / (double) N) >= (3.0 / 4)) {
-				limit = ceil((double) (3 * N - 2 * E) / 4);
-				for (int n = 0; n <= limit - 1; n++) {
-					ind = Q_Ftmp_N[N] + 1;
-					Q_Ftmp_N[ind] = n;
-					Q_Ftmp_N[N] = Q_Ftmp_N[N] + 1;
-				}
-			} else {
-				limit = ceil((double) (9 * N - 4 * E) / 16);
-				for (int n = 0; n <= limit - 1; n++) {
-					ind = Q_Ftmp_N[N] + 1;
-					Q_Ftmp_N[ind] = n;
-					Q_Ftmp_N[N] = Q_Ftmp_N[N] + 1;
-				}
-			}
-		} else { //shortening
-			for (int n = E; n <= N - 1; n++) {
-				ind = Q_Ftmp_N[N] + 1;
-				Q_Ftmp_N[ind] = J[n];
-				Q_Ftmp_N[N] = Q_Ftmp_N[N] + 1;
-			}
-		}
+      } else {
+	limit = ceil((double) (9 * N - 4 * E) / 16);
+	for (int n = 0; n <= limit - 1; n++) {
+	  ind = Q_Ftmp_N[N] + 1;
+	  Q_Ftmp_N[ind] = n;
+	  Q_Ftmp_N[N] = Q_Ftmp_N[N] + 1;
 	}
+      }
+    } else { //shortening
+      for (int n = E; n <= N - 1; n++) {
+	ind = Q_Ftmp_N[N] + 1;
+	Q_Ftmp_N[ind] = J[n];
+	Q_Ftmp_N[N] = Q_Ftmp_N[N] + 1;
+      }
+    }
+  }
 
-	//Q_I,tmp_N = Q_0_N-1 \ Q_F,tmp_N
-	for (int n = 0; n <= N - 1; n++) {
-		flag = 1;
-		for (int m = 0; m <= Q_Ftmp_N[N]; m++) {
-			if (Q_0_Nminus1[n] == Q_Ftmp_N[m]) {
-				flag = 0;
-				break;
-			}
-		}
-		if (flag) {
-			Q_Itmp_N[Q_Itmp_N[N] + 1] = Q_0_Nminus1[n];
-			Q_Itmp_N[N]++;
-		}
-	}
+  //Q_I,tmp_N = Q_0_N-1 \ Q_F,tmp_N
+  for (int n = 0; n <= N - 1; n++) {
+    flag = 1;
+    for (int m = 0; m <= Q_Ftmp_N[N]; m++) {
+      if (Q_0_Nminus1[n] == Q_Ftmp_N[m]) {
+	flag = 0;
+	break;
+      }
+    }
+    if (flag) {
+      Q_Itmp_N[Q_Itmp_N[N] + 1] = Q_0_Nminus1[n];
+      Q_Itmp_N[N]++;
+    }
+  }
 
-	//Q_I_N comprises (K+n_PC) most reliable bit indices in Q_I,tmp_N
-	for (int n = 0; n <= (K + n_PC) - 1; n++) {
-		ind = Q_Itmp_N[N] + n - ((K + n_PC) - 1);
-		Q_I_N[n] = Q_Itmp_N[ind];
-	}
+  //Q_I_N comprises (K+n_PC) most reliable bit indices in Q_I,tmp_N
+  for (int n = 0; n <= (K + n_PC) - 1; n++) {
+    ind = Q_Itmp_N[N] + n - ((K + n_PC) - 1);
+    Q_I_N[n] = Q_Itmp_N[ind];
+  }
 
-	//Q_F_N = Q_0_N-1 \ Q_I_N
-	for (int n = 0; n <= N - 1; n++) {
-		flag = 1;
-		for (int m = 0; m <= (K + n_PC) - 1; m++) {
-			if (Q_0_Nminus1[n] == Q_I_N[m]) {
-				flag = 0;
-				break;
-			}
-		}
-		if (flag) {
-			Q_F_N[Q_F_N[N] + 1] = Q_0_Nminus1[n];
-			Q_F_N[N]++;
-		}
-	}
+  //Q_F_N = Q_0_N-1 \ Q_I_N
+  for (int n = 0; n <= N - 1; n++) {
+    flag = 1;
+    for (int m = 0; m <= (K + n_PC) - 1; m++) {
+      if (Q_0_Nminus1[n] == Q_I_N[m]) {
+	flag = 0;
+	break;
+      }
+    }
+    if (flag) {
+      Q_F_N[Q_F_N[N] + 1] = Q_0_Nminus1[n];
+      Q_F_N[N]++;
+    }
+  }
 
-	//Information Bit Pattern
-	for (int n = 0; n <= N - 1; n++) {
-		ibp[n] = 0;
+  //Information Bit Pattern
+  for (int n = 0; n <= N - 1; n++) {
+    ibp[n] = 0;
 
-		for (int m = 0; m <= (K + n_PC) - 1; m++) {
-			if (n == Q_I_N[m]) {
-				ibp[n] = 1;
-				break;
-			}
-		}
-	}
+    for (int m = 0; m <= (K + n_PC) - 1; m++) {
+      if (n == Q_I_N[m]) {
+	ibp[n] = 1;
+	break;
+      }
+    }
+  }
 
-	free(Q_Ftmp_N);
-	free(Q_Itmp_N);
+  free(Q_Ftmp_N);
+  free(Q_Itmp_N);
 }
 
 
 void nr_polar_info_bit_extraction(uint8_t *input,
-								  uint8_t *output,
-								  uint8_t *pattern,
-								  uint16_t size)
+				  uint8_t *output,
+				  uint8_t *pattern,
+				  uint16_t size)
 {
-	uint16_t j = 0;
-	for (int i = 0; i < size; i++) {
-		if (pattern[i] > 0) {
-			output[j] = input[i];
-			j++;
-		}
-	}
+  uint16_t j = 0;
+  for (int i = 0; i < size; i++) {
+    if (pattern[i] > 0) {
+      output[j] = input[i];
+      j++;
+    }
+  }
 }
 
 
-void nr_polar_rate_matching_pattern(uint16_t *rmp, uint16_t *J, const uint8_t *P_i_, uint16_t K, uint16_t N, uint16_t E){
+void nr_polar_rate_matching_pattern(uint16_t *rmp,
+				    uint16_t *J,
+				    const uint8_t *P_i_,
+				    uint16_t K,
+				    uint16_t N,
+				    uint16_t E)
+{
+  uint8_t i;
+  uint16_t *d, *y, ind;
+  d = (uint16_t *)malloc(sizeof(uint16_t) * N);
+  y = (uint16_t *)malloc(sizeof(uint16_t) * N);
 
-	uint8_t i;
-	uint16_t *d, *y, ind;
-	d = (uint16_t *)malloc(sizeof(uint16_t) * N);
-	y = (uint16_t *)malloc(sizeof(uint16_t) * N);
+  for (int m=0; m<=N-1; m++) d[m]=m;
 
-	for (int m=0; m<=N-1; m++) d[m]=m;
+  for (int m=0; m<=N-1; m++){
+    i=floor((32*m)/N);
+    J[m] = (P_i_[i]*(N/32)) + (m%(N/32));
+    y[m] = d[J[m]];
+  }
 
-	for (int m=0; m<=N-1; m++){
-		i=floor((32*m)/N);
-		J[m] = (P_i_[i]*(N/32)) + (m%(N/32));
-		y[m] = d[J[m]];
-	}
+  if (E>=N) { //repetition
+    for (int k=0; k<=E-1; k++) {
+      ind = (k%N);
+      rmp[k]=y[ind];
+    }
+  } else {
+    if ( (K/(double)E) <= (7.0/16) ) { //puncturing
+      for (int k=0; k<=E-1; k++) {
+	rmp[k]=y[k+N-E];
+      }
+    } else { //shortening
+      for (int k=0; k<=E-1; k++) {
+	rmp[k]=y[k];
+      }
+    }
+  }
 
-	if (E>=N) { //repetition
-		for (int k=0; k<=E-1; k++) {
-			ind = (k%N);
-			rmp[k]=y[ind];
-		}
-	} else {
-		if ( (K/(double)E) <= (7.0/16) ) { //puncturing
-			for (int k=0; k<=E-1; k++) {
-				rmp[k]=y[k+N-E];
-			}
-		} else { //shortening
-			for (int k=0; k<=E-1; k++) {
-				rmp[k]=y[k];
-			}
-		}
-	}
-
-	free(d);
-	free(y);
+  free(d);
+  free(y);
 }
 
 
-void nr_polar_rate_matching(double *input, double *output, uint16_t *rmp, uint16_t K, uint16_t N, uint16_t E){
-
-	if (E>=N) { //repetition
-		for (int i=0; i<=N-1; i++) output[i]=0;
-		for (int i=0; i<=E-1; i++){
-			output[rmp[i]]+=input[i];
-		}
-	} else {
-		if ( (K/(double)E) <= (7.0/16) ) { //puncturing
-			for (int i=0; i<=N-1; i++) output[i]=0;
-		} else { //shortening
-			for (int i=0; i<=N-1; i++) output[i]=INFINITY;
-		}
-
-		for (int i=0; i<=E-1; i++){
-			output[rmp[i]]=input[i];
-		}
-	}
+void nr_polar_rate_matching(double *input,
+			    double *output,
+			    uint16_t *rmp,
+			    uint16_t K,
+			    uint16_t N,
+			    uint16_t E)
+{
+  if (E>=N) { //repetition
+    for (int i=0; i<=N-1; i++) output[i]=0;
+    for (int i=0; i<=E-1; i++){
+      output[rmp[i]]+=input[i];
+    }
+  } else {
+    if ( (K/(double)E) <= (7.0/16) ) { //puncturing
+      for (int i=0; i<=N-1; i++) output[i]=0;
+    } else { //shortening
+      for (int i=0; i<=N-1; i++) output[i]=INFINITY;
+    }
 
+    for (int i=0; i<=E-1; i++){
+      output[rmp[i]]=input[i];
+    }
+  }
 }
 
-void nr_polar_rate_matching_int16(int16_t *input, int16_t *output, uint16_t *rmp, uint16_t K, uint16_t N, uint16_t E){
-
-	if (E>=N) { //repetition
-		for (int i=0; i<=N-1; i++) output[i]=0;
-		for (int i=0; i<=E-1; i++){
-			output[rmp[i]]+=input[i];
-		}
-	} else {
-		if ( (K/(double)E) <= (7.0/16) ) { //puncturing
-			for (int i=0; i<=N-1; i++) output[i]=0;
-		} else { //shortening
-			for (int i=0; i<=N-1; i++) output[i]=32767;//instead of INFINITY, to prevent [-Woverflow]
-		}
-
-		for (int i=0; i<=E-1; i++){
-			output[rmp[i]]=input[i];
-		}
-	}
+void nr_polar_rate_matching_int16(int16_t *input,
+				  int16_t *output,
+				  uint16_t *rmp,
+				  uint16_t K,
+				  uint16_t N,
+				  uint16_t E)
+{
+  if (E>=N) { //repetition
+    memset((void*)output,0,N*sizeof(int16_t));
+    for (int i=0; i<=E-1; i++) output[rmp[i]]+=input[i];
+  } else {
+    if ( (K/(double)E) <= (7.0/16) ) memset((void*)output,0,N*sizeof(int16_t)); //puncturing
+    else { //shortening
+      for (int i=0; i<=N-1; i++) output[i]=32767;//instead of INFINITY, to prevent [-Woverflow]
+    }
 
+    for (int i=0; i<=E-1; i++) output[rmp[i]]=input[i];
+   
+  }
 }
-
diff --git a/openair1/PHY/CODING/nrSmallBlock/decodeSmallBlock.c b/openair1/PHY/CODING/nrSmallBlock/decodeSmallBlock.c
new file mode 100644
index 0000000000..3dd570cc18
--- /dev/null
+++ b/openair1/PHY/CODING/nrSmallBlock/decodeSmallBlock.c
@@ -0,0 +1,156 @@
+/*
+ * 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
+ */
+
+/*!\file PHY/CODING/nrSmallBlock/decodeSmallBlock.c
+ * \brief
+ * \author Turker Yilmaz
+ * \date 2019
+ * \version 0.1
+ * \company EURECOM
+ * \email turker.yilmaz@eurecom.fr
+ * \note
+ * \warning
+*/
+
+#include "PHY/CODING/nrSmallBlock/nr_small_block_defs.h"
+#include "assertions.h"
+#include "PHY/sse_intrin.h"
+
+//#define DEBUG_DECODESMALLBLOCK
+
+//input = [d̂_0] [d̂_1] [d̂_2] ... [d̂_31]
+//output = [? ... ? ĉ_K-1 ... ĉ_2 ĉ_1 ĉ_0]
+
+uint16_t decodeSmallBlock(int8_t *in, uint8_t len){
+	uint16_t out = 0;
+
+	AssertFatal(len >= 3 && len <= 11, "[decodeSmallBlock] Message Length = %d (Small Block Coding is only defined for input lengths 3 to 11)", len);
+
+	if(len<7) {
+		int16_t Rhat[NR_SMALL_BLOCK_CODED_BITS] = {0}, Rhatabs[NR_SMALL_BLOCK_CODED_BITS] = {0};
+		uint16_t maxVal;
+		uint8_t maxInd = 0;
+		uint8_t jmax = (1<<(len-1));
+		for (int j = 0; j < jmax; ++j)
+			for (int k = 0; k < NR_SMALL_BLOCK_CODED_BITS; ++k)
+				Rhat[j] += in[k] * hadamard32InterleavedTransposed[j][k];
+
+#if defined(__AVX2__)
+		for (int i = 0; i < NR_SMALL_BLOCK_CODED_BITS; i += 16) {
+			__m256i a15_a0 = _mm256_loadu_si256((__m256i*)&Rhat[i]);
+			a15_a0 = _mm256_abs_epi16(a15_a0);
+			_mm256_storeu_si256((__m256i*)(&Rhatabs[i]), a15_a0);
+		}
+#else
+		for (int i = 0; i < NR_SMALL_BLOCK_CODED_BITS; i += 8) {
+			__m128i a7_a0 = _mm_loadu_si128((__m128i*)&Rhat[i]);
+			a7_a0 = _mm_abs_epi16(a7_a0);
+			_mm_storeu_si128((__m128i*)(&Rhatabs[i]), a7_a0);
+		}
+#endif
+		maxVal = Rhatabs[0];
+		for (int k = 1; k < jmax; ++k){
+			if (Rhatabs[k] > maxVal){
+				maxVal = Rhatabs[k];
+				maxInd = k;
+			}
+		}
+
+		out = properOrderedBasis[maxInd] | ( (Rhat[maxInd] > 0) ? (uint16_t)0 : (uint16_t)1 );
+
+#ifdef DEBUG_DECODESMALLBLOCK
+		for (int k = 0; k < jmax; ++k)
+			printf("[decodeSmallBlock]Rhat[%d]=%d %d %d %d\n",k, Rhat[k], maxVal, maxInd, ((uint32_t)out>>k)&1);
+		printf("[decodeSmallBlock]0x%x 0x%x\n", out, properOrderedBasis[maxInd]);
+#endif
+
+	} else {
+		uint8_t maxRow = 0, maxCol = 0;
+
+#if defined(__AVX2__)
+        int16_t maxVal = 0;
+		int DmatrixElementVal = 0;
+		int8_t DmatrixElement[NR_SMALL_BLOCK_CODED_BITS] = {0};
+		__m256i _in_256 = _mm256_loadu_si256 ((__m256i*)&in[0]);
+		__m256i _maskD_256, _Dmatrixj_256, _maskH_256, _DmatrixElement_256;
+		for (int j = 0; j < ( 1<<(len-6) ); ++j) {
+			_maskD_256 = _mm256_loadu_si256 ((__m256i*)(&maskD[j][0]));
+			_Dmatrixj_256 = _mm256_sign_epi8 (_in_256, _maskD_256);
+			for (int k = 0; k < NR_SMALL_BLOCK_CODED_BITS; ++k) {
+				_maskH_256 = _mm256_loadu_si256 ((__m256i*)(&hadamard32InterleavedTransposed[k][0]));
+				_DmatrixElement_256 = _mm256_sign_epi8 (_Dmatrixj_256, _maskH_256);
+#if defined(__AVX512F__)
+			    DmatrixElementVal = _mm512_reduce_add_epi32 (
+			    		            _mm512_add_epi32(
+			    				    _mm512_cvtepi8_epi32 (_mm256_extracti128_si256 (_DmatrixElement_256, 1)),
+								    _mm512_cvtepi8_epi32 (_mm256_castsi256_si128 (_DmatrixElement_256))
+			    		            				)
+															);
+#else
+				_mm256_storeu_si256((__m256i*)(&DmatrixElement[0]), _DmatrixElement_256);
+				for (int i = 0; i < NR_SMALL_BLOCK_CODED_BITS; ++i)
+					DmatrixElementVal += DmatrixElement[i];
+#endif
+				if (abs(DmatrixElementVal) > abs(maxVal)){
+					maxVal = DmatrixElementVal;
+					maxRow = j;
+					maxCol = k;
+				}
+				DmatrixElementVal=0;
+			}
+		}
+		out = properOrderedBasisExtended[maxRow] | properOrderedBasis[maxCol] | ( (maxVal > 0) ? (uint16_t)0 : (uint16_t)1 );
+#else
+		int8_t Dmatrix[NR_SMALL_BLOCK_CODED_BITS][NR_SMALL_BLOCK_CODED_BITS] = {0};
+		int16_t DmatrixFHT[NR_SMALL_BLOCK_CODED_BITS][NR_SMALL_BLOCK_CODED_BITS] = {0};
+		uint16_t maxVal;
+		uint8_t rowLimit = 1<<(len-6);
+
+		for (int j = 0; j < ( rowLimit ); ++j)
+			for (int k = 0; k < NR_SMALL_BLOCK_CODED_BITS; ++k)
+				Dmatrix[j][k] = in[k] * maskD[j][k];
+
+		for (int i = 0; i < ( rowLimit ); ++i)
+			for (int j = 0; j < NR_SMALL_BLOCK_CODED_BITS; ++j)
+				for (int k = 0; k < NR_SMALL_BLOCK_CODED_BITS; ++k)
+					DmatrixFHT[i][j] += Dmatrix[i][k] * hadamard32InterleavedTransposed[j][k];
+
+		maxVal = abs(DmatrixFHT[0][0]);
+		for (int i = 0; i < ( rowLimit ); ++i)
+			for (int j = 0; j < NR_SMALL_BLOCK_CODED_BITS; ++j)
+				if (abs(DmatrixFHT[i][j]) > maxVal){
+					maxVal = abs(DmatrixFHT[i][j]);
+					maxRow = i;
+					maxCol = j;
+				}
+
+		out = properOrderedBasisExtended[maxRow] | properOrderedBasis[maxCol] | ( (DmatrixFHT[maxRow][maxCol] > 0) ? (uint16_t)0 : (uint16_t)1 );
+#endif
+
+#ifdef DEBUG_DECODESMALLBLOCK
+		for (int k = 0; k < NR_SMALL_BLOCK_CODED_BITS; ++k)
+					printf("[decodeSmallBlock]maxRow = %d maxCol = %d out[%d]=%d\n", maxRow, maxCol, k, ((uint32_t)out>>k)&1);
+#endif
+
+	}
+
+	return out;
+}
diff --git a/openair1/PHY/CODING/nrSmallBlock/encodeSmallBlock.c b/openair1/PHY/CODING/nrSmallBlock/encodeSmallBlock.c
new file mode 100644
index 0000000000..8358bd270b
--- /dev/null
+++ b/openair1/PHY/CODING/nrSmallBlock/encodeSmallBlock.c
@@ -0,0 +1,44 @@
+/*
+ * 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
+ */
+
+/*!\file PHY/CODING/nrSmallBlock/encodeSmallBlock.c
+ * \brief
+ * \author Turker Yilmaz
+ * \date 2019
+ * \version 0.1
+ * \company EURECOM
+ * \email turker.yilmaz@eurecom.fr
+ * \note
+ * \warning
+*/
+
+#include "PHY/CODING/nrSmallBlock/nr_small_block_defs.h"
+
+//input = [0 ... 0 c_K-1 ... c_2 c_1 c_0]
+//output = [d_31 d_30 ... d_2 d_1 d_0]
+uint32_t encodeSmallBlock(uint16_t *in, uint8_t len){
+	uint32_t out = 0;
+	  for (uint16_t i=0; i<len; i++)
+	    if ((*in & (1<<i)) > 0)
+	    	out^=nrSmallBlockBasis[i];
+
+	  return out;
+}
diff --git a/openair1/PHY/CODING/nrSmallBlock/nr_small_block_defs.h b/openair1/PHY/CODING/nrSmallBlock/nr_small_block_defs.h
new file mode 100644
index 0000000000..50559aa0d2
--- /dev/null
+++ b/openair1/PHY/CODING/nrSmallBlock/nr_small_block_defs.h
@@ -0,0 +1,134 @@
+/*
+ * 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
+ */
+
+/*!\file PHY/CODING/nrSmallBlock/nr_small_block_defs.h
+ * \brief
+ * \author Turker Yilmaz
+ * \date 2019
+ * \version 0.1
+ * \company EURECOM
+ * \email turker.yilmaz@eurecom.fr
+ * \note
+ * \warning
+*/
+
+#ifndef __NR_SMALL_BLOCK_DEFS__H__
+#define __NR_SMALL_BLOCK_DEFS__H__
+
+#include <math.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define NR_SMALL_BLOCK_CODED_BITS 32
+
+#define L1d_CLS 64
+
+uint32_t encodeSmallBlock(uint16_t *in, uint8_t len);
+
+uint16_t decodeSmallBlock(int8_t *in, uint8_t len);
+
+static const uint32_t nrSmallBlockBasis[11] = {0xFFFFFFFF, 0x4BA5A933, 0x7D910E5A, 0x6D26339C, 0x71C7C3E0,
+		0x7E0FFC00, 0x731D8E64, 0x6B44F5B0, 0x7DC218EC, 0x4DA1B746, 0x42F0FFFF};
+
+static const uint16_t properOrderedBasis[32] = {0x0000, 0x0002, 0x0004, 0x0006, 0x0008, 0x000A, 0x000C, 0x000E, 0x0010, 0x0012,
+		0x0014, 0x0016, 0x0018, 0x001A, 0x001C, 0x001E, 0x0020, 0x0022, 0x0024, 0x0026,
+		0x0028, 0x002A, 0x002C, 0x002E, 0x0030, 0x0032, 0x0034, 0x0036, 0x0038, 0x003A, 0x003C, 0x003E};
+
+static const uint16_t properOrderedBasisExtended[32] = {0x0000, 0x0040, 0x0080, 0x00C0, 0x0100, 0x0140, 0x0180, 0x01C0, 0x0200, 0x0240,
+		0x0280, 0x02C0, 0x0300, 0x0340, 0x0380, 0x03C0, 0x0400, 0x0440, 0x0480, 0x04C0,
+		0x0500, 0x0540, 0x0580, 0x05C0, 0x0600, 0x0640, 0x0680, 0x06C0, 0x0700, 0x0740, 0x0780, 0x07C0};
+
+static const int8_t hadamard32InterleavedTransposed[32][32] __attribute__ ((aligned(32))) = {
+		{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
+		{-1,-1,1,1,-1,-1,1,1,-1,1,1,-1,1,-1,1,-1,-1,1,-1,1,1,-1,1,-1,-1,-1,1,-1,1,1,-1,1},
+		{1,-1,1,-1,-1,1,-1,1,1,-1,-1,-1,1,1,1,1,-1,1,1,1,-1,1,1,-1,-1,1,-1,-1,-1,-1,-1,1},
+		{-1,1,1,-1,1,-1,-1,1,-1,-1,-1,1,1,-1,1,-1,1,1,-1,1,-1,-1,1,1,1,-1,-1,1,-1,-1,1,1},
+		{1,1,-1,-1,-1,1,1,-1,-1,-1,1,1,-1,-1,1,1,1,-1,-1,1,1,-1,1,1,-1,1,-1,-1,1,-1,-1,1},
+		{-1,-1,-1,-1,1,-1,1,-1,1,-1,1,-1,-1,1,1,-1,-1,-1,1,1,1,1,1,-1,1,-1,-1,1,1,-1,1,1},
+		{1,-1,-1,1,1,1,-1,-1,-1,1,-1,-1,-1,-1,1,1,-1,-1,-1,1,-1,-1,1,-1,1,1,1,1,-1,1,1,1},
+		{-1,1,-1,1,-1,-1,-1,-1,1,1,-1,1,-1,1,1,-1,1,-1,1,1,-1,1,1,1,-1,-1,1,-1,-1,1,-1,1},
+		{1,1,1,1,1,-1,-1,-1,-1,-1,1,1,1,1,-1,-1,-1,-1,-1,1,1,1,-1,-1,-1,1,1,1,-1,-1,-1,1},
+		{-1,-1,1,1,-1,1,-1,-1,1,-1,1,-1,1,-1,-1,1,1,-1,1,1,1,-1,-1,1,1,-1,1,-1,-1,-1,1,1},
+		{1,-1,1,-1,-1,-1,1,-1,-1,1,-1,-1,1,1,-1,-1,1,-1,-1,1,-1,1,-1,1,1,1,-1,-1,1,1,1,1},
+		{-1,1,1,-1,1,1,1,-1,1,1,-1,1,1,-1,-1,1,-1,-1,1,1,-1,-1,-1,-1,-1,-1,-1,1,1,1,-1,1},
+		{1,1,-1,-1,-1,-1,-1,1,1,1,1,1,-1,-1,-1,-1,-1,1,1,1,1,-1,-1,-1,1,1,-1,-1,-1,1,1,1},
+		{-1,-1,-1,-1,1,1,-1,1,-1,1,1,-1,-1,1,-1,1,1,1,-1,1,1,1,-1,1,-1,-1,-1,1,-1,1,-1,1},
+		{1,-1,-1,1,1,-1,1,1,1,-1,-1,-1,-1,-1,-1,-1,1,1,1,1,-1,-1,-1,1,-1,1,1,1,1,-1,-1,1},
+		{-1,1,-1,1,-1,1,1,1,-1,-1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,-1,1,-1,1,-1,1,-1,1,1},
+		{1,1,1,1,1,1,1,1,1,1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,1,1,1,1,1,-1,-1,-1,-1,-1,-1,1},
+		{-1,-1,1,1,-1,-1,1,1,-1,1,-1,1,-1,1,-1,1,1,-1,1,-1,1,-1,1,-1,-1,1,-1,1,-1,-1,1,1},
+		{1,-1,1,-1,-1,1,-1,1,1,-1,1,1,-1,-1,-1,-1,1,-1,-1,-1,-1,1,1,-1,-1,-1,1,1,1,1,1,1},
+		{-1,1,1,-1,1,-1,-1,1,-1,-1,1,-1,-1,1,-1,1,-1,-1,1,-1,-1,-1,1,1,1,1,1,-1,1,1,-1,1},
+		{1,1,-1,-1,-1,1,1,-1,-1,-1,-1,-1,1,1,-1,-1,-1,1,1,-1,1,-1,1,1,-1,-1,1,1,-1,1,1,1},
+		{-1,-1,-1,-1,1,-1,1,-1,1,-1,-1,1,1,-1,-1,1,1,1,-1,-1,1,1,1,-1,1,1,1,-1,-1,1,-1,1},
+		{1,-1,-1,1,1,1,-1,-1,-1,1,1,1,1,1,-1,-1,1,1,1,-1,-1,-1,1,-1,1,-1,-1,-1,1,-1,-1,1},
+		{-1,1,-1,1,-1,-1,-1,-1,1,1,1,-1,1,-1,-1,1,-1,1,-1,-1,-1,1,1,1,-1,1,-1,1,1,-1,1,1},
+		{1,1,1,1,1,-1,-1,-1,-1,-1,-1,-1,-1,-1,1,1,1,1,1,-1,1,1,-1,-1,-1,-1,-1,-1,1,1,1,1},
+		{-1,-1,1,1,-1,1,-1,-1,1,-1,-1,1,-1,1,1,-1,-1,1,-1,-1,1,-1,-1,1,1,1,-1,1,1,1,-1,1},
+		{1,-1,1,-1,-1,-1,1,-1,-1,1,1,1,-1,-1,1,1,-1,1,1,-1,-1,1,-1,1,1,-1,1,1,-1,-1,-1,1},
+		{-1,1,1,-1,1,1,1,-1,1,1,1,-1,-1,1,1,-1,1,1,-1,-1,-1,-1,-1,-1,-1,1,1,-1,-1,-1,1,1},
+		{1,1,-1,-1,-1,-1,-1,1,1,1,-1,-1,1,1,1,1,1,-1,-1,-1,1,-1,-1,-1,1,-1,1,1,1,-1,-1,1},
+		{-1,-1,-1,-1,1,1,-1,1,-1,1,-1,1,1,-1,1,-1,-1,-1,1,-1,1,1,-1,1,-1,1,1,-1,1,-1,1,1},
+		{1,-1,-1,1,1,-1,1,1,1,-1,1,1,1,1,1,1,-1,-1,-1,-1,-1,-1,-1,1,-1,-1,-1,-1,-1,1,1,1},
+		{-1,1,-1,1,-1,1,1,1,-1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,-1,1,-1,-1,1,1,-1,1,-1,1,-1,1}
+};
+
+static const int8_t maskD[32][32] __attribute__ ((aligned(32))) = {
+		{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
+		{1,1,-1,1,1,-1,-1,1,1,-1,-1,-1,1,1,1,-1,-1,1,-1,-1,-1,1,1,1,-1,-1,1,1,-1,-1,-1,1},
+		{1,1,1,1,-1,-1,1,-1,-1,1,-1,1,-1,-1,-1,-1,1,1,-1,1,1,1,-1,1,-1,-1,1,-1,1,-1,-1,1},
+		{1,1,-1,1,-1,1,-1,-1,-1,-1,1,-1,-1,-1,-1,1,-1,1,1,-1,-1,1,-1,1,1,1,1,-1,-1,1,1,1},
+		{1,1,-1,-1,1,-1,-1,-1,1,1,1,-1,-1,1,1,1,1,-1,1,1,1,1,-1,-1,-1,1,-1,-1,-1,-1,-1,1},
+		{1,1,1,-1,1,1,1,-1,1,-1,-1,1,-1,1,1,-1,-1,-1,-1,-1,-1,1,-1,-1,1,-1,-1,-1,1,1,1,1},
+		{1,1,-1,-1,-1,1,-1,1,-1,1,-1,-1,1,-1,-1,-1,1,-1,-1,1,1,1,1,-1,1,-1,-1,1,-1,1,1,1},
+		{1,1,1,-1,-1,-1,1,1,-1,-1,1,1,1,-1,-1,1,-1,-1,1,-1,-1,1,1,-1,-1,1,-1,1,1,-1,-1,1},
+		{1,-1,-1,1,1,1,-1,1,-1,-1,-1,1,-1,-1,1,-1,-1,1,1,1,1,-1,1,-1,-1,1,-1,-1,1,1,-1,1},
+		{1,-1,1,1,1,-1,1,1,-1,1,1,-1,-1,-1,1,1,1,1,-1,-1,-1,-1,1,-1,1,-1,-1,-1,-1,-1,1,1},
+		{1,-1,-1,1,-1,-1,-1,-1,1,-1,1,1,1,1,-1,1,-1,1,-1,1,1,-1,-1,-1,1,-1,-1,1,1,-1,1,1},
+		{1,-1,1,1,-1,1,1,-1,1,1,-1,-1,1,1,-1,-1,1,1,1,-1,-1,-1,-1,-1,-1,1,-1,1,-1,1,-1,1},
+		{1,-1,1,-1,1,-1,1,-1,-1,-1,-1,-1,1,-1,1,-1,-1,-1,1,1,1,-1,-1,1,1,1,1,1,-1,-1,1,1},
+		{1,-1,-1,-1,1,1,-1,-1,-1,1,1,1,1,-1,1,1,1,-1,-1,-1,-1,-1,-1,1,-1,-1,1,1,1,1,-1,1},
+		{1,-1,1,-1,-1,1,1,1,1,-1,1,-1,-1,1,-1,1,-1,-1,-1,1,1,-1,1,1,-1,-1,1,-1,-1,1,-1,1},
+		{1,-1,-1,-1,-1,-1,-1,1,1,1,-1,1,-1,1,-1,-1,1,-1,1,-1,-1,-1,1,1,1,1,1,-1,1,-1,1,1},
+		{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,1,1,1,1,-1,-1,-1,-1,1,-1,1,1,1,1,-1,1},
+		{-1,-1,1,-1,-1,1,1,-1,-1,1,1,1,-1,-1,-1,1,-1,1,-1,-1,1,-1,-1,-1,-1,1,1,1,-1,-1,1,1},
+		{-1,-1,-1,-1,1,1,-1,1,1,-1,1,-1,1,1,1,1,1,1,-1,1,-1,-1,1,-1,-1,1,1,-1,1,-1,1,1},
+		{-1,-1,1,-1,1,-1,1,1,1,1,-1,1,1,1,1,-1,-1,1,1,-1,1,-1,1,-1,1,-1,1,-1,-1,1,-1,1},
+		{-1,-1,1,1,-1,1,1,1,-1,-1,-1,1,1,-1,-1,-1,1,-1,1,1,-1,-1,1,1,-1,-1,-1,-1,-1,-1,1,1},
+		{-1,-1,-1,1,-1,-1,-1,1,-1,1,1,-1,1,-1,-1,1,-1,-1,-1,-1,1,-1,1,1,1,1,-1,-1,1,1,-1,1},
+		{-1,-1,1,1,1,-1,1,-1,1,-1,1,1,-1,1,1,1,1,-1,-1,1,-1,-1,-1,1,1,1,-1,1,-1,1,-1,1},
+		{-1,-1,-1,1,1,1,-1,-1,1,1,-1,-1,-1,1,1,-1,-1,-1,1,-1,1,-1,-1,1,-1,-1,-1,1,1,-1,1,1},
+		{-1,1,1,-1,-1,-1,1,-1,1,1,1,-1,1,1,-1,1,-1,1,1,1,-1,1,-1,1,-1,-1,-1,-1,1,1,1,1},
+		{-1,1,-1,-1,-1,1,-1,-1,1,-1,-1,1,1,1,-1,-1,1,1,-1,-1,1,1,-1,1,1,1,-1,-1,-1,-1,-1,1},
+		{-1,1,1,-1,1,1,1,1,-1,1,-1,-1,-1,-1,1,-1,-1,1,-1,1,-1,1,1,1,1,1,-1,1,1,-1,-1,1},
+		{-1,1,-1,-1,1,-1,-1,1,-1,-1,1,1,-1,-1,1,1,1,1,1,-1,1,1,1,1,-1,-1,-1,1,-1,1,1,1},
+		{-1,1,-1,1,-1,1,-1,1,1,1,1,1,-1,1,-1,1,-1,-1,1,1,-1,1,1,-1,1,-1,1,1,-1,-1,-1,1},
+		{-1,1,1,1,-1,-1,1,1,1,-1,-1,-1,-1,1,-1,-1,1,-1,-1,-1,1,1,1,-1,-1,1,1,1,1,1,1,1},
+		{-1,1,-1,1,1,-1,-1,-1,-1,1,-1,1,1,-1,1,-1,-1,-1,-1,1,-1,1,-1,-1,-1,1,1,-1,-1,1,1,1,},
+		{-1,1,1,1,1,1,1,-1,-1,-1,1,-1,1,-1,1,1,1,-1,1,-1,1,1,-1,-1,1,-1,1,-1,1,-1,-1,1}
+};
+
+
+
+#endif
+
diff --git a/openair1/PHY/CODING/nr_polar_init.c b/openair1/PHY/CODING/nr_polar_init.c
index dd0056b3b5..efc78d91fd 100644
--- a/openair1/PHY/CODING/nr_polar_init.c
+++ b/openair1/PHY/CODING/nr_polar_init.c
@@ -21,19 +21,16 @@
 
 /*!\file PHY/CODING/nr_polar_init.h
  * \brief
- * \author Turker Yilmaz
+ * \author Turker Yilmaz, Raymond Knopp
  * \date 2018
  * \version 0.1
  * \company EURECOM
- * \email turker.yilmaz@eurecom.fr
+ * \email turker.yilmaz@eurecom.fr, raymond.knopp@eurecom.fr
  * \note
  * \warning
 */
 
-#include "nrPolar_tools/nr_polar_defs.h"
-#include "PHY/CODING/nrPolar_tools/nr_polar_dci_defs.h"
-#include "PHY/CODING/nrPolar_tools/nr_polar_uci_defs.h"
-#include "PHY/CODING/nrPolar_tools/nr_polar_pbch_defs.h"
+#include "PHY/CODING/nrPolar_tools/nr_polar_defs.h"
 #include "PHY/NR_TRANSPORT/nr_dci.h"
 
 static int intcmp(const void *p1,const void *p2) {
@@ -56,7 +53,7 @@ static void nr_polar_init(t_nrPolar_params * *polarParams,
 
   //  printf("currentPtr %p (polarParams %p)\n",currentPtr,polarParams);
   //Else, initialize and add node to the end of the linked list.
-  t_nrPolar_params *newPolarInitNode = malloc(sizeof(t_nrPolar_params));
+  t_nrPolar_params *newPolarInitNode = calloc(sizeof(t_nrPolar_params),1);
 
   if (newPolarInitNode != NULL) {
     newPolarInitNode->idx = (messageType * messageLength * aggregation_prime);
@@ -95,7 +92,9 @@ static void nr_polar_init(t_nrPolar_params * *polarParams,
     }
 
     newPolarInitNode->K = newPolarInitNode->payloadBits + newPolarInitNode->crcParityBits; // Number of bits to encode.
-    newPolarInitNode->N = nr_polar_output_length(newPolarInitNode->K, newPolarInitNode->encoderLength, newPolarInitNode->n_max);
+    newPolarInitNode->N = nr_polar_output_length(newPolarInitNode->K,
+    											 newPolarInitNode->encoderLength,
+												 newPolarInitNode->n_max);
     newPolarInitNode->n = log2(newPolarInitNode->N);
     newPolarInitNode->G_N = nr_polar_kronecker_power_matrices(newPolarInitNode->n);
     //polar_encoder vectors:
@@ -182,9 +181,9 @@ void nr_polar_print_polarParams(t_nrPolar_params *polarParams) {
   return;
 }
 
-t_nrPolar_params *nr_polar_params ( int8_t messageType,
-                                    uint16_t messageLength,
-                                    uint8_t aggregation_level) {
+t_nrPolar_params *nr_polar_params (int8_t messageType,
+                                   uint16_t messageLength,
+                                   uint8_t aggregation_level) {
   static t_nrPolar_params *polarList = NULL;
   nr_polar_init(&polarList, messageType,messageLength,aggregation_level);
   t_nrPolar_params *polarParams=polarList;
diff --git a/openair1/PHY/CODING/nr_rate_matching.c b/openair1/PHY/CODING/nr_rate_matching.c
index 4172ad0306..0954939a58 100644
--- a/openair1/PHY/CODING/nr_rate_matching.c
+++ b/openair1/PHY/CODING/nr_rate_matching.c
@@ -26,6 +26,7 @@
 
 #include "PHY/defs_gNB.h"
 #include "PHY/defs_nr_UE.h"
+#include "PHY/CODING/coding_defs.h"
 
 //#define RM_DEBUG 1
 
diff --git a/openair1/PHY/CODING/nr_segmentation.c b/openair1/PHY/CODING/nr_segmentation.c
index 8d0cc9e7d3..421f440ec2 100644
--- a/openair1/PHY/CODING/nr_segmentation.c
+++ b/openair1/PHY/CODING/nr_segmentation.c
@@ -34,7 +34,7 @@ int32_t nr_segmentation(unsigned char *input_buffer,
                      unsigned int B,
                      unsigned int *C,
                      unsigned int *K,
-					 unsigned int *Zout,
+                     unsigned int *Zout, // [hna] Zout is Zc
                      unsigned int *F)
 {
 
diff --git a/openair1/PHY/INIT/lte_init_ue.c b/openair1/PHY/INIT/lte_init_ue.c
index bcdd782073..9c9d67bdc2 100644
--- a/openair1/PHY/INIT/lte_init_ue.c
+++ b/openair1/PHY/INIT/lte_init_ue.c
@@ -355,7 +355,9 @@ void phy_config_dedicated_scell_ue(uint8_t Mod_id,
 #endif
 
 
-void phy_config_harq_ue(module_id_t Mod_id,int CC_id,uint8_t eNB_id,
+void phy_config_harq_ue(module_id_t Mod_id,
+						int CC_id,
+						uint8_t eNB_id,
                         uint16_t max_harq_tx )
 {
 
diff --git a/openair1/PHY/INIT/nr_init.c b/openair1/PHY/INIT/nr_init.c
index 46e3010972..397f206336 100644
--- a/openair1/PHY/INIT/nr_init.c
+++ b/openair1/PHY/INIT/nr_init.c
@@ -33,12 +33,14 @@
 #include "assertions.h"
 #include <math.h>
 
+#include "PHY/NR_TRANSPORT/nr_ulsch.h"
 #include "PHY/NR_REFSIG/nr_refsig.h"
 #include "PHY/LTE_REFSIG/lte_refsig.h"
 #include "SCHED_NR/fapi_nr_l1.h"
 
 extern uint32_t from_nrarfcn(int nr_bandP,uint32_t dl_nrarfcn);
 extern int32_t get_uldl_offset(int nr_bandP);
+extern openair0_config_t openair0_cfg[MAX_CARDS];
 
 int l1_north_init_gNB() {
   int i,j;
@@ -77,12 +79,14 @@ int phy_init_nr_gNB(PHY_VARS_gNB *gNB,
                     unsigned char abstraction_flag) {
   // shortcuts
   NR_DL_FRAME_PARMS *const fp       = &gNB->frame_parms;
-  nfapi_nr_config_request_t *cfg       = &gNB->gNB_config;
+  nfapi_nr_config_request_t *cfg    = &gNB->gNB_config;
   NR_gNB_COMMON *const common_vars  = &gNB->common_vars;
-  LTE_eNB_PUSCH **const pusch_vars   = gNB->pusch_vars;
-  LTE_eNB_SRS *const srs_vars        = gNB->srs_vars;
-  LTE_eNB_PRACH *const prach_vars    = &gNB->prach_vars;
+  LTE_eNB_PUSCH **const pusch_vars  = gNB->pusch_vars;
+  LTE_eNB_SRS *const srs_vars       = gNB->srs_vars;
+  LTE_eNB_PRACH *const prach_vars   = &gNB->prach_vars;
+
   int i, UE_id;
+
   LOG_I(PHY,"[gNB %d] %s() About to wait for gNB to be configured\n", gNB->Mod_id, __FUNCTION__);
   gNB->total_dlsch_bitrate = 0;
   gNB->total_transmitted_bits = 0;
@@ -110,7 +114,6 @@ int phy_init_nr_gNB(PHY_VARS_gNB *gNB,
   init_dfts();
   // PBCH DMRS gold sequences generation
   nr_init_pbch_dmrs(gNB);
-  // Polar encoder init for PBCH
   //PDCCH DMRS init
   gNB->nr_gold_pdcch_dmrs = (uint32_t ***)malloc16(fp->slots_per_frame*sizeof(uint32_t **));
   uint32_t ***pdcch_dmrs             = gNB->nr_gold_pdcch_dmrs;
@@ -148,6 +151,7 @@ int phy_init_nr_gNB(PHY_VARS_gNB *gNB,
   }
 
   nr_init_pdsch_dmrs(gNB, cfg->sch_config.physical_cell_id.value);
+
   /// Transport init necessary for NR synchro
   init_nr_transport(gNB);
 
@@ -167,14 +171,15 @@ int phy_init_nr_gNB(PHY_VARS_gNB *gNB,
   gNB->first_run_I0_measurements =
     1; ///This flag used to be static. With multiple gNBs this does no longer work, hence we put it in the structure. However it has to be initialized with 1, which is performed here.
   common_vars->rxdata  = (int32_t **)NULL;
-  common_vars->txdataF = (int32_t **)malloc16(15*sizeof(int32_t *));
-  common_vars->rxdataF = (int32_t **)malloc16(64*sizeof(int32_t *));
+  common_vars->txdataF = (int32_t **)malloc16(15*sizeof(int32_t*));
+  common_vars->rxdataF = (int32_t **)malloc16(64*sizeof(int32_t*));
 
-  for (i=0; i<15; i++) {
-    common_vars->txdataF[i] = (int32_t *)malloc16_clear(fp->samples_per_frame_wCP*sizeof(int32_t) );
-    LOG_D(PHY,"[INIT] common_vars->txdataF[%d] = %p (%lu bytes)\n",
-          i,common_vars->txdataF[i],
-          fp->samples_per_frame_wCP*sizeof(int32_t));
+  for (i=0;i<15;i++){
+      common_vars->txdataF[i] = (int32_t*)malloc16_clear(fp->samples_per_frame_wCP*sizeof(int32_t) ); // [hna] samples_per_frame without CP
+
+      LOG_D(PHY,"[INIT] common_vars->txdataF[%d] = %p (%lu bytes)\n",
+            i,common_vars->txdataF[i],
+            fp->samples_per_frame_wCP*sizeof(int32_t));
   }
 
   // Channel estimates for SRS
@@ -357,7 +362,9 @@ void install_schedule_handlers(IF_Module_t *if_inst)
 
 /// this function is a temporary addition for NR configuration
 
-void nr_phy_config_request_sim(PHY_VARS_gNB *gNB,int N_RB_DL,int N_RB_UL,int mu,int Nid_cell) {
+
+void nr_phy_config_request_sim(PHY_VARS_gNB *gNB,int N_RB_DL,int N_RB_UL,int mu,int Nid_cell,uint64_t position_in_burst) {
+
   NR_DL_FRAME_PARMS *fp = &gNB->frame_parms;
   nfapi_nr_config_request_t *gNB_config = &gNB->gNB_config;
   //overwrite for new NR parameters
@@ -372,15 +379,17 @@ void nr_phy_config_request_sim(PHY_VARS_gNB *gNB,int N_RB_DL,int N_RB_UL,int mu,
   gNB_config->sch_config.n_ssb_crb.value = (N_RB_DL-20);
   gNB_config->sch_config.ssb_subcarrier_offset.value = 0;
   gNB_config->sch_config.physical_cell_id.value=Nid_cell;
+  gNB_config->sch_config.ssb_scg_position_in_burst.value=position_in_burst;
   gNB_config->subframe_config.dl_cyclic_prefix_type.value = (fp->Ncp == NORMAL) ? NFAPI_CP_NORMAL : NFAPI_CP_EXTENDED;
 
   gNB->mac_enabled     = 1;
-  fp->dl_CarrierFreq = from_nrarfcn(gNB_config->nfapi_config.rf_bands.rf_band[0],gNB_config->nfapi_config.nrarfcn.value);
-  fp->ul_CarrierFreq = fp->dl_CarrierFreq - (get_uldl_offset(gNB_config->nfapi_config.rf_bands.rf_band[0])*100000);
+  fp->dl_CarrierFreq = 3500000000;//from_nrarfcn(gNB_config->nfapi_config.rf_bands.rf_band[0],gNB_config->nfapi_config.nrarfcn.value);
+  fp->ul_CarrierFreq = 3500000000;//fp->dl_CarrierFreq - (get_uldl_offset(gNB_config->nfapi_config.rf_bands.rf_band[0])*100000);
   fp->threequarter_fs                    = 0;
   nr_init_frame_parms(gNB_config, fp);
   gNB->configured                                   = 1;
   LOG_I(PHY,"gNB configured\n");
+
 }
 
 
@@ -398,6 +407,7 @@ void nr_phy_config_request(NR_PHY_Config_t *phy_config) {
   gNB_config->sch_config.ssb_subcarrier_offset.value    = phy_config->cfg->sch_config.ssb_subcarrier_offset.value;//0;
   gNB_config->sch_config.n_ssb_crb.value                = (phy_config->cfg->rf_config.dl_carrier_bandwidth.value-20);
   gNB_config->sch_config.physical_cell_id.value         = phy_config->cfg->sch_config.physical_cell_id.value;
+  gNB_config->sch_config.ssb_scg_position_in_burst.value= phy_config->cfg->sch_config.ssb_scg_position_in_burst.value;
 
   if (phy_config->cfg->subframe_config.duplex_mode.value == 0) {
     gNB_config->subframe_config.duplex_mode.value    = TDD;
@@ -408,7 +418,7 @@ void nr_phy_config_request(NR_PHY_Config_t *phy_config) {
   RC.gNB[Mod_id][CC_id]->mac_enabled     = 1;
   fp->dl_CarrierFreq = from_nrarfcn(gNB_config->nfapi_config.rf_bands.rf_band[0],gNB_config->nfapi_config.nrarfcn.value);
   fp->ul_CarrierFreq = fp->dl_CarrierFreq - (get_uldl_offset(gNB_config->nfapi_config.rf_bands.rf_band[0])*100000);
-  fp->threequarter_fs                    = 0;
+  fp->threequarter_fs                    = openair0_cfg[0].threequarter_fs;
   LOG_I(PHY,"Configuring MIB for instance %d, CCid %d : (band %d,N_RB_DL %d, N_RB_UL %d, Nid_cell %d,DL freq %u)\n",
         Mod_id,
         CC_id,
@@ -417,6 +427,7 @@ void nr_phy_config_request(NR_PHY_Config_t *phy_config) {
         gNB_config->rf_config.ul_carrier_bandwidth.value,
         gNB_config->sch_config.physical_cell_id.value,
         fp->dl_CarrierFreq );
+
   nr_init_frame_parms(gNB_config, fp);
 
   if (RC.gNB[Mod_id][CC_id]->configured == 1) {
@@ -436,6 +447,7 @@ void init_nr_transport(PHY_VARS_gNB *gNB) {
   LOG_I(PHY, "Initialise nr transport\n");
 
   for (i=0; i<NUMBER_OF_UE_MAX; i++) {
+
     LOG_I(PHY,"Allocating Transport Channel Buffers for DLSCH, UE %d\n",i);
 
     for (j=0; j<2; j++) {
@@ -445,29 +457,38 @@ void init_nr_transport(PHY_VARS_gNB *gNB) {
         LOG_E(PHY,"Can't get gNB dlsch structures for UE %d \n", i);
         exit(-1);
       }/* else {
-
-  gNB->dlsch[i][j]->rnti=0;
-  LOG_D(PHY,"dlsch[%d][%d] => %p rnti:%d\n",i,j,gNB->dlsch[i][j], gNB->dlsch[i][j]->rnti);
+        gNB->dlsch[i][j]->rnti=0;
+        LOG_D(PHY,"dlsch[%d][%d] => %p rnti:%d\n",i,j,gNB->dlsch[i][j], gNB->dlsch[i][j]->rnti);
       }*/
+
+      ///////////////////////// Initializing gNB ULSCH /////////////////////////
+      LOG_I(PHY,"Allocating Transport Channel Buffer for ULSCH, UE %d\n",i);
+
+      // ULSCH for RA
+      if(i==0) {
+        gNB->ulsch[i][j] = new_gNB_ulsch(5, fp->N_RB_UL, 0);
+
+        if (!gNB->ulsch[i][j]) {
+          LOG_E(PHY,"Can't get gNB ulsch structures\n");
+          exit(-1);
+        }
+      }
+
+      // ULSCH for data
+      gNB->ulsch[i+1][j] = new_gNB_ulsch(5, fp->N_RB_UL, 0);
+
+      if (!gNB->ulsch[i+1][j]) {
+        LOG_E(PHY,"Can't get gNB ulsch structures\n");
+        exit(-1);
+      }
+      //////////////////////////////////////////////////////////////////////////
     }
 
-    //LOG_I(PHY,"Allocating Transport Channel Buffer for ULSCH, UE %d\n",i);
-    //gNB->ulsch[1+i] = new_gNB_ulsch(MAX_TURBO_ITERATIONS,fp->N_RB_UL, 0);
-    /*if (!gNB->ulsch[1+i]) {
-      LOG_E(PHY,"Can't get gNB ulsch structures\n");
-      exit(-1);
-    }*/
     // this is the transmission mode for the signalling channels
     // this will be overwritten with the real transmission mode by the RRC once the UE is connected
     //gNB->transmission_mode[i] = fp->nb_antenna_ports_gNB==1 ? 1 : 2;
   }
 
-  // ULSCH for RA
-  //gNB->ulsch[0] = new_gNB_ulsch(MAX_TURBO_ITERATIONS, fp->N_RB_UL, 0);
-  /*if (!gNB->ulsch[0]) {
-    LOG_E(PHY,"Can't get gNB ulsch structures\n");
-    exit(-1);
-  }*/
   gNB->dlsch_SI  = new_gNB_dlsch(1,8,NSOFT, 0, fp, cfg);
   LOG_D(PHY,"gNB %d.%d : SI %p\n",gNB->Mod_id,gNB->CC_id,gNB->dlsch_SI);
   gNB->dlsch_ra  = new_gNB_dlsch(1,8,NSOFT, 0, fp, cfg);
diff --git a/openair1/PHY/INIT/nr_init_ue.c b/openair1/PHY/INIT/nr_init_ue.c
index a150717e42..63aeba0480 100644
--- a/openair1/PHY/INIT/nr_init_ue.c
+++ b/openair1/PHY/INIT/nr_init_ue.c
@@ -357,12 +357,19 @@ void phy_config_dedicated_scell_ue(uint8_t Mod_id,
 }
 #endif
 
-void phy_config_harq_ue(module_id_t Mod_id,int CC_id,uint8_t eNB_id,
-                        uint16_t max_harq_tx )
+void phy_config_harq_ue(module_id_t Mod_id,
+						int CC_id,
+						uint8_t eNB_id,
+                        uint16_t max_harq_tx)
 {
 
+  int num_of_threads,num_of_code_words;
+
   PHY_VARS_NR_UE *phy_vars_ue = PHY_vars_UE_g[Mod_id][CC_id];
-  phy_vars_ue->ulsch[eNB_id]->Mlimit = max_harq_tx;
+
+  for (num_of_threads=0;num_of_threads<RX_NB_TH_MAX;num_of_threads++)
+    for (num_of_code_words=0;num_of_code_words<NR_MAX_NB_CODEWORDS;num_of_code_words++)
+      phy_vars_ue->ulsch[num_of_threads][eNB_id][num_of_code_words]->Mlimit = max_harq_tx;
 }
 
 extern uint16_t beta_cqi[16];
@@ -592,7 +599,8 @@ void phy_init_nr_ue__PDSCH( NR_UE_PDSCH* const pdsch, const NR_DL_FRAME_PARMS* c
   AssertFatal( pdsch, "pdsch==0" );
 
   pdsch->pmi_ext = (uint8_t*)malloc16_clear( fp->N_RB_DL );
-  pdsch->llr[0] = (int16_t*)malloc16_clear( (8*((3*8*6144)+12))*sizeof(int16_t) );
+  pdsch->llr[0] = (int16_t*)malloc16_clear( (8*(3*8*6144))*sizeof(int16_t) );
+  pdsch->layer_llr[0] = (int16_t*)malloc16_clear( (8*(3*8*6144))*sizeof(int16_t) );
   pdsch->llr128 = (int16_t**)malloc16_clear( sizeof(int16_t*) );
   // FIXME! no further allocation for (int16_t*)pdsch->llr128 !!! expect SIGSEGV
   // FK, 11-3-2015: this is only as a temporary pointer, no memory is stored there
@@ -602,6 +610,7 @@ void phy_init_nr_ue__PDSCH( NR_UE_PDSCH* const pdsch, const NR_DL_FRAME_PARMS* c
   pdsch->rxdataF_uespec_pilots  = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
   pdsch->rxdataF_comp0          = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
   pdsch->rho                    = (int32_t**)malloc16_clear( fp->nb_antennas_rx*sizeof(int32_t*) );
+  pdsch->dl_ch_estimates        = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
   pdsch->dl_ch_estimates_ext    = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
   pdsch->dl_bf_ch_estimates     = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
   pdsch->dl_bf_ch_estimates_ext = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
@@ -623,6 +632,7 @@ void phy_init_nr_ue__PDSCH( NR_UE_PDSCH* const pdsch, const NR_DL_FRAME_PARMS* c
       pdsch->rxdataF_ext[idx]             = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
       pdsch->rxdataF_uespec_pilots[idx]   = (int32_t*)malloc16_clear( sizeof(int32_t) * fp->N_RB_DL*12);
       pdsch->rxdataF_comp0[idx]           = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+      pdsch->dl_ch_estimates[idx]         = (int32_t*)malloc16_clear( sizeof(int32_t) * fp->ofdm_symbol_size*7*2);
       pdsch->dl_ch_estimates_ext[idx]     = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
       pdsch->dl_bf_ch_estimates[idx]      = (int32_t*)malloc16_clear( sizeof(int32_t) * fp->ofdm_symbol_size*7*2);
       pdsch->dl_bf_ch_estimates_ext[idx]  = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
@@ -719,22 +729,6 @@ int init_nr_ue_signal(PHY_VARS_NR_UE *ue,
     }
   }
 
-  // Channel estimates
-  for (eNB_id=0; eNB_id<7; eNB_id++) {
-    for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
-        common_vars->common_vars_rx_data_per_thread[th_id].dl_ch_estimates[eNB_id]      = (int32_t**)malloc16_clear(8*sizeof(int32_t*));
-        common_vars->common_vars_rx_data_per_thread[th_id].dl_ch_estimates_time[eNB_id] = (int32_t**)malloc16_clear(8*sizeof(int32_t*));
-    }
-
-    for (i=0; i<fp->nb_antennas_rx; i++)
-      for (j=0; j<4; j++) {
-        int idx = (j<<1) + i;
-        for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
-            common_vars->common_vars_rx_data_per_thread[th_id].dl_ch_estimates[eNB_id][idx] = (int32_t*)malloc16_clear( sizeof(int32_t)*fp->symbols_per_slot*(fp->ofdm_symbol_size+LTE_CE_FILTER_LENGTH) );
-            common_vars->common_vars_rx_data_per_thread[th_id].dl_ch_estimates_time[eNB_id][idx] = (int32_t*)malloc16_clear( sizeof(int32_t)*fp->ofdm_symbol_size*2 );
-        }
-      }
-  }
 
   // DLSCH
   for (eNB_id=0; eNB_id<ue->n_connected_eNB; eNB_id++) {
@@ -761,7 +755,8 @@ int init_nr_ue_signal(PHY_VARS_NR_UE *ue,
       for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
         (*pdsch_vars_th)[th_id][eNB_id]->llr_shifts      = (uint8_t*)malloc16_clear(7*2*fp->N_RB_DL*12);
         (*pdsch_vars_th)[th_id][eNB_id]->llr_shifts_p        = (*pdsch_vars_th)[0][eNB_id]->llr_shifts;
-        (*pdsch_vars_th)[th_id][eNB_id]->llr[1]              = (int16_t*)malloc16_clear( (8*((3*8*8448)+12))*sizeof(int16_t) );
+        (*pdsch_vars_th)[th_id][eNB_id]->llr[1]              = (int16_t*)malloc16_clear( (8*(3*8*8448))*sizeof(int16_t) );
+        (*pdsch_vars_th)[th_id][eNB_id]->layer_llr[1]        = (int16_t*)malloc16_clear( (8*(3*8*8448))*sizeof(int16_t) );
         (*pdsch_vars_th)[th_id][eNB_id]->llr128_2ndstream    = (int16_t**)malloc16_clear( sizeof(int16_t*) );
         (*pdsch_vars_th)[th_id][eNB_id]->rho                 = (int32_t**)malloc16_clear( fp->nb_antennas_rx*sizeof(int32_t*) );
       }
@@ -827,30 +822,32 @@ int init_nr_ue_signal(PHY_VARS_NR_UE *ue,
           (*pdcch_vars_th)[th_id][eNB_id]->rho                 = (int32_t**)malloc16( fp->nb_antennas_rx*sizeof(int32_t*) );
           (*pdcch_vars_th)[th_id][eNB_id]->rxdataF_ext         = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
           (*pdcch_vars_th)[th_id][eNB_id]->dl_ch_estimates_ext = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
-      }
-      
-      for (i=0; i<fp->nb_antennas_rx; i++) {
-        //ue_pdcch_vars[eNB_id]->rho[i] = (int32_t*)malloc16_clear( sizeof(int32_t)*(fp->N_RB_DL*12*7*2) );
-        for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
-            (*pdcch_vars_th)[th_id][eNB_id]->rho[i] = (int32_t*)malloc16_clear( sizeof(int32_t)*(100*12*4) );
-        }
 
-        for (j=0; j<4; j++) { //fp->nb_antennas_tx; j++)
-          int idx = (j<<1)+i;
-          //  size_t num = 7*2*fp->N_RB_DL*12;
-          size_t num = 4*100*12;  // 4 symbols, 100 PRBs, 12 REs per PRB
-          for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
+	  // Channel estimates
+	  (*pdcch_vars_th)[th_id][eNB_id]->dl_ch_estimates      = (int32_t**)malloc16_clear(8*sizeof(int32_t*));
+	  (*pdcch_vars_th)[th_id][eNB_id]->dl_ch_estimates_time = (int32_t**)malloc16_clear(8*sizeof(int32_t*));
+
+	  for (i=0; i<fp->nb_antennas_rx; i++) {
+            (*pdcch_vars_th)[th_id][eNB_id]->rho[i] = (int32_t*)malloc16_clear( sizeof(int32_t)*(100*12*4) );
+	    for (j=0; j<4; j++) {
+	      int idx = (j<<1) + i;
+	      (*pdcch_vars_th)[th_id][eNB_id]->dl_ch_estimates[idx] = (int32_t*)malloc16_clear( sizeof(int32_t)*fp->symbols_per_slot*(fp->ofdm_symbol_size+LTE_CE_FILTER_LENGTH) );
+	      (*pdcch_vars_th)[th_id][eNB_id]->dl_ch_estimates_time[idx] = (int32_t*)malloc16_clear( sizeof(int32_t)*fp->ofdm_symbol_size*2 );
+      
+	      //  size_t num = 7*2*fp->N_RB_DL*12;
+	      size_t num = 4*273*12;  // 4 symbols, 100 PRBs, 12 REs per PRB
               (*pdcch_vars_th)[th_id][eNB_id]->rxdataF_comp[idx]        = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
               (*pdcch_vars_th)[th_id][eNB_id]->dl_ch_rho_ext[idx]       = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
               (*pdcch_vars_th)[th_id][eNB_id]->rxdataF_ext[idx]         = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
               (*pdcch_vars_th)[th_id][eNB_id]->dl_ch_estimates_ext[idx] = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
-          }
-        }
+	    }
+	  }
       }
 
       // PBCH
       pbch_vars[eNB_id]->rxdataF_ext         = (int32_t**)malloc16( fp->nb_antennas_rx*sizeof(int32_t*) );
       pbch_vars[eNB_id]->rxdataF_comp        = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+      pbch_vars[eNB_id]->dl_ch_estimates     = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
       pbch_vars[eNB_id]->dl_ch_estimates_ext = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
       pbch_vars[eNB_id]->llr                 = (int16_t*)malloc16_clear( 1920 );//
       prach_vars[eNB_id]->prachF             = (int16_t*)malloc16_clear( sizeof(int)*(7*2*sizeof(int)*(fp->ofdm_symbol_size*12)) );
@@ -862,6 +859,7 @@ int init_nr_ue_signal(PHY_VARS_NR_UE *ue,
         for (j=0; j<4; j++) {//fp->nb_antennas_tx;j++) {
           int idx = (j<<1)+i;
           pbch_vars[eNB_id]->rxdataF_comp[idx]        = (int32_t*)malloc16_clear( sizeof(int32_t)*20*12*4 );
+          pbch_vars[eNB_id]->dl_ch_estimates[idx]     = (int32_t*)malloc16_clear( sizeof(int32_t)*7*2*sizeof(int)*(fp->ofdm_symbol_size) );
           pbch_vars[eNB_id]->dl_ch_estimates_ext[idx] = (int32_t*)malloc16_clear( sizeof(int32_t)*20*12*4 );
         }
       }
@@ -882,7 +880,8 @@ int init_nr_ue_signal(PHY_VARS_NR_UE *ue,
   if (abstraction_flag == 0) {
     for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
         //phy_init_lte_ue__PDSCH( (*pdsch_vars_th)[th_id][eNB_id], fp );
-        (*pdsch_vars_th)[th_id][eNB_id]->llr[1] = (int16_t*)malloc16_clear( (8*((3*8*8448)+12))*sizeof(int16_t) );
+        (*pdsch_vars_th)[th_id][eNB_id]->llr[1] = (int16_t*)malloc16_clear( (8*(3*8*8448))*sizeof(int16_t) );
+        (*pdsch_vars_th)[th_id][eNB_id]->layer_llr[1] = (int16_t*)malloc16_clear( (8*(3*8*8448))*sizeof(int16_t) );
     }
 
   } else { //abstraction == 1
@@ -920,14 +919,14 @@ void init_nr_ue_transport(PHY_VARS_NR_UE *ue,int abstraction_flag) {
   for (i=0; i<NUMBER_OF_CONNECTED_eNB_MAX; i++) {
     for (j=0; j<2; j++) {
       for (k=0; k<RX_NB_TH_MAX; k++) {
-	AssertFatal((ue->dlsch[k][i][j]  = new_nr_ue_dlsch(1,NUMBER_OF_HARQ_PID_MAX,NSOFT,MAX_LDPC_ITERATIONS,ue->frame_parms.N_RB_DL, abstraction_flag))!=NULL,"Can't get ue dlsch structures\n");
+        AssertFatal((ue->dlsch[k][i][j]  = new_nr_ue_dlsch(1,NUMBER_OF_HARQ_PID_MAX,NSOFT,MAX_LDPC_ITERATIONS,ue->frame_parms.N_RB_DL, abstraction_flag))!=NULL,"Can't get ue dlsch structures\n");
+        LOG_D(PHY,"dlsch[%d][%d][%d] => %p\n",k,i,j,ue->dlsch[k][i][j]);
 
-	LOG_D(PHY,"dlsch[%d][%d][%d] => %p\n",k,i,j,ue->dlsch[k][i][j]);
+        AssertFatal((ue->ulsch[k][i][j]  = new_nr_ue_ulsch(ue->frame_parms.N_RB_UL, NUMBER_OF_HARQ_PID_MAX, abstraction_flag))!=NULL,"Can't get ue ulsch structures\n");
+        LOG_D(PHY,"ulsch[%d][%d][%d] => %p\n",k,i,j,ue->ulsch[k][i][j]);
       }
     }
 
-    //AssertFatal((ue->ulsch[i]  = new_ue_ulsch(ue->frame_parms.N_RB_UL, abstraction_flag))!=NULL,"Can't get ue ulsch structures\n");
-
     ue->dlsch_SI[i]  = new_nr_ue_dlsch(1,1,NSOFT,MAX_LDPC_ITERATIONS,ue->frame_parms.N_RB_DL, abstraction_flag);
     ue->dlsch_ra[i]  = new_nr_ue_dlsch(1,1,NSOFT,MAX_LDPC_ITERATIONS,ue->frame_parms.N_RB_DL, abstraction_flag);
 
diff --git a/openair1/PHY/INIT/nr_parms.c b/openair1/PHY/INIT/nr_parms.c
index 6b782e17c4..5c38ab3056 100644
--- a/openair1/PHY/INIT/nr_parms.c
+++ b/openair1/PHY/INIT/nr_parms.c
@@ -27,6 +27,59 @@ uint32_t nr_subcarrier_spacing[MAX_NUM_SUBCARRIER_SPACING] = {15e3, 30e3, 60e3,
 uint16_t nr_slots_per_subframe[MAX_NUM_SUBCARRIER_SPACING] = {1, 2, 4, 16, 32};
 
 
+int nr_get_ssb_start_symbol(NR_DL_FRAME_PARMS *fp, uint8_t i_ssb, uint8_t half_frame_index)
+{
+
+  int mu = fp->numerology_index;
+  int symbol = 0;
+  uint8_t n, n_temp;
+  nr_ssb_type_e type = fp->ssb_type;
+  int case_AC[2] = {2,8};
+  int case_BD[4] = {4,8,16,20};
+  int case_E[8] = {8, 12, 16, 20, 32, 36, 40, 44};
+
+  switch(mu) {
+
+	case NR_MU_0: // case A
+	    n = i_ssb >> 1;
+	    symbol = case_AC[i_ssb % 2] + 14*n;
+	break;
+
+	case NR_MU_1: 
+	    if (type == 1){ // case B
+		n = i_ssb >> 2;
+	    	symbol = case_BD[i_ssb % 4] + 28*n;
+	    }
+	    if (type == 2){ // case C
+		n = i_ssb >> 1;
+		symbol = case_AC[i_ssb % 2] + 14*n;
+	    }
+	 break;
+
+	 case NR_MU_3: // case D
+	    n_temp = i_ssb >> 2; 
+	    n = n_temp + (n_temp >> 2);
+	    symbol = case_BD[i_ssb % 4] + 28*n;
+	 break;
+
+	 case NR_MU_4:  // case E
+	    n_temp = i_ssb >> 3; 
+	    n = n_temp + (n_temp >> 2);
+	    symbol = case_E[i_ssb % 8] + 56*n;
+	 break;
+
+
+	 default:
+	      AssertFatal(0==1, "Invalid numerology index %d for the synchronization block\n", mu);
+  }
+
+  if (half_frame_index)
+    symbol += (5 * fp->symbols_per_slot * fp->slots_per_subframe);
+
+  return symbol;
+}
+
+
 int nr_init_frame_parms0(NR_DL_FRAME_PARMS *fp,
 			 int mu,
 			 int Ncp,
@@ -46,18 +99,29 @@ int nr_init_frame_parms0(NR_DL_FRAME_PARMS *fp,
   fp->numerology_index = mu;
   fp->Ncp = Ncp;
   fp->N_RB_DL = N_RB_DL;
-  
+
   switch(mu) {
 
     case NR_MU_0: //15kHz scs
       fp->subcarrier_spacing = nr_subcarrier_spacing[NR_MU_0];
       fp->slots_per_subframe = nr_slots_per_subframe[NR_MU_0];
+      fp->ssb_type = nr_ssb_type_A;
       break;
 
     case NR_MU_1: //30kHz scs
       fp->subcarrier_spacing = nr_subcarrier_spacing[NR_MU_1];
       fp->slots_per_subframe = nr_slots_per_subframe[NR_MU_1];
 
+      // selection of SS block pattern according to TS 38101-1 Table 5.4.3.3-1 for SCS 30kHz
+      if (fp->eutra_band == 5 || fp->eutra_band == 66) 
+	      fp->ssb_type = nr_ssb_type_B;
+      else{  
+      	if (fp->eutra_band == 41 || ( fp->eutra_band > 76 && fp->eutra_band < 80) )
+		fp->ssb_type = nr_ssb_type_C;
+	else
+		AssertFatal(1==0,"NR Operating Band n%d not available for SS block SCS with mu=%d\n", fp->eutra_band, mu);
+      }
+
       switch(N_RB_DL){
         case 11:
         case 24:
@@ -144,11 +208,13 @@ int nr_init_frame_parms0(NR_DL_FRAME_PARMS *fp,
     case NR_MU_3:
       fp->subcarrier_spacing = nr_subcarrier_spacing[NR_MU_3];
       fp->slots_per_subframe = nr_slots_per_subframe[NR_MU_3];
+      fp->ssb_type = nr_ssb_type_D;
       break;
 
     case NR_MU_4:
       fp->subcarrier_spacing = nr_subcarrier_spacing[NR_MU_4];
       fp->slots_per_subframe = nr_slots_per_subframe[NR_MU_4];
+      fp->ssb_type = nr_ssb_type_E;
       break;
 
   default:
@@ -169,13 +235,16 @@ int nr_init_frame_parms0(NR_DL_FRAME_PARMS *fp,
   fp->samples_per_frame = 10 * fp->samples_per_subframe;
   fp->freq_range = (fp->dl_CarrierFreq < 6e9)? nr_FR1 : nr_FR2;
 
-  // Initial bandwidth part configuration -- full carrier bandwidth
-  fp->initial_bwp_dl.bwp_id = 0;
-  fp->initial_bwp_dl.scs = fp->subcarrier_spacing;
-  fp->initial_bwp_dl.location = 0;
-  fp->initial_bwp_dl.N_RB = fp->N_RB_DL;
-  fp->initial_bwp_dl.cyclic_prefix = fp->Ncp;
-  fp->initial_bwp_dl.ofdm_symbol_size = fp->ofdm_symbol_size;
+  // definition of Lmax according to ts 38.213 section 4.1
+  if (fp->dl_CarrierFreq < 6e9){
+	if(fp->frame_type && (fp->ssb_type==2))
+		fp->Lmax = (fp->dl_CarrierFreq < 2.4e9)? 4 : 8;
+	else
+		fp->Lmax = (fp->dl_CarrierFreq < 3e9)? 4 : 8;
+  }  
+  else
+    fp->Lmax = 64;
+
 
   return 0;
 }
@@ -184,7 +253,9 @@ int nr_init_frame_parms(nfapi_nr_config_request_t* config,
                         NR_DL_FRAME_PARMS *fp)
 {
 
-
+  fp->eutra_band = config->nfapi_config.rf_bands.rf_band[0];
+  fp->frame_type = !(config->subframe_config.duplex_mode.value);
+  fp->L_ssb = config->sch_config.ssb_scg_position_in_burst.value;
   return nr_init_frame_parms0(fp,
 			      config->subframe_config.numerology_index_mu.value,
 			      config->subframe_config.dl_cyclic_prefix_type.value,
@@ -215,10 +286,7 @@ void nr_dump_frame_parms(NR_DL_FRAME_PARMS *fp)
   LOG_I(PHY,"fp->samples_per_frame_wCP=%d\n",fp->samples_per_frame_wCP);
   LOG_I(PHY,"fp->samples_per_subframe=%d\n",fp->samples_per_subframe);
   LOG_I(PHY,"fp->samples_per_frame=%d\n",fp->samples_per_frame);
-  LOG_I(PHY,"fp->initial_bwp_dl.bwp_id=%d\n",fp->initial_bwp_dl.bwp_id);
-  LOG_I(PHY,"fp->initial_bwp_dl.scs=%d\n",fp->initial_bwp_dl.scs);
-  LOG_I(PHY,"fp->initial_bwp_dl.N_RB=%d\n",fp->initial_bwp_dl.N_RB);
-  LOG_I(PHY,"fp->initial_bwp_dl.cyclic_prefix=%d\n",fp->initial_bwp_dl.cyclic_prefix);
-  LOG_I(PHY,"fp->initial_bwp_dl.location=%d\n",fp->initial_bwp_dl.location);
-  LOG_I(PHY,"fp->initial_bwp_dl.ofdm_symbol_size=%d\n",fp->initial_bwp_dl.ofdm_symbol_size);
 }
+
+
+
diff --git a/openair1/PHY/INIT/phy_init.h b/openair1/PHY/INIT/phy_init.h
index 2a7dcf88fd..6f9cff07bf 100644
--- a/openair1/PHY/INIT/phy_init.h
+++ b/openair1/PHY/INIT/phy_init.h
@@ -376,6 +376,7 @@ void phy_config_request(PHY_Config_t *phy_config);
 
 int init_frame_parms(LTE_DL_FRAME_PARMS *frame_parms,uint8_t osf);
 void dump_frame_parms(LTE_DL_FRAME_PARMS *frame_parms);
+int nr_get_ssb_start_symbol(NR_DL_FRAME_PARMS *fp, uint8_t i_ssb, uint8_t half_frame_index);
 int nr_init_frame_parms(nfapi_nr_config_request_t* config, NR_DL_FRAME_PARMS *frame_parms);
 int nr_init_frame_parms_ue(NR_DL_FRAME_PARMS *frame_parms,int mu,int Ncp,int N_RB_DL,int n_ssb_crb,int ssb_subcarrier_offset);
 int init_nr_ue_signal(PHY_VARS_NR_UE *ue,int nb_connected_eNB,uint8_t abstraction_flag);
@@ -383,13 +384,14 @@ void init_nr_ue_transport(PHY_VARS_NR_UE *ue,int abstraction_flag);
 void nr_dump_frame_parms(NR_DL_FRAME_PARMS *frame_parms);
 int phy_init_nr_gNB(PHY_VARS_gNB *gNB, unsigned char is_secondary_gNB, unsigned char abstraction_flag);
 void nr_phy_config_request(NR_PHY_Config_t *gNB);
-void nr_phy_config_request_sim(PHY_VARS_gNB *gNB,int N_RB_DL,int N_RB_UL,int mu,int Nid_cell);
+void nr_phy_config_request_sim(PHY_VARS_gNB *gNB,int N_RB_DL,int N_RB_UL,int mu,int Nid_cell,uint64_t position_in_burst);
 void phy_free_nr_gNB(PHY_VARS_gNB *gNB);
 int l1_north_init_gNB(void);
 void init_nr_transport(PHY_VARS_gNB *gNB);
 
 void init_dfts(void);
 
+
 /** @} */
 #endif
 
diff --git a/openair1/PHY/LTE_TRANSPORT/dlsch_coding.c b/openair1/PHY/LTE_TRANSPORT/dlsch_coding.c
index a7e4b33c16..85886f88b6 100644
--- a/openair1/PHY/LTE_TRANSPORT/dlsch_coding.c
+++ b/openair1/PHY/LTE_TRANSPORT/dlsch_coding.c
@@ -41,7 +41,6 @@
 #include "common/utils/LOG/vcd_signal_dumper.h"
 #include "common/utils/LOG/log.h"
 #include <syscall.h>
-#include "targets/RT/USER/rt_wrapper.h"
 
 //#define DEBUG_DLSCH_CODING
 //#define DEBUG_DLSCH_FREE 1
@@ -337,14 +336,6 @@ int dlsch_encoding_2threads0(te_params *tep) {
 
 extern int oai_exit;
 void *te_thread(void *param) {
-  cpu_set_t cpuset;
-  CPU_ZERO(&cpuset);
-  
-  thread_top_init("te_thread",1,200000,250000,500000);
-  pthread_setname_np( pthread_self(),"te processing");
-  LOG_I(PHY,"thread te created id=%ld\n", syscall(__NR_gettid));
-  
-
   te_params *tep                 = (te_params *)param;
   
   //wait_sync("te_thread");
diff --git a/openair1/PHY/LTE_TRANSPORT/ulsch_decoding.c b/openair1/PHY/LTE_TRANSPORT/ulsch_decoding.c
index 046e456916..6cb8c7d212 100644
--- a/openair1/PHY/LTE_TRANSPORT/ulsch_decoding.c
+++ b/openair1/PHY/LTE_TRANSPORT/ulsch_decoding.c
@@ -42,7 +42,6 @@
 
 #include "common/utils/LOG/vcd_signal_dumper.h"
 //#define DEBUG_ULSCH_DECODING
-#include "targets/RT/USER/rt_wrapper.h"
 #include "transport_proto.h"
 
 extern WORKER_CONF_t get_thread_worker_conf(void);
@@ -383,10 +382,7 @@ extern int oai_exit;
 void *td_thread(void *param) {
   PHY_VARS_eNB *eNB = ((td_params*)param)->eNB;
   eNB_proc_t *proc  = &eNB->proc;
-  cpu_set_t cpuset;
-  CPU_ZERO(&cpuset);
   
-  thread_top_init("td_thread",1,200000,250000,500000);
   pthread_setname_np( pthread_self(),"td processing");
   LOG_I(PHY,"thread td created id=%ld\n", syscall(__NR_gettid));
   //wait_sync("td_thread");
diff --git a/openair1/PHY/LTE_UE_TRANSPORT/transport_ue.h b/openair1/PHY/LTE_UE_TRANSPORT/transport_ue.h
index 98e6f90a53..4c433a5683 100644
--- a/openair1/PHY/LTE_UE_TRANSPORT/transport_ue.h
+++ b/openair1/PHY/LTE_UE_TRANSPORT/transport_ue.h
@@ -194,7 +194,7 @@ typedef struct {
   /// allocated CBA RNTI
   uint16_t cba_rnti[4];//NUM_MAX_CBA_GROUP];
   /// UL max-harq-retransmission
-  uint8_t Mlimit;
+  uint16_t Mlimit;
 } LTE_UE_ULSCH_t;
 
 
diff --git a/openair1/PHY/MODULATION/modulation_UE.h b/openair1/PHY/MODULATION/modulation_UE.h
index 9734c02907..2bb04bd43a 100644
--- a/openair1/PHY/MODULATION/modulation_UE.h
+++ b/openair1/PHY/MODULATION/modulation_UE.h
@@ -52,9 +52,7 @@ int nr_slot_fep(PHY_VARS_NR_UE *phy_vars_ue,
              unsigned char l,
              unsigned char Ns,
              int sample_offset,
-             int no_prefix,
-	     int reset_freq_est,
-			 NR_CHANNEL_EST_t channel);
+             int no_prefix);
 
 int slot_fep_mbsfn(PHY_VARS_UE *phy_vars_ue,
                    unsigned char l,
diff --git a/openair1/PHY/MODULATION/slot_fep_nr.c b/openair1/PHY/MODULATION/slot_fep_nr.c
index 1e1751fe24..c6a6d93c18 100644
--- a/openair1/PHY/MODULATION/slot_fep_nr.c
+++ b/openair1/PHY/MODULATION/slot_fep_nr.c
@@ -35,38 +35,30 @@
 #endif*/
 
 int nr_slot_fep(PHY_VARS_NR_UE *ue,
-		unsigned char l,
+		unsigned char symbol,
 		unsigned char Ns,
 		int sample_offset,
-		int no_prefix,
-		int reset_freq_est,
-		NR_CHANNEL_EST_t channel)
+		int no_prefix)
 {
   NR_DL_FRAME_PARMS *frame_parms = &ue->frame_parms;
   NR_UE_COMMON *common_vars   = &ue->common_vars;
-  uint8_t eNB_id = 0;//ue_common_vars->eNb_id;
   unsigned char aa;
-  unsigned char symbol = l;//+((7-frame_parms->Ncp)*(Ns&1)); ///symbol within sub-frame
-  unsigned int nb_prefix_samples = (no_prefix ? 0 : frame_parms->nb_prefix_samples);
-  unsigned int nb_prefix_samples0 = (no_prefix ? 0 : frame_parms->nb_prefix_samples0);
+  unsigned int nb_prefix_samples;
+  unsigned int nb_prefix_samples0;
+  if (ue->is_synchronized) {
+    nb_prefix_samples = (no_prefix ? 0 : frame_parms->nb_prefix_samples);
+    nb_prefix_samples0 = (no_prefix ? 0 : frame_parms->nb_prefix_samples0);
+  }
+  else {
+    nb_prefix_samples = (no_prefix ? 0 : frame_parms->nb_prefix_samples);
+    nb_prefix_samples0 = (no_prefix ? 0 : frame_parms->nb_prefix_samples);
+  }
   //unsigned int subframe_offset;//,subframe_offset_F;
   unsigned int slot_offset;
   //int i;
   unsigned int frame_length_samples = frame_parms->samples_per_subframe * 10;
   unsigned int rx_offset;
-  NR_UE_PDCCH *pdcch_vars  = ue->pdcch_vars[ue->current_thread_id[Ns]][0];
-  uint16_t coreset_start_subcarrier = frame_parms->first_carrier_offset;//+((int)floor(frame_parms->ssb_start_subcarrier/NR_NB_SC_PER_RB)+pdcch_vars->coreset[0].rb_offset)*NR_NB_SC_PER_RB;
-  uint16_t nb_rb_coreset = 0;
-  uint16_t bwp_start_subcarrier = frame_parms->first_carrier_offset;//+516;
-  uint16_t nb_rb_pdsch = 50;
-  uint8_t p=0;
-  uint8_t l0 = pdcch_vars->coreset[0].duration;
-  uint64_t coreset_freq_dom  = pdcch_vars->coreset[0].frequencyDomainResources;
-  for (int i = 0; i < 45; i++) {
-    if (((coreset_freq_dom & 0x1FFFFFFFFFFF) >> i) & 0x1) nb_rb_coreset++;
-  }
-  nb_rb_coreset = 6 * nb_rb_coreset; 
-  //printf("corset duration %d nb_rb_coreset %d\n", l0, nb_rb_coreset);
+
 
   void (*dft)(int16_t *,int16_t *, int);
   int tmp_dft_in[8192] __attribute__ ((aligned (32)));  // This is for misalignment issues for 6 and 15 PRBs
@@ -140,7 +132,7 @@ int nr_slot_fep(PHY_VARS_NR_UE *ue,
           nb_prefix_samples,nb_prefix_samples0,slot_offset,sample_offset,rx_offset,frame_length_samples);
 #endif
 
-    if (l==0) {
+    if (symbol==0) {
 
       if (rx_offset > (frame_length_samples - frame_parms->ofdm_symbol_size))
         memcpy((short *)&common_vars->rxdata[aa][frame_length_samples],
@@ -165,7 +157,7 @@ int nr_slot_fep(PHY_VARS_NR_UE *ue,
 #endif
       }
     } else {
-      rx_offset += (frame_parms->ofdm_symbol_size+nb_prefix_samples)*l;// +
+      rx_offset += (frame_parms->ofdm_symbol_size+nb_prefix_samples)*symbol;// +
       //                   (frame_parms->ofdm_symbol_size+nb_prefix_samples)*(l-1);
 
       if (rx_offset > (frame_length_samples - frame_parms->ofdm_symbol_size))
@@ -200,107 +192,6 @@ int nr_slot_fep(PHY_VARS_NR_UE *ue,
     #endif
   }
 
-  if (ue->perfect_ce == 0) {
-
-  switch(channel){
-  case NR_PBCH_EST:
-
-#ifdef DEBUG_FEP
-    printf("Channel estimation eNB %d, slot %d, symbol %d\n",eNB_id,Ns,l);
-#endif
-#if UE_TIMING_TRACE
-    start_meas(&ue->dlsch_channel_estimation_stats);
-#endif
-    nr_pbch_channel_estimation(ue,eNB_id,0,
-			       Ns,
-			       l,
-			       symbol);
-      //}
-#if UE_TIMING_TRACE
-        stop_meas(&ue->dlsch_channel_estimation_stats);
-#endif
-
-      // do frequency offset estimation here!
-      // use channel estimates from current symbol (=ch_t) and last symbol (ch_{t-1})
-#ifdef DEBUG_FEP
-      printf("Frequency offset estimation\n");
-#endif
-
-      if (l==(4-frame_parms->Ncp)) {
-
-#if UE_TIMING_TRACE
-          start_meas(&ue->dlsch_freq_offset_estimation_stats);
-#endif
-
-        /*lte_est_freq_offset(common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[Ns>>1]].dl_ch_estimates[0],
-                            frame_parms,
-                            l,
-                            &common_vars->freq_offset,
-			    reset_freq_est);*/
-#if UE_TIMING_TRACE
-        stop_meas(&ue->dlsch_freq_offset_estimation_stats);
-#endif
-
-      }
-
-  break;
-
-  case NR_PDCCH_EST:
-
-#ifdef DEBUG_FEP
-    printf("PDCCH Channel estimation eNB %d, aatx %d, slot %d, symbol %d start_sc %d\n",eNB_id,aa,Ns,l,coreset_start_subcarrier);
-#endif
-#if UE_TIMING_TRACE
-    start_meas(&ue->dlsch_channel_estimation_stats);
-#endif
-    nr_pdcch_channel_estimation(ue,eNB_id,0,
-				Ns,
-				l,
-				symbol,
-				coreset_start_subcarrier,
-				nb_rb_coreset);
-#if UE_TIMING_TRACE
-    stop_meas(&ue->dlsch_channel_estimation_stats);
-#endif
-    
-    break;
-    
-  case NR_PDSCH_EST:
-#ifdef DEBUG_FEP
-    printf("Channel estimation eNB %d, aatx %d, slot %d, symbol %d\n",eNB_id,aa,Ns,l);
-#endif
-#if UE_TIMING_TRACE
-    start_meas(&ue->dlsch_channel_estimation_stats);
-#endif
-
-  ue->frame_parms.nushift =  (p>>1)&1;;
-
-    if (symbol ==l0)
-    nr_pdsch_channel_estimation(ue,eNB_id,0,
-				Ns,
-				p,
-				l,
-				symbol,
-				bwp_start_subcarrier,
-				nb_rb_pdsch);
-				
-#if UE_TIMING_TRACE
-    stop_meas(&ue->dlsch_channel_estimation_stats);
-#endif
-    
-    break;
-    
-  case NR_SSS_EST:
-  break;
-
-  default:
-    LOG_E(PHY,"[UE][FATAL] Unknown channel format %d\n",channel);
-    return(-1);
-    break;
-  }
-
-  }
-
 #ifdef DEBUG_FEP
   printf("slot_fep: done\n");
 #endif
diff --git a/openair1/PHY/NR_REFSIG/nr_gold.c b/openair1/PHY/NR_REFSIG/nr_gold.c
index 968f7fa7a4..bd60933155 100644
--- a/openair1/PHY/NR_REFSIG/nr_gold.c
+++ b/openair1/PHY/NR_REFSIG/nr_gold.c
@@ -32,13 +32,13 @@ void nr_init_pbch_dmrs(PHY_VARS_gNB* gNB)
 
   Nid = cfg->sch_config.physical_cell_id.value;
 
-  Lmax = (fp->dl_CarrierFreq < 3e9)? 4:8;
+  Lmax = fp->Lmax;
   N_hf = (Lmax == 4)? 2:1;
 
   for (n_hf = 0; n_hf < N_hf; n_hf++) {
     for (l = 0; l < Lmax ; l++) {
       i_ssb = l & (Lmax-1);
-      i_ssb2 = (i_ssb<<2) + n_hf;
+      i_ssb2 = i_ssb + (n_hf<<2);
 
       reset = 1;
       x2 = (1<<11) * (i_ssb2 + 1) * ((Nid>>2) + 1) + (1<<6) * (i_ssb2 + 1) + (Nid&3);
diff --git a/openair1/PHY/NR_REFSIG/nr_gold_ue.c b/openair1/PHY/NR_REFSIG/nr_gold_ue.c
index 3bb8745875..726aab8a37 100644
--- a/openair1/PHY/NR_REFSIG/nr_gold_ue.c
+++ b/openair1/PHY/NR_REFSIG/nr_gold_ue.c
@@ -29,15 +29,14 @@ void nr_gold_pbch(PHY_VARS_NR_UE* ue)
   unsigned char Lmax, l, n_hf, N_hf;
 
   Nid = ue->frame_parms.Nid_cell;
-
-  Lmax = 8; //(fp->dl_CarrierFreq < 3e9)? 4:8;
+  Lmax = ue->frame_parms.Lmax;
   N_hf = (Lmax == 4)? 2:1;
 
   for (n_hf = 0; n_hf < N_hf; n_hf++) {
 
     for (l = 0; l < Lmax ; l++) {
       i_ssb = l & (Lmax-1);
-      i_ssb2 = (i_ssb<<2) + n_hf;
+      i_ssb2 = i_ssb + (n_hf<<2);
 
       x1 = 1 + (1<<31);
       x2 = (1<<11) * (i_ssb2 + 1) * ((Nid>>2) + 1) + (1<<6) * (i_ssb2 + 1) + (Nid&3);
diff --git a/openair1/PHY/NR_TRANSPORT/nr_dci.c b/openair1/PHY/NR_TRANSPORT/nr_dci.c
index 929ac823dd..15e31d9728 100644
--- a/openair1/PHY/NR_TRANSPORT/nr_dci.c
+++ b/openair1/PHY/NR_TRANSPORT/nr_dci.c
@@ -31,6 +31,7 @@
 */
 
 #include "nr_dci.h"
+#include "nr_dlsch.h"
 
 //#define DEBUG_PDCCH_DMRS
 //#define DEBUG_DCI
diff --git a/openair1/PHY/NR_TRANSPORT/nr_dci.h b/openair1/PHY/NR_TRANSPORT/nr_dci.h
index 21fcd06c09..f53f5be282 100644
--- a/openair1/PHY/NR_TRANSPORT/nr_dci.h
+++ b/openair1/PHY/NR_TRANSPORT/nr_dci.h
@@ -25,8 +25,6 @@
 #include "PHY/defs_gNB.h"
 #include "PHY/NR_REFSIG/nr_refsig.h"
 
-typedef unsigned __int128 uint128_t;
-
 uint16_t nr_get_dci_size(nfapi_nr_dci_format_e format,
                          nfapi_nr_rnti_type_e rnti_type,
                          uint16_t N_RB,
diff --git a/openair1/PHY/NR_TRANSPORT/nr_dci_tools.c b/openair1/PHY/NR_TRANSPORT/nr_dci_tools.c
index 06c0e30bde..b392506095 100644
--- a/openair1/PHY/NR_TRANSPORT/nr_dci_tools.c
+++ b/openair1/PHY/NR_TRANSPORT/nr_dci_tools.c
@@ -46,7 +46,7 @@ void nr_fill_cce_list(NR_gNB_DCI_ALLOC_t* dci_alloc, uint16_t n_shift, uint8_t m
   uint8_t bsize = pdcch_params->reg_bundle_size;
   uint8_t R = pdcch_params->interleaver_size;
   uint16_t N_reg = pdcch_params->n_rb * pdcch_params->n_symb;
-  uint16_t Y, N_cce, M_s_max, n_CI=0, tmp, C;
+  uint16_t Y, N_cce, M_s_max, n_CI=0, tmp, C=0;
   uint16_t n_RNTI = (pdcch_params->search_space_type == NFAPI_NR_SEARCH_SPACE_TYPE_UE_SPECIFIC)? pdcch_params->rnti:0;
   uint32_t A[3]={39827,39829,39839};
 
@@ -64,9 +64,9 @@ void nr_fill_cce_list(NR_gNB_DCI_ALLOC_t* dci_alloc, uint16_t n_shift, uint8_t m
   }
 
   if (pdcch_params->cr_mapping_type == NFAPI_NR_CCE_REG_MAPPING_INTERLEAVED) {
-    AssertFatal((N_reg%(bsize*R))==0, "CCE to REG interleaving: Invalid configuration leading to non integer C (N_reg %d, bsize %d R %d)\n",
-    N_reg, bsize, R);
-    C = N_reg/(bsize*R);
+	  uint16_t assertFatalCond = (N_reg%(bsize*R));
+	  AssertFatal(assertFatalCond == 0,"CCE to REG interleaving: Invalid configuration leading to non integer C (N_reg %us, bsize %d R %d)\n",N_reg, bsize, R);
+	  C = N_reg/(bsize*R);
   }
 
   tmp = L * (( Y + (m*N_cce)/(L*M_s_max) + n_CI ) % CEILIDIV(N_cce,L));
diff --git a/openair1/PHY/NR_TRANSPORT/nr_dlsch.c b/openair1/PHY/NR_TRANSPORT/nr_dlsch.c
index eb2e11fec4..48cd97809a 100644
--- a/openair1/PHY/NR_TRANSPORT/nr_dlsch.c
+++ b/openair1/PHY/NR_TRANSPORT/nr_dlsch.c
@@ -215,7 +215,7 @@ uint8_t nr_generate_pdsch(NR_gNB_DLSCH_t dlsch,
   nr_dlsch_encoding(harq->pdu, slot, &dlsch, &frame_parms);
 #ifdef DEBUG_DLSCH
 printf("PDSCH encoding:\nPayload:\n");
-for (int i=0; i<TBS>>7; i++) {
+for (int i=0; i<harq->B>>7; i++) {
   for (int j=0; j<16; j++)
     printf("0x%02x\t", harq->pdu[(i<<4)+j]);
   printf("\n");
@@ -233,7 +233,7 @@ printf("\n");
   for (int q=0; q<rel15->nb_codewords; q++)
     memset((void*)scrambled_output[q], 0, (encoded_length>>5)*sizeof(uint32_t));
   uint16_t n_RNTI = (pdcch_params.search_space_type == NFAPI_NR_SEARCH_SPACE_TYPE_UE_SPECIFIC)? \
-  ((pdcch_params.scrambling_id)?pdcch_params.rnti:0) : 0;
+  ((pdcch_params.scrambling_id==0)?pdcch_params.rnti:0) : 0;
   uint16_t Nid = (pdcch_params.search_space_type == NFAPI_NR_SEARCH_SPACE_TYPE_UE_SPECIFIC)? \
   pdcch_params.scrambling_id : config.sch_config.physical_cell_id.value;
   for (int q=0; q<rel15->nb_codewords; q++)
@@ -308,16 +308,13 @@ for (int i=0; i<n_dmrs>>4; i++) {
 
 
     // Non interleaved VRB to PRB mapping
-  uint16_t start_sc = frame_parms.first_carrier_offset + frame_parms.ssb_start_subcarrier;
-  if (start_sc >= frame_parms.ofdm_symbol_size)
-    start_sc -= frame_parms.ofdm_symbol_size;
- /*rel15->start_prb*NR_NB_SC_PER_RB +
-  ((pdcch_params.search_space_type == NFAPI_NR_SEARCH_SPACE_TYPE_COMMON) && (pdcch_params.dci_format == NFAPI_NR_DL_DCI_FORMAT_1_0))?\
-       ((frame_parms.ssb_start_subcarrier/NR_NB_SC_PER_RB + pdcch_params.rb_offset)*NR_NB_SC_PER_RB) : 0;*/
+ uint16_t start_sc = frame_parms.first_carrier_offset + rel15->start_prb*NR_NB_SC_PER_RB;
+ if (start_sc >= frame_parms.ofdm_symbol_size)
+   start_sc -= frame_parms.ofdm_symbol_size;
 
 #ifdef DEBUG_DLSCH_MAPPING
-printf("PDSCH resource mapping started (start SC %d\tstart symbol %d\tN_PRB %d\tnb_symbols %d)\n",
-start_sc, rel15->start_symbol, rel15->n_prb, rel15->nb_symbols);
+ printf("PDSCH resource mapping started (start SC %d\tstart symbol %d\tN_PRB %d\tnb_symbols %d)\n",
+	start_sc, rel15->start_symbol, rel15->n_prb, rel15->nb_symbols);
 #endif
 
   for (int ap=0; ap<rel15->nb_layers; ap++) {
diff --git a/openair1/PHY/NR_TRANSPORT/nr_dlsch.h b/openair1/PHY/NR_TRANSPORT/nr_dlsch.h
index 06969eded0..f5f1ba3d0a 100644
--- a/openair1/PHY/NR_TRANSPORT/nr_dlsch.h
+++ b/openair1/PHY/NR_TRANSPORT/nr_dlsch.h
@@ -67,6 +67,11 @@ void nr_pdsch_codeword_scrambling(uint8_t *in,
                          uint32_t n_RNTI,
                          uint32_t* out);
 
+void nr_modulation(uint32_t *in,
+                   uint16_t length,
+                   nr_mod_t modulation_type,
+                   int16_t *out);
+
 void nr_pdsch_codeword_modulation(uint32_t *in,
                          uint8_t  Qm,
                          uint32_t length,
@@ -96,6 +101,8 @@ void free_gNB_dlsch(NR_gNB_DLSCH_t *dlsch);
 
 void clean_gNB_dlsch(NR_gNB_DLSCH_t *dlsch);
 
+void clean_gNB_ulsch(NR_gNB_ULSCH_t *ulsch);
+
 int nr_dlsch_encoding(unsigned char *a,
                      uint8_t subframe,
                      NR_gNB_DLSCH_t *dlsch,
diff --git a/openair1/PHY/NR_TRANSPORT/nr_dlsch_coding.c b/openair1/PHY/NR_TRANSPORT/nr_dlsch_coding.c
index 7415b36281..0a2927d881 100644
--- a/openair1/PHY/NR_TRANSPORT/nr_dlsch_coding.c
+++ b/openair1/PHY/NR_TRANSPORT/nr_dlsch_coding.c
@@ -69,7 +69,7 @@ void free_gNB_dlsch(NR_gNB_DLSCH_t *dlsch)
 #endif
 
         if (dlsch->harq_processes[i]->b) {
-          free16(dlsch->harq_processes[i]->b,MAX_DLSCH_PAYLOAD_BYTES);
+          free16(dlsch->harq_processes[i]->b,MAX_DLSCH_PAYLOAD_BYTES); //this should be MAX_NR_DLSCH_PAYLOAD_BYTES
           dlsch->harq_processes[i]->b = NULL;
 #ifdef DEBUG_DLSCH_FREE
           printf("Freeing dlsch process %d b (%p)\n",i,dlsch->harq_processes[i]->b);
@@ -195,8 +195,11 @@ NR_gNB_DLSCH_t *new_gNB_dlsch(unsigned char Kmimo,
         if (abstraction_flag==0) {
           for (r=0; r<MAX_NUM_NR_DLSCH_SEGMENTS/bw_scaling; r++) {
             // account for filler in first segment and CRCs for multiple segment case
+            // [hna] 8448 is the maximum CB size in NR
+            //       68*348 = 68*(maximum size of Zc)
+            //       In section 5.3.2 in 38.212, the for loop is up to N + 2*Zc (maximum size of N is 66*Zc, therefore 68*Zc)
             dlsch->harq_processes[i]->c[r] = (uint8_t*)malloc16(8448);
-            dlsch->harq_processes[i]->d[r] = (uint8_t*)malloc16(68*384);
+            dlsch->harq_processes[i]->d[r] = (uint8_t*)malloc16(68*384); //max size for coded output
             if (dlsch->harq_processes[i]->c[r]) {
               bzero(dlsch->harq_processes[i]->c[r],8448);
             } else {
@@ -272,7 +275,6 @@ int nr_dlsch_encoding(unsigned char *a,
 
   unsigned int G;
   unsigned int crc=1;
-
   uint8_t harq_pid = dlsch->harq_ids[slot];
   nfapi_nr_dl_config_dlsch_pdu_rel15_t rel15 = dlsch->harq_processes[harq_pid]->dlsch_pdu.dlsch_pdu_rel15;
   uint16_t nb_rb = rel15.n_prb;
@@ -280,8 +282,8 @@ int nr_dlsch_encoding(unsigned char *a,
   uint32_t A, Z, F=0;
   uint32_t *pz = &Z;
   uint8_t mod_order = rel15.modulation_order;
-  uint16_t Kr=0,r,r_offset=0,Kr_bytes;
-  uint8_t *d_tmp[MAX_NUM_DLSCH_SEGMENTS];
+  uint16_t Kr=0,r,r_offset=0;
+  //uint8_t *d_tmp[MAX_NUM_DLSCH_SEGMENTS];
   uint8_t BG=1;
   uint32_t E;
   uint8_t Ilbrm = 0;
@@ -302,7 +304,9 @@ int nr_dlsch_encoding(unsigned char *a,
   A = rel15.transport_block_size;
 
   G = nr_get_G(nb_rb, nb_symb_sch, nb_re_dmrs, length_dmrs,mod_order,rel15.nb_layers);
+
   LOG_D(PHY,"dlsch coding A %d G %d mod_order %d\n", A,G, mod_order);
+  
 
   Tbslbrm = nr_compute_tbs(28,nb_rb,frame_parms->symbols_per_slot,0,0, rel15.nb_layers);
 
@@ -328,6 +332,7 @@ int nr_dlsch_encoding(unsigned char *a,
 
     dlsch->harq_processes[harq_pid]->B = A+24;
     //    dlsch->harq_processes[harq_pid]->b = a;
+    
     memcpy(dlsch->harq_processes[harq_pid]->b,a,(A/8)+4);
 
     nr_segmentation(dlsch->harq_processes[harq_pid]->b,
@@ -335,7 +340,7 @@ int nr_dlsch_encoding(unsigned char *a,
 		    dlsch->harq_processes[harq_pid]->B,
 		    &dlsch->harq_processes[harq_pid]->C,
 		    &dlsch->harq_processes[harq_pid]->K,
-		    pz,
+		    pz, // [hna] pz is Zc
 		    &dlsch->harq_processes[harq_pid]->F);
 
     F = dlsch->harq_processes[harq_pid]->F;
@@ -349,13 +354,16 @@ int nr_dlsch_encoding(unsigned char *a,
 	}
 
     Kr = dlsch->harq_processes[harq_pid]->K;
+#ifdef DEBUG_DLSCH_CODING
+    uint16_t Kr_bytes;
     Kr_bytes = Kr>>3;
+#endif
 
     //printf("segment Z %d k %d Kr %d BG %d\n", *pz,dlsch->harq_processes[harq_pid]->K,Kr,BG);
 
     //start_meas(te_stats);
     for (r=0; r<dlsch->harq_processes[harq_pid]->C; r++) {
-      d_tmp[r] = &dlsch->harq_processes[harq_pid]->d[r][0];
+      //d_tmp[r] = &dlsch->harq_processes[harq_pid]->d[r][0];
       //channel_input[r] = &dlsch->harq_processes[harq_pid]->d[r][0];
 #ifdef DEBUG_DLSCH_CODING
       printf("Encoder: B %d F %d \n",dlsch->harq_processes[harq_pid]->B, dlsch->harq_processes[harq_pid]->F);
@@ -429,6 +437,7 @@ int nr_dlsch_encoding(unsigned char *a,
                           rel15.redundancy_version,
                           E);
 
+    
 #ifdef DEBUG_DLSCH_CODING
     for (int i =0; i<16; i++)
       printf("output ratematching e[%d]= %d r_offset %d\n", i,dlsch->harq_processes[harq_pid]->e[i+r_offset], r_offset);
@@ -442,6 +451,7 @@ int nr_dlsch_encoding(unsigned char *a,
 						dlsch->harq_processes[harq_pid]->f+r_offset);
     //stop_meas(i_stats);
 
+
 #ifdef DEBUG_DLSCH_CODING
     for (int i =0; i<16; i++)
       printf("output interleaving f[%d]= %d r_offset %d\n", i,dlsch->harq_processes[harq_pid]->f[i+r_offset], r_offset);
@@ -455,5 +465,5 @@ int nr_dlsch_encoding(unsigned char *a,
 
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_DLSCH_ENCODING, VCD_FUNCTION_OUT);
 
-  return(0);
+  return 0;
 }
diff --git a/openair1/PHY/NR_TRANSPORT/nr_pbch.c b/openair1/PHY/NR_TRANSPORT/nr_pbch.c
index 284a710335..ead8e3cda5 100644
--- a/openair1/PHY/NR_TRANSPORT/nr_pbch.c
+++ b/openair1/PHY/NR_TRANSPORT/nr_pbch.c
@@ -425,9 +425,11 @@ int nr_generate_pbch(NR_gNB_PBCH *pbch,
       m++;
     }
 
+
     if (k >= frame_parms->ofdm_symbol_size)
       k-=frame_parms->ofdm_symbol_size;
   }
 
+
   return 0;
 }
diff --git a/openair1/PHY/NR_TRANSPORT/nr_pss.c b/openair1/PHY/NR_TRANSPORT/nr_pss.c
index 29dbe4ec99..e0d7b6ae33 100644
--- a/openair1/PHY/NR_TRANSPORT/nr_pss.c
+++ b/openair1/PHY/NR_TRANSPORT/nr_pss.c
@@ -59,7 +59,6 @@ int nr_generate_pss(  int16_t *d_pss,
   /// Resource mapping
   a = amp;
 
-
     // PSS occupies a predefined position (subcarriers 56-182, symbol 0) within the SSB block starting from
     k = frame_parms->first_carrier_offset + frame_parms->ssb_start_subcarrier + 56; //and
     if (k>= frame_parms->ofdm_symbol_size) k-=frame_parms->ofdm_symbol_size;
diff --git a/openair1/PHY/NR_TRANSPORT/nr_tbs_tools.c b/openair1/PHY/NR_TRANSPORT/nr_tbs_tools.c
index f8b7454067..83d0d72b28 100644
--- a/openair1/PHY/NR_TRANSPORT/nr_tbs_tools.c
+++ b/openair1/PHY/NR_TRANSPORT/nr_tbs_tools.c
@@ -112,12 +112,9 @@ void nr_get_tbs(nfapi_nr_dl_config_dlsch_pdu *dlsch_pdu,
   nfapi_nr_dl_config_pdcch_parameters_rel15_t params_rel15 = dci_pdu.pdcch_params_rel15;
   nfapi_nr_dl_config_dlsch_pdu_rel15_t *dlsch_rel15 = &dlsch_pdu->dlsch_pdu_rel15;
   uint8_t rnti_type = params_rel15.rnti_type;
-  uint8_t dci_format = params_rel15.dci_format;
-  uint8_t ss_type = params_rel15.search_space_type;
   uint8_t N_PRB_oh = ((rnti_type==NFAPI_NR_RNTI_SI)||(rnti_type==NFAPI_NR_RNTI_RA)||(rnti_type==NFAPI_NR_RNTI_P))? 0 : \
   (config.pdsch_config.x_overhead.value);
   uint8_t N_PRB_DMRS = (config.pdsch_config.dmrs_type.value == NFAPI_NR_DMRS_TYPE1)?6:4; //This only works for antenna port 1000
-  uint8_t mcs_table = config.pdsch_config.mcs_table.value;
   uint8_t N_sh_symb = dlsch_rel15->nb_symbols;
   uint8_t Imcs = dlsch_rel15->mcs_idx;
   uint16_t N_RE_prime = NR_NB_SC_PER_RB*N_sh_symb - N_PRB_DMRS - N_PRB_oh;
@@ -126,7 +123,11 @@ void nr_get_tbs(nfapi_nr_dl_config_dlsch_pdu *dlsch_pdu,
   uint16_t N_RE, Ninfo, Ninfo_prime, C, TBS=0, R;
   uint8_t table_idx, Qm, n, scale;
 
-  table_idx = get_table_idx(mcs_table, dci_format, rnti_type, ss_type);
+  /*uint8_t mcs_table = config.pdsch_config.mcs_table.value;
+  uint8_t ss_type = params_rel15.search_space_type;
+  uint8_t dci_format = params_rel15.dci_format;
+  get_table_idx(mcs_table, dci_format, rnti_type, ss_type);*/
+  table_idx = 1;
   scale = ((table_idx==2)&&((Imcs==20)||(Imcs==26)))?11:10;
   
   N_RE = min(156, N_RE_prime)*dlsch_rel15->n_prb;
diff --git a/openair1/PHY/NR_TRANSPORT/nr_transport_common_proto.h b/openair1/PHY/NR_TRANSPORT/nr_transport_common_proto.h
index b075da4e97..14ba3de923 100644
--- a/openair1/PHY/NR_TRANSPORT/nr_transport_common_proto.h
+++ b/openair1/PHY/NR_TRANSPORT/nr_transport_common_proto.h
@@ -38,7 +38,7 @@
 #define MAX_NUM_NR_ULSCH_SEGMENTS MAX_NUM_NR_DLSCH_SEGMENTS
 
 #define MAX_NR_DLSCH_PAYLOAD_BYTES (MAX_NUM_NR_DLSCH_SEGMENTS*1056)
-#define MAX_NR_ULSCH_PAYLOAD_BYTES (MAX_NUM_NR_DLSCH_SEGMENTS*1056)
+#define MAX_NR_ULSCH_PAYLOAD_BYTES (MAX_NUM_NR_ULSCH_SEGMENTS*1056)
 
 #define MAX_NUM_NR_CHANNEL_BITS (14*273*12*6)  // 14 symbols, 273 RB
 #define MAX_NUM_NR_RE (14*273*12)
diff --git a/openair1/PHY/NR_TRANSPORT/nr_ulsch.h b/openair1/PHY/NR_TRANSPORT/nr_ulsch.h
new file mode 100644
index 0000000000..77cc101679
--- /dev/null
+++ b/openair1/PHY/NR_TRANSPORT/nr_ulsch.h
@@ -0,0 +1,49 @@
+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+/*! \file PHY/NR_TRANSPORT/nr_ulsch.h
+* \brief functions used for PUSCH/ULSCH physical and transport channels for gNB
+* \author Ahmed Hussein
+* \date 2019
+* \version 0.1
+* \company Fraunhofer IIS
+* \email: ahmed.hussein@iis.fraunhofer.de
+* \note
+* \warning
+*/
+
+#include "PHY/defs_gNB.h"
+
+void free_gNB_ulsch(NR_gNB_ULSCH_t *ulsch);
+
+NR_gNB_ULSCH_t *new_gNB_ulsch(uint8_t max_ldpc_iterations,uint8_t N_RB_UL, uint8_t abstraction_flag);
+
+uint32_t nr_ulsch_decoding(PHY_VARS_gNB *phy_vars_gNB,
+                           uint8_t UE_id,
+                           short *ulsch_llr,
+                           NR_DL_FRAME_PARMS *frame_parms,
+                           uint32_t frame,
+                           uint16_t nb_symb_sch,
+                           uint8_t nr_tti_rx,
+                           uint8_t harq_pid,
+                           uint8_t is_crnti,
+                           uint8_t llr8_flag);
+
diff --git a/openair1/PHY/NR_TRANSPORT/nr_ulsch_decoding.c b/openair1/PHY/NR_TRANSPORT/nr_ulsch_decoding.c
new file mode 100644
index 0000000000..f9d8291423
--- /dev/null
+++ b/openair1/PHY/NR_TRANSPORT/nr_ulsch_decoding.c
@@ -0,0 +1,709 @@
+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+/*! \file PHY/NR_TRANSPORT/nr_ulsch_decoding.c
+* \brief Top-level routines for decoding  LDPC (ULSCH) transport channels from 38.212, V15.4.0 2018-12
+* \author Ahmed Hussein
+* \date 2019
+* \version 0.1
+* \company Fraunhofer IIS
+* \email: ahmed.hussein@iis.fraunhofer.de
+* \note
+* \warning
+*/
+
+
+// [from gNB coding]
+#include "PHY/defs_gNB.h"
+#include "PHY/phy_extern.h"
+#include "PHY/CODING/coding_extern.h"
+#include "PHY/CODING/coding_defs.h"
+#include "PHY/CODING/lte_interleaver_inline.h"
+#include "PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.h"
+#include "PHY/CODING/nrLDPC_decoder/nrLDPC_types.h"
+#include "PHY/NR_TRANSPORT/nr_transport_common_proto.h"
+#include "PHY/NR_TRANSPORT/nr_ulsch.h"
+#include "PHY/NR_TRANSPORT/nr_dlsch.h"
+#include "SCHED_NR/sched_nr.h"
+#include "defs.h"
+#include "common/utils/LOG/vcd_signal_dumper.h"
+#include "common/utils/LOG/log.h"
+#include <syscall.h>
+//#define DEBUG_ULSCH_DECODING
+
+#define OAI_UL_LDPC_MAX_NUM_LLR 27000//26112 // NR_LDPC_NCOL_BG1*NR_LDPC_ZMAX = 68*384
+
+static uint64_t nb_total_decod =0;
+static uint64_t nb_error_decod =0;
+
+//extern double cpuf;
+
+void free_gNB_ulsch(NR_gNB_ULSCH_t *ulsch)
+{
+
+  int i,r;
+
+  if (ulsch) {
+    for (i=0; i<NR_MAX_ULSCH_HARQ_PROCESSES; i++) {
+
+      if (ulsch->harq_processes[i]) {
+        if (ulsch->harq_processes[i]->b) {
+          free16(ulsch->harq_processes[i]->b,MAX_NR_ULSCH_PAYLOAD_BYTES);
+          ulsch->harq_processes[i]->b = NULL;
+        }
+        for (r=0; r<MAX_NUM_NR_ULSCH_SEGMENTS; r++) {
+          free16(ulsch->harq_processes[i]->c[r],(8448)*sizeof(uint8_t));
+          ulsch->harq_processes[i]->c[r] = NULL;
+        }
+        for (r=0; r<MAX_NUM_NR_ULSCH_SEGMENTS; r++) {
+          if (ulsch->harq_processes[i]->d[r]) {
+            free16(ulsch->harq_processes[i]->d[r],(68*384)*sizeof(int16_t));
+            ulsch->harq_processes[i]->d[r] = NULL;
+          }
+        }
+        for (r=0; r<(MAX_NUM_NR_ULSCH_SEGMENTS); r++) {
+          if (ulsch->harq_processes[i]->p_nrLDPC_procBuf[r]){
+            nrLDPC_free_mem(ulsch->harq_processes[i]->p_nrLDPC_procBuf[r]);
+            ulsch->harq_processes[i]->p_nrLDPC_procBuf[r] = NULL;
+          }
+        }
+        free16(ulsch->harq_processes[i],sizeof(NR_UL_gNB_HARQ_t));
+        ulsch->harq_processes[i] = NULL;
+      }
+    }
+    free16(ulsch,sizeof(NR_gNB_ULSCH_t));
+    ulsch = NULL;
+  }
+}
+
+
+NR_gNB_ULSCH_t *new_gNB_ulsch(uint8_t max_ldpc_iterations,uint8_t N_RB_UL, uint8_t abstraction_flag)
+{
+
+  NR_gNB_ULSCH_t *ulsch;
+  uint8_t exit_flag = 0,i,r;
+  unsigned char bw_scaling =1;
+
+  switch (N_RB_UL) {
+    case 106:
+      bw_scaling =2;
+    break;
+
+    default:
+      bw_scaling =1;
+    break;
+  }
+
+  ulsch = (NR_gNB_ULSCH_t *)malloc16(sizeof(NR_gNB_ULSCH_t));
+
+  if (ulsch) {
+
+    memset(ulsch,0,sizeof(NR_gNB_ULSCH_t));
+
+    ulsch->max_ldpc_iterations = max_ldpc_iterations;
+    ulsch->Mlimit = 4;
+
+    for (i=0; i<NR_MAX_ULSCH_HARQ_PROCESSES; i++) {
+
+      ulsch->harq_processes[i] = (NR_UL_gNB_HARQ_t *)malloc16(sizeof(NR_UL_gNB_HARQ_t));
+
+      if (ulsch->harq_processes[i]) {
+
+        memset(ulsch->harq_processes[i],0,sizeof(NR_UL_gNB_HARQ_t));
+
+        ulsch->harq_processes[i]->b = (uint8_t*)malloc16(MAX_NR_ULSCH_PAYLOAD_BYTES/bw_scaling);
+
+        if (ulsch->harq_processes[i]->b)
+          memset(ulsch->harq_processes[i]->b,0,MAX_NR_ULSCH_PAYLOAD_BYTES/bw_scaling);
+        else
+          exit_flag=3;
+
+        if (abstraction_flag == 0) {
+          for (r=0; r<MAX_NUM_NR_ULSCH_SEGMENTS/bw_scaling; r++) {
+
+            ulsch->harq_processes[i]->p_nrLDPC_procBuf[r] = nrLDPC_init_mem();
+
+            ulsch->harq_processes[i]->c[r] = (uint8_t*)malloc16(8448*sizeof(uint8_t));
+
+            if (ulsch->harq_processes[i]->c[r])
+              memset(ulsch->harq_processes[i]->c[r],0,8448*sizeof(uint8_t));
+            else
+              exit_flag=2;
+
+            ulsch->harq_processes[i]->d[r] = (int16_t*)malloc16((68*384)*sizeof(int16_t));
+
+            if (ulsch->harq_processes[i]->d[r])
+              memset(ulsch->harq_processes[i]->d[r],0,(68*384)*sizeof(int16_t));
+            else
+              exit_flag=2;
+          }
+        }
+      } else {
+        exit_flag=1;
+      }
+    }
+
+    if (exit_flag==0)
+      return(ulsch);
+  }
+
+  printf("new_gNB_ulsch with size %zu: exit_flag = %u\n",sizeof(NR_UL_gNB_HARQ_t), exit_flag);
+  free_gNB_ulsch(ulsch);
+  
+  return(NULL);
+}
+
+void clean_gNB_ulsch(NR_gNB_ULSCH_t *ulsch)
+{
+  unsigned char i, j;
+
+  if (ulsch) {
+	  ulsch->harq_mask = 0;
+	  ulsch->bundling = 0;
+	  ulsch->beta_offset_cqi_times8 = 0;
+	  ulsch->beta_offset_ri_times8 = 0;
+	  ulsch->beta_offset_harqack_times8 = 0;
+	  ulsch->Msg3_active = 0;
+	  ulsch->Msg3_flag = 0;
+	  ulsch->Msg3_subframe = 0;
+	  ulsch->Msg3_frame = 0;
+	  ulsch->rnti = 0;
+	  ulsch->rnti_type = 0;
+	  ulsch->cyclicShift = 0;
+	  ulsch->cooperation_flag = 0;
+	  ulsch->Mlimit = 0;
+	  ulsch->max_ldpc_iterations = 0;
+	  ulsch->last_iteration_cnt = 0;
+	  ulsch->num_active_cba_groups = 0;
+	  for (i=0;i<NUM_MAX_CBA_GROUP;i++) ulsch->cba_rnti[i] = 0;
+	  for (i=0;i<NR_MAX_SLOTS_PER_FRAME;i++) ulsch->harq_process_id[i] = 0;
+
+	  for (i=0; i<NR_MAX_ULSCH_HARQ_PROCESSES; i++) {
+		  if (ulsch->harq_processes[i]){
+			  /// Nfapi ULSCH PDU
+			  //nfapi_nr_ul_config_ulsch_pdu ulsch_pdu;
+			  ulsch->harq_processes[i]->frame=0;
+			  ulsch->harq_processes[i]->subframe=0;
+			  ulsch->harq_processes[i]->round=0;
+			  ulsch->harq_processes[i]->TPC=0;
+			  ulsch->harq_processes[i]->mimo_mode=0;
+			  ulsch->harq_processes[i]->dci_alloc=0;
+			  ulsch->harq_processes[i]->rar_alloc=0;
+			  ulsch->harq_processes[i]->status=0;
+			  ulsch->harq_processes[i]->subframe_scheduling_flag=0;
+			  ulsch->harq_processes[i]->subframe_cba_scheduling_flag=0;
+			  ulsch->harq_processes[i]->phich_active=0;
+			  ulsch->harq_processes[i]->phich_ACK=0;
+			  ulsch->harq_processes[i]->previous_first_rb=0;
+			  ulsch->harq_processes[i]->handled=0;
+			  ulsch->harq_processes[i]->delta_TF=0;
+
+			  ulsch->harq_processes[i]->TBS=0;
+			  /// Pointer to the payload (38.212 V15.4.0 section 5.1)
+			  //uint8_t *b;
+			  ulsch->harq_processes[i]->B=0;
+			  /// Pointers to code blocks after code block segmentation and CRC attachment (38.212 V15.4.0 section 5.2.2)
+			  //uint8_t *c[MAX_NUM_NR_ULSCH_SEGMENTS];
+			  ulsch->harq_processes[i]->K=0;
+			  ulsch->harq_processes[i]->F=0;
+			  ulsch->harq_processes[i]->C=0;
+			  /// Pointers to code blocks after LDPC coding (38.212 V15.4.0 section 5.3.2)
+			  //int16_t *d[MAX_NUM_NR_ULSCH_SEGMENTS];
+			  /// LDPC processing buffer
+			  //t_nrLDPC_procBuf* p_nrLDPC_procBuf[MAX_NUM_NR_ULSCH_SEGMENTS];
+			  ulsch->harq_processes[i]->Z=0;
+			  /// code blocks after bit selection in rate matching for LDPC code (38.212 V15.4.0 section 5.4.2.1)
+			  //int16_t e[MAX_NUM_NR_DLSCH_SEGMENTS][3*8448];
+			  ulsch->harq_processes[i]->E=0;
+			  ulsch->harq_processes[i]->G=0;
+
+
+			  ulsch->harq_processes[i]->n_DMRS=0;
+			  ulsch->harq_processes[i]->n_DMRS2=0;
+			  ulsch->harq_processes[i]->previous_n_DMRS=0;
+
+
+			  ulsch->harq_processes[i]->cqi_crc_status=0;
+			  for (j=0;j<MAX_CQI_BYTES;j++) ulsch->harq_processes[i]->o[j]=0;
+			  ulsch->harq_processes[i]->uci_format=0;
+			  ulsch->harq_processes[i]->Or1=0;
+			  ulsch->harq_processes[i]->Or2=0;
+			  ulsch->harq_processes[i]->o_RI[0]=0; ulsch->harq_processes[i]->o_RI[1]=0;
+			  ulsch->harq_processes[i]->O_RI=0;
+			  ulsch->harq_processes[i]->o_ACK[0]=0; ulsch->harq_processes[i]->o_ACK[1]=0;
+			  ulsch->harq_processes[i]->o_ACK[2]=0; ulsch->harq_processes[i]->o_ACK[3]=0;
+			  ulsch->harq_processes[i]->O_ACK=0;
+			  ulsch->harq_processes[i]->V_UL_DAI=0;
+			  /// "q" sequences for CQI/PMI (for definition see 36-212 V8.6 2009-03, p.27)
+			  //int8_t q[MAX_CQI_PAYLOAD];
+			  ulsch->harq_processes[i]->o_RCC=0;
+			  /// coded and interleaved CQI bits
+			  //int8_t o_w[(MAX_CQI_BITS+8)*3];
+			  /// coded CQI bits
+			  //int8_t o_d[96+((MAX_CQI_BITS+8)*3)];
+			  for (j=0;j<MAX_ACK_PAYLOAD;j++) ulsch->harq_processes[i]->q_ACK[j]=0;
+			  for (j=0;j<MAX_RI_PAYLOAD;j++) ulsch->harq_processes[i]->q_RI[j]=0;
+			  /// Temporary h sequence to flag PUSCH_x/PUSCH_y symbols which are not scrambled
+			  //uint8_t h[MAX_NUM_CHANNEL_BITS];
+			  /// soft bits for each received segment ("w"-sequence)(for definition see 36-212 V8.6 2009-03, p.15)
+			  //int16_t w[MAX_NUM_ULSCH_SEGMENTS][3*(6144+64)];
+		  }
+	  }
+  }
+}
+
+uint32_t nr_ulsch_decoding(PHY_VARS_gNB *phy_vars_gNB,
+                           uint8_t UE_id,
+                           short *ulsch_llr,
+                           NR_DL_FRAME_PARMS *frame_parms,
+                           uint32_t frame,
+                           uint16_t nb_symb_sch,
+                           uint8_t nr_tti_rx,
+                           uint8_t harq_pid,
+                           uint8_t is_crnti,
+                           uint8_t llr8_flag)
+{
+
+  uint32_t A,E;
+  uint32_t G;
+  uint32_t ret,offset;
+  int32_t no_iteration_ldpc, length_dec;
+  uint32_t r,r_offset=0,Kr=8424,Kr_bytes,K_bytes_F,err_flag=0;
+  uint8_t crc_type;
+  int8_t llrProcBuf[OAI_UL_LDPC_MAX_NUM_LLR] __attribute__ ((aligned(32)));
+  
+
+  NR_gNB_ULSCH_t                       *ulsch                 = phy_vars_gNB->ulsch[UE_id][0];
+  NR_UL_gNB_HARQ_t                     *harq_process          = ulsch->harq_processes[harq_pid];
+  nfapi_nr_ul_config_ulsch_pdu_rel15_t *nfapi_ulsch_pdu_rel15 = &harq_process->ulsch_pdu.ulsch_pdu_rel15;
+  
+  t_nrLDPC_dec_params decParams;
+  t_nrLDPC_dec_params* p_decParams    = &decParams;
+  t_nrLDPC_time_stats procTime;
+  t_nrLDPC_time_stats* p_procTime     = &procTime ;
+  t_nrLDPC_procBuf** p_nrLDPC_procBuf = harq_process->p_nrLDPC_procBuf;
+
+  int16_t z [68*384];
+  int8_t l [68*384];
+  //int16_t inv_d [68*384];
+  uint8_t kc;
+  uint8_t Ilbrm        = 0;
+  uint32_t Tbslbrm     = 950984;
+  uint16_t nb_rb       = 30; //to update
+  uint8_t nb_re_dmrs   = 6;
+  uint16_t length_dmrs = 1;
+  double Coderate = 0.0;
+
+  uint32_t i,j;
+
+  __m128i *pv = (__m128i*)&z;
+  __m128i *pl = (__m128i*)&l;
+  
+  
+   if (!ulsch_llr) {
+    printf("ulsch_decoding.c: NULL ulsch_llr pointer\n");
+    return(ulsch->max_ldpc_iterations);
+  }
+
+  if (!harq_process) {
+    printf("ulsch_decoding.c: NULL harq_process pointer\n");
+    return(ulsch->max_ldpc_iterations);
+  }
+
+  if (!frame_parms) {
+    printf("ulsch_decoding.c: NULL frame_parms pointer\n");
+    return(ulsch->max_ldpc_iterations);
+  }
+
+  nb_rb = nfapi_ulsch_pdu_rel15->number_rbs;
+
+  // harq_process->trials[nfapi_ulsch_pdu_rel15->round]++;
+
+  harq_process->TBS = nr_compute_tbs(nfapi_ulsch_pdu_rel15->mcs, nb_rb, nb_symb_sch, nb_re_dmrs, length_dmrs, nfapi_ulsch_pdu_rel15->n_layers);
+
+  A   = harq_process->TBS;
+  ret = ulsch->max_ldpc_iterations;
+
+  harq_process->G = nr_get_G(nb_rb, nb_symb_sch, nb_re_dmrs, length_dmrs, nfapi_ulsch_pdu_rel15->Qm,nfapi_ulsch_pdu_rel15->n_layers);
+  G = harq_process->G;
+
+  LOG_I(PHY,"ULSCH Decoding, harq_pid %d TBS %d G %d mcs %d Nl %d nb_symb_sch %d nb_rb %d\n",harq_pid,A,G, nfapi_ulsch_pdu_rel15->mcs, nfapi_ulsch_pdu_rel15->n_layers, nb_symb_sch,nb_rb);
+
+  if (harq_process->round == 0) {
+
+    // This is a new packet, so compute quantities regarding segmentation
+    harq_process->B = A+24;
+
+    // [hna] Perform nr_segmenation with input and output set to NULL to calculate only (B, C, K, Z, F)
+    nr_segmentation(NULL,
+                    NULL,
+                    harq_process->B,
+                    &harq_process->C,
+                    &harq_process->K,
+                    &harq_process->Z, // [hna] Z is Zc
+                    &harq_process->F);
+
+    p_decParams->Z = harq_process->Z;
+
+#ifdef DEBUG_ULSCH_DECODING
+    printf("ulsch decoding nr segmentation Z %d\n", p_decParams->Z);
+    if (!frame%100)
+      printf("K %d C %d Z %d nl %d \n", harq_process->K, harq_process->C, p_decParams->Z, harq_process->Nl);
+#endif
+  }
+
+  Coderate = (float) A /(float) G;
+
+  if ((A <=292) || ((A<=3824) && (Coderate <= 0.6667)) || Coderate <= 0.25){
+    p_decParams->BG = 2;
+    if (Coderate < 0.3333) {
+      p_decParams->R = 15;
+      kc = 52;
+    }
+    else if (Coderate <0.6667) {
+      p_decParams->R = 13;
+      kc = 32;
+    }
+    else {
+      p_decParams->R = 23;
+      kc = 17;
+    }
+  } else {
+    p_decParams->BG = 1;
+    if (Coderate < 0.6667) {
+      p_decParams->R = 13;
+      kc = 68;
+    }
+    else if (Coderate <0.8889) {
+      p_decParams->R = 23;
+      kc = 35;
+    }
+    else {
+      p_decParams->R = 89;
+      kc = 27;
+    }
+  }
+
+  //printf("coderate %f kc %d \n", Coderate, kc);
+
+
+
+  p_decParams->numMaxIter = ulsch->max_ldpc_iterations;
+  p_decParams->outMode= 0;
+
+  err_flag = 0;
+  r_offset = 0;
+
+  unsigned char bw_scaling =1;
+
+  switch (frame_parms->N_RB_UL) {
+
+    case 106:
+      bw_scaling =2;
+      break;
+
+    default:
+      bw_scaling =1;
+      break;
+  }
+
+  if (harq_process->C > MAX_NUM_NR_ULSCH_SEGMENTS/bw_scaling) {
+    LOG_E(PHY,"Illegal harq_process->C %d > %d\n",harq_process->C,MAX_NUM_NR_ULSCH_SEGMENTS/bw_scaling);
+    return((1+ulsch->max_ldpc_iterations));
+  }
+#ifdef DEBUG_ULSCH_DECODING
+  printf("Segmentation: C %d, K %d\n",harq_process->C,harq_process->K);
+#endif
+
+  opp_enabled=1;
+
+  Kr = harq_process->K; // [hna] overwrites this line "Kr = p_decParams->Z*kb"
+  Kr_bytes = Kr>>3;
+
+  K_bytes_F = Kr_bytes-(harq_process->F>>3);
+
+  Tbslbrm = nr_compute_tbs(28,nb_rb,frame_parms->symbols_per_slot,0,0, nfapi_ulsch_pdu_rel15->n_layers);
+
+  for (r=0; r<harq_process->C; r++) {
+
+    E = nr_get_E(G, harq_process->C, nfapi_ulsch_pdu_rel15->Qm, nfapi_ulsch_pdu_rel15->n_layers, r);
+
+#if gNB_TIMING_TRACE
+    start_meas(ulsch_deinterleaving_stats);
+#endif
+
+    ////////////////////////////////////////////////////////////////////////////////////////////
+    ///////////////////////////////// nr_deinterleaving_ldpc ///////////////////////////////////
+    //////////////////////////////////////////////////////////////////////////////////////////
+
+    //////////////////////////// ulsch_llr =====> harq_process->e //////////////////////////////
+
+    nr_deinterleaving_ldpc(E,
+                           nfapi_ulsch_pdu_rel15->Qm,
+                           harq_process->e[r],
+                           ulsch_llr+r_offset);
+
+    //for (int i =0; i<16; i++)
+    //          printf("rx output deinterleaving w[%d]= %d r_offset %d\n", i,harq_process->w[r][i], r_offset);
+
+#if gNB_TIMING_TRACE
+    stop_meas(ulsch_deinterleaving_stats);
+#endif
+
+#if gNB_TIMING_TRACE
+    start_meas(ulsch_rate_unmatching_stats);
+#endif
+
+#ifdef DEBUG_ULSCH_DECODING
+    LOG_D(PHY,"HARQ_PID %d Rate Matching Segment %d (coded bits %d,unpunctured/repeated bits %d, TBS %d, mod_order %d, nb_rb %d, Nl %d, rv %d, round %d)...\n",
+          harq_pid,r, G,
+          Kr*3,
+          harq_process->TBS,
+          nfapi_ulsch_pdu_rel15->Qm,
+          nfapi_ulsch_pdu_rel15->number_rbs,
+          nfapi_ulsch_pdu_rel15->n_layers,
+          nfapi_ulsch_pdu_rel15->rv,
+          harq_process->round);
+#endif
+    //////////////////////////////////////////////////////////////////////////////////////////
+
+
+    //////////////////////////////////////////////////////////////////////////////////////////
+    //////////////////////////////// nr_rate_matching_ldpc_rx ////////////////////////////////
+    //////////////////////////////////////////////////////////////////////////////////////////
+
+    ///////////////////////// harq_process->e =====> harq_process->d /////////////////////////
+
+    if (nr_rate_matching_ldpc_rx(Ilbrm,
+                                 Tbslbrm,
+                                 p_decParams->BG,
+                                 p_decParams->Z,
+                                 harq_process->d[r],
+                                 harq_process->e[r],
+                                 harq_process->C,
+                                 nfapi_ulsch_pdu_rel15->rv,
+                                 (harq_process->round==0)?1:0,
+                                 E)==-1) {
+#if gNB_TIMING_TRACE
+      stop_meas(ulsch_rate_unmatching_stats);
+#endif
+      LOG_E(PHY,"ulsch_decoding.c: Problem in rate_matching\n");
+      return(ulsch->max_ldpc_iterations);
+    } else {
+#if gNB_TIMING_TRACE
+      stop_meas(ulsch_rate_unmatching_stats);
+#endif
+    }
+
+    r_offset += E;
+
+#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);
+    }
+
+    printf("decoder input(segment %d) :",r);
+    int i; 
+    for (i=0;i<(3*8*Kr_bytes)+12;i++)
+      printf("%d : %d\n",i,harq_process->d[r][i]);
+    printf("\n");
+#endif
+
+
+    //    printf("Clearing c, %p\n",harq_process->c[r]);
+    memset(harq_process->c[r],0,Kr_bytes);
+
+    //    printf("done\n");
+    if (harq_process->C == 1) {
+      crc_type = CRC24_A;
+      length_dec = harq_process->B;
+    }
+    else {
+      crc_type = CRC24_B;
+      length_dec = (harq_process->B+24*harq_process->C)/harq_process->C;
+    }
+
+    if (err_flag == 0) {
+
+#if gNB_TIMING_TRACE
+      start_meas(ulsch_turbo_decoding_stats);
+#endif
+
+      //LOG_E(PHY,"AbsSubframe %d.%d Start LDPC segment %d/%d A %d ",frame%1024,nr_tti_rx,r,harq_process->C-1, A);
+
+      
+      memset(pv,0,2*harq_process->Z*sizeof(int16_t));
+      memset((pv+K_bytes_F),127,harq_process->F*sizeof(int16_t));
+
+      for (i=((2*p_decParams->Z)>>3), j = 0; i < K_bytes_F; i++, j++) {
+        pv[i]= _mm_loadu_si128((__m128i*)(&harq_process->d[r][8*j]));
+      }
+
+      for (i=Kr_bytes,j=K_bytes_F-((2*p_decParams->Z)>>3); i < ((kc*p_decParams->Z)>>3); i++, j++) {
+        pv[i]= _mm_loadu_si128((__m128i*)(&harq_process->d[r][8*j]));
+      }
+    
+      for (i=0, j=0; j < ((kc*p_decParams->Z)>>4);  i+=2, j++) {
+        pl[j] = _mm_packs_epi16(pv[i],pv[i+1]);
+      }
+
+      //////////////////////////////////////////////////////////////////////////////////////////
+
+
+      //////////////////////////////////////////////////////////////////////////////////////////
+      ///////////////////////////////////// nrLDPC_decoder /////////////////////////////////////
+      //////////////////////////////////////////////////////////////////////////////////////////
+
+      ////////////////////////////////// pl =====> llrProcBuf //////////////////////////////////
+
+      no_iteration_ldpc = nrLDPC_decoder(p_decParams,
+                                         (int8_t*)&pl[0],
+                                         llrProcBuf,
+                                         p_nrLDPC_procBuf[r],
+                                         p_procTime);
+
+      if (check_crc((uint8_t*)llrProcBuf,length_dec,harq_process->F,crc_type)) {
+        printf("Segment %d CRC OK\n",r);
+        ret = 2;
+      } else {
+        printf("CRC NOK\n");
+        ret = 1+ulsch->max_ldpc_iterations;
+      }
+    
+      nb_total_decod++;
+      if (no_iteration_ldpc > ulsch->max_ldpc_iterations){
+        nb_error_decod++;
+      }
+
+      ret=no_iteration_ldpc;
+
+      for (int m=0; m < Kr>>3; m ++) {
+        harq_process->c[r][m]= (uint8_t) llrProcBuf[m];
+      }
+
+#ifdef DEBUG_ULSCH_DECODING
+      //printf("output decoder %d %d %d %d %d \n", harq_process->c[r][0], harq_process->c[r][1], harq_process->c[r][2],harq_process->c[r][3], harq_process->c[r][4]);
+      for (int k=0;k<A>>3;k++)
+       printf("output decoder [%d] =  0x%02x \n", k, harq_process->c[r][k]);
+      printf("no_iterations_ldpc %d (ret %d)\n",no_iteration_ldpc,ret);
+      //write_output("dec_output.m","dec0",harq_process->c[0],Kr_bytes,1,4);
+#endif
+
+#if gNB_TIMING_TRACE
+      stop_meas(ulsch_turbo_decoding_stats);
+#endif
+    }
+
+    if ((err_flag == 0) && (ret>=(1+ulsch->max_ldpc_iterations))) {
+      // a Code segment is in error so break;
+      LOG_D(PHY,"AbsSubframe %d.%d CRC failed, segment %d/%d \n",frame%1024,nr_tti_rx,r,harq_process->C-1);
+      err_flag = 1;
+    }
+    //////////////////////////////////////////////////////////////////////////////////////////
+  }
+
+  int32_t frame_rx_prev = frame;
+  int32_t tti_rx_prev = nr_tti_rx - 1;
+  if (tti_rx_prev < 0) {
+    frame_rx_prev--;
+    tti_rx_prev += 10*frame_parms->ttis_per_subframe;
+  }
+  frame_rx_prev = frame_rx_prev%1024;
+
+  if (err_flag == 1) {
+
+#if gNB_DEBUG_TRACE
+    LOG_I(PHY,"[gNB %d] ULSCH: Setting NAK for SFN/SF %d/%d (pid %d, status %d, round %d, TBS %d, mcs %d) Kr %d r %d harq_process->round %d\n",
+          phy_vars_gNB->Mod_id, frame, nr_tti_rx, harq_pid,harq_process->status, harq_process->round,harq_process->TBS,harq_process->mcs,Kr,r,harq_process->round);
+#endif
+
+    // harq_process->harq_ack.ack = 0;
+    // harq_process->harq_ack.harq_id = harq_pid;
+    // harq_process->harq_ack.send_harq_status = 1;
+    // harq_process->errors[harq_process->round]++;
+    harq_process->round++;
+
+    if (harq_process->round >= ulsch->Mlimit) {
+      harq_process->status = SCH_IDLE;
+      harq_process->round  = 0;
+      harq_process->handled  = 0;
+      ulsch->harq_mask &= ~(1 << harq_pid);
+    }
+
+    if(is_crnti) {
+      LOG_D(PHY,"[gNB %d] ULSCH: Setting NACK for nr_tti_rx %d (pid %d, pid status %d, round %d/Max %d, TBS %d)\n",
+            phy_vars_gNB->Mod_id,nr_tti_rx,harq_pid,harq_process->status,harq_process->round,ulsch->Mlimit,harq_process->TBS);
+    }
+
+    harq_process->handled  = 1;
+    return((1+ulsch->max_ldpc_iterations));
+
+  } else {
+
+#if gNB_DEBUG_TRACE
+    LOG_I(PHY,"[gNB %d] ULSCH: Setting ACK for nr_tti_rx %d TBS %d mcs %d nb_rb %d harq_process->round %d\n",
+          phy_vars_gNB->Mod_id,nr_tti_rx,harq_process->TBS,harq_process->mcs,harq_process->nb_rb, harq_process->round);
+#endif
+
+    harq_process->status = SCH_IDLE;
+    harq_process->round  = 0;
+    // harq_process->handled  = 0;
+    ulsch->harq_mask  &= ~(1 << harq_pid);
+    // harq_process->harq_ack.ack = 1;
+    // harq_process->harq_ack.harq_id = harq_pid;
+    // harq_process->harq_ack.send_harq_status = 1;
+
+    if(is_crnti)
+    {
+      LOG_D(PHY,"[gNB %d] ULSCH: Setting ACK for nr_tti_rx %d (pid %d, round %d, TBS %d)\n",phy_vars_gNB->Mod_id,nr_tti_rx,harq_pid,harq_process->round,harq_process->TBS);
+    }
+  }
+
+  // Reassembly of Transport block here
+  offset = 0;
+  Kr = harq_process->K;
+  Kr_bytes = Kr>>3;
+
+  for (r=0; r<harq_process->C; r++) {
+
+    memcpy(harq_process->b+offset,
+           harq_process->c[r],
+           Kr_bytes- - (harq_process->F>>3) -((harq_process->C>1)?3:0));
+
+    offset += (Kr_bytes - (harq_process->F>>3) - ((harq_process->C>1)?3:0));
+
+#ifdef DEBUG_ULSCH_DECODING
+    printf("Segment %d : Kr= %d bytes\n",r,Kr_bytes);
+    printf("copied %d bytes to b sequence (harq_pid %d)\n",
+           (Kr_bytes - (harq_process->F>>3)-((harq_process->C>1)?3:0)),harq_pid);
+    printf("b[0] = %x,c[%d] = %x\n",
+           harq_process->b[offset],
+           harq_process->F>>3,
+           harq_process->c[r]);
+#endif
+
+  }
+
+  ulsch->last_iteration_cnt = ret;
+
+  return(ret);
+}
diff --git a/openair1/PHY/NR_UE_ESTIMATION/nr_adjust_synch_ue.c b/openair1/PHY/NR_UE_ESTIMATION/nr_adjust_synch_ue.c
index f1a3ef42ab..24ca3d1ad6 100644
--- a/openair1/PHY/NR_UE_ESTIMATION/nr_adjust_synch_ue.c
+++ b/openair1/PHY/NR_UE_ESTIMATION/nr_adjust_synch_ue.c
@@ -52,9 +52,7 @@ void nr_adjust_synch_ue(NR_DL_FRAME_PARMS *frame_parms,
 
   ncoef = 32767 - coef;
 
-//#ifdef DEBUG_PHY
-  LOG_D(PHY,"AbsSubframe %d.%d: rx_offset (before) = %d\n",ue->proc.proc_rxtx[0].frame_rx%1024,subframe,ue->rx_offset);
-//#endif //DEBUG_PHY
+  LOG_D(PHY,"AbsSubframe %d: rx_offset (before) = %d\n",subframe,ue->rx_offset);
 
 
   // we only use channel estimates from tx antenna 0 here
@@ -62,8 +60,8 @@ void nr_adjust_synch_ue(NR_DL_FRAME_PARMS *frame_parms,
     temp = 0;
 
     for (aa=0; aa<frame_parms->nb_antennas_rx; aa++) {
-      Re = ((int16_t*)ue->common_vars.common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].dl_ch_estimates_time[eNB_id][aa])[(i<<1)];
-      Im = ((int16_t*)ue->common_vars.common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].dl_ch_estimates_time[eNB_id][aa])[1+(i<<1)];
+      Re = ((int16_t*)ue->pdcch_vars[ue->current_thread_id[subframe]][eNB_id]->dl_ch_estimates_time[aa])[(i<<1)];
+      Im = ((int16_t*)ue->pdcch_vars[ue->current_thread_id[subframe]][eNB_id]->dl_ch_estimates_time[aa])[1+(i<<1)];
       temp += (Re*Re/2) + (Im*Im/2);
     }
 
@@ -122,8 +120,7 @@ void nr_adjust_synch_ue(NR_DL_FRAME_PARMS *frame_parms,
 
 
       #ifdef DEBUG_PHY
-      LOG_D(PHY,"AbsSubframe %d.%d: ThreadId %d diff =%i rx_offset (final) = %i : clear %d,max_pos = %d,max_pos_fil = %d (peak %d) max_val %d target_pos %d \n",
-              ue->proc.proc_rxtx[ue->current_thread_id[subframe]].frame_rx,
+      LOG_D(PHY,"AbsSubframe %d: ThreadId %d diff =%i rx_offset (final) = %i : clear %d,max_pos = %d,max_pos_fil = %d (peak %d) max_val %d target_pos %d \n",
               subframe,
               ue->current_thread_id[subframe],
               diff,
diff --git a/openair1/PHY/NR_UE_ESTIMATION/nr_dl_channel_estimation.c b/openair1/PHY/NR_UE_ESTIMATION/nr_dl_channel_estimation.c
index a90450b0a5..0ab83712d8 100644
--- a/openair1/PHY/NR_UE_ESTIMATION/nr_dl_channel_estimation.c
+++ b/openair1/PHY/NR_UE_ESTIMATION/nr_dl_channel_estimation.c
@@ -22,55 +22,42 @@
 
 #include <string.h>
 
-//#include "defs.h"
-//#include "SCHED/defs.h"
-#include "PHY/defs_nr_UE.h"
+#include "nr_estimation.h"
 #include "PHY/NR_REFSIG/refsig_defs_ue.h"
 #include "filt16a_32.h"
-#include "T.h"
+
 //#define DEBUG_PDSCH
 //#define DEBUG_PDCCH
 
 
-int nr_pbch_channel_estimation(PHY_VARS_NR_UE *ue,
-			       uint8_t eNB_id,
+int nr_pbch_dmrs_correlation(PHY_VARS_NR_UE *ue,
 			       uint8_t eNB_offset,
 			       unsigned char Ns,
-			       unsigned char l,
-			       unsigned char symbol)
+			       unsigned char symbol,
+                               int dmrss,
+			       NR_UE_SSB *current_ssb)
 {
   int pilot[200] __attribute__((aligned(16)));
   unsigned char aarx;
   unsigned short k;
   unsigned int pilot_cnt;
-  int16_t ch[2],*pil,*rxF,*dl_ch,*fl,*fm,*fr;
-  int ch_offset,symbol_offset;
-  int dmrss;
+  int16_t ch[2],*pil,*rxF;
+  int symbol_offset;
 
-  //uint16_t Nid_cell = (eNB_offset == 0) ? ue->frame_parms.Nid_cell : ue->measurements.adj_cell_id[eNB_offset-1];
 
-  uint8_t nushift, ssb_index=0, n_hf=0;
-  int **dl_ch_estimates  =ue->common_vars.common_vars_rx_data_per_thread[ue->current_thread_id[Ns>>1]].dl_ch_estimates[eNB_offset];
-  int **rxdataF=ue->common_vars.common_vars_rx_data_per_thread[ue->current_thread_id[Ns>>1]].rxdataF;
+  uint8_t nushift;
+  uint8_t ssb_index=current_ssb->i_ssb;
+  uint8_t n_hf=current_ssb->n_hf;
+  int **rxdataF=ue->common_vars.common_vars_rx_data_per_thread[ue->current_thread_id[Ns]].rxdataF;
 
   nushift =  ue->frame_parms.Nid_cell%4;
   ue->frame_parms.nushift = nushift;
-
   unsigned int  ssb_offset = ue->frame_parms.first_carrier_offset + ue->frame_parms.ssb_start_subcarrier;
   if (ssb_offset>= ue->frame_parms.ofdm_symbol_size) ssb_offset-=ue->frame_parms.ofdm_symbol_size;
 
-  if (ue->is_synchronized ==0 ) dmrss = symbol-1;
-  else dmrss = symbol-5;
-
-  if (ue->high_speed_flag == 0) // use second channel estimate position for temporary storage
-    ch_offset     = ue->frame_parms.ofdm_symbol_size ;
-  else
-    ch_offset     = ue->frame_parms.ofdm_symbol_size*symbol;
-
-  AssertFatal((symbol > 0 && symbol < 4 && ue->is_synchronized == 0) || 
-	      (symbol > 4 && symbol < 8 && ue->is_synchronized == 1),
-	      "symbol %d is illegal for PBCH DM-RS (is_synchronized %d)\n",
-	      symbol,ue->is_synchronized);
+  AssertFatal(dmrss >= 0 && dmrss < 3,
+	      "symbol %d is illegal for PBCH DM-RS \n",
+	      dmrss);
 
   symbol_offset = ue->frame_parms.ofdm_symbol_size*symbol;
 
@@ -78,8 +65,175 @@ int nr_pbch_channel_estimation(PHY_VARS_NR_UE *ue,
   k = nushift;
 
 #ifdef DEBUG_CH
-  printf("PBCH Channel Estimation : ThreadId %d, eNB_offset %d ch_offset %d, OFDM size %d, Ncp=%d, l=%d, Ns=%d, k=%d symbol %d\n",ue->current_thread_id[Ns>>1], eNB_offset,ch_offset,ue->frame_parms.ofdm_symbol_size,
-         ue->frame_parms.Ncp,l,Ns,k, symbol);
+  printf("PBCH DMRS Correlation : ThreadId %d, eNB_offset %d , OFDM size %d, Ncp=%d, Ns=%d, k=%d symbol %d\n",ue->current_thread_id[Ns>>1], eNB_offset,ue->frame_parms.ofdm_symbol_size,
+         ue->frame_parms.Ncp,Ns,k, symbol);
+#endif
+
+  // generate pilot
+  nr_pbch_dmrs_rx(dmrss,ue->nr_gold_pbch[n_hf][ssb_index], &pilot[0]);
+
+  int re_offset = ssb_offset;
+  for (aarx=0; aarx<ue->frame_parms.nb_antennas_rx; aarx++) {
+
+    pil   = (int16_t *)&pilot[0];
+    rxF   = (int16_t *)&rxdataF[aarx][(symbol_offset+k+re_offset)];
+
+#ifdef DEBUG_CH
+    printf("pbch ch est pilot addr %p RB_DL %d\n",&pilot[0], ue->frame_parms.N_RB_DL);
+    printf("k %d, first_carrier %d\n",k,ue->frame_parms.first_carrier_offset);
+    printf("rxF addr %p\n", rxF);
+#endif
+    //if ((ue->frame_parms.N_RB_DL&1)==0) {
+
+    // Treat first 2 pilots specially (left edge)
+    ch[0] = (int16_t)(((int32_t)pil[0]*rxF[0] - (int32_t)pil[1]*rxF[1])>>15);
+    ch[1] = (int16_t)(((int32_t)pil[0]*rxF[1] + (int32_t)pil[1]*rxF[0])>>15);
+
+    current_ssb->c_re +=ch[0];
+    current_ssb->c_im +=ch[1];
+
+#ifdef DEBUG_CH
+    printf("ch 0 %d\n",((int32_t)pil[0]*rxF[0] - (int32_t)pil[1]*rxF[1]));
+    printf("pilot 0 : rxF - > (%d,%d) addr %p  ch -> (%d,%d), pil -> (%d,%d) \n",rxF[0],rxF[1],&rxF[0],ch[0],ch[1],pil[0],pil[1]);
+#endif
+
+    pil+=2;
+    re_offset = (re_offset+4)&(ue->frame_parms.ofdm_symbol_size-1);
+    rxF   = (int16_t *)&rxdataF[aarx][(symbol_offset+k+re_offset)];
+
+
+    ch[0] = (int16_t)(((int32_t)pil[0]*rxF[0] - (int32_t)pil[1]*rxF[1])>>15);
+    ch[1] = (int16_t)(((int32_t)pil[0]*rxF[1] + (int32_t)pil[1]*rxF[0])>>15);
+
+    current_ssb->c_re +=ch[0];
+    current_ssb->c_im +=ch[1];
+
+#ifdef DEBUG_CH
+    printf("pilot 1 : rxF - > (%d,%d) ch -> (%d,%d), pil -> (%d,%d) \n",rxF[0],rxF[1],ch[0],ch[1],pil[0],pil[1]);
+#endif
+
+    pil+=2;
+    re_offset = (re_offset+4)&(ue->frame_parms.ofdm_symbol_size-1);
+    rxF   = (int16_t *)&rxdataF[aarx][(symbol_offset+k+re_offset)];
+
+    current_ssb->c_re +=ch[0];
+    current_ssb->c_im +=ch[1];
+
+#ifdef DEBUG_CH
+    printf("pilot 2 : rxF - > (%d,%d) ch -> (%d,%d), pil -> (%d,%d) \n",rxF[0],rxF[1],ch[0],ch[1],pil[0],pil[1]);
+#endif
+
+    pil+=2;
+    re_offset = (re_offset+4)&(ue->frame_parms.ofdm_symbol_size-1);
+    rxF   = (int16_t *)&rxdataF[aarx][(symbol_offset+k+re_offset)];
+
+    for (pilot_cnt=3; pilot_cnt<(3*20); pilot_cnt+=3) {
+
+      //	if (pilot_cnt == 30)
+      //	  rxF   = (int16_t *)&rxdataF[aarx][(symbol_offset+k)];
+
+      // in 2nd symbol, skip middle  REs (48 with DMRS,  144 for SSS, and another 48 with DMRS) 
+      if (dmrss == 1 && pilot_cnt == 12) {
+	pilot_cnt=48;
+	re_offset = (re_offset+144)&(ue->frame_parms.ofdm_symbol_size-1);
+	rxF   = (int16_t *)&rxdataF[aarx][(symbol_offset+k+re_offset)];
+      }
+      ch[0] = (int16_t)(((int32_t)pil[0]*rxF[0] - (int32_t)pil[1]*rxF[1])>>15);
+      ch[1] = (int16_t)(((int32_t)pil[0]*rxF[1] + (int32_t)pil[1]*rxF[0])>>15);
+      
+      current_ssb->c_re +=ch[0];
+      current_ssb->c_im +=ch[1];
+
+#ifdef DEBUG_CH
+      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]);
+#endif
+
+      pil+=2;
+      re_offset = (re_offset+4)&(ue->frame_parms.ofdm_symbol_size-1);
+      rxF   = (int16_t *)&rxdataF[aarx][(symbol_offset+k+re_offset)];
+        
+  
+      ch[0] = (int16_t)(((int32_t)pil[0]*rxF[0] - (int32_t)pil[1]*rxF[1])>>15);
+      ch[1] = (int16_t)(((int32_t)pil[0]*rxF[1] + (int32_t)pil[1]*rxF[0])>>15);
+
+      current_ssb->c_re +=ch[0];
+      current_ssb->c_im +=ch[1];
+
+#ifdef DEBUG_CH
+      printf("pilot %d : 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]);
+#endif
+      pil+=2;
+      re_offset = (re_offset+4)&(ue->frame_parms.ofdm_symbol_size-1);
+      rxF   = (int16_t *)&rxdataF[aarx][(symbol_offset+k+re_offset)];
+        
+
+      ch[0] = (int16_t)(((int32_t)pil[0]*rxF[0] - (int32_t)pil[1]*rxF[1])>>15);
+      ch[1] = (int16_t)(((int32_t)pil[0]*rxF[1] + (int32_t)pil[1]*rxF[0])>>15);
+
+      current_ssb->c_re +=ch[0];
+      current_ssb->c_im +=ch[1];
+
+#ifdef DEBUG_CH
+      printf("pilot %d : 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]);
+#endif
+
+      pil+=2;
+      re_offset = (re_offset+4)&(ue->frame_parms.ofdm_symbol_size-1);
+      rxF   = (int16_t *)&rxdataF[aarx][(symbol_offset+k+re_offset)];
+
+    }
+
+
+    //}
+
+  }
+  return(0);
+}
+
+
+int nr_pbch_channel_estimation(PHY_VARS_NR_UE *ue,
+			       uint8_t eNB_offset,
+			       unsigned char Ns,
+			       unsigned char symbol,
+			       int dmrss,
+			       uint8_t ssb_index,
+			       uint8_t n_hf)
+{
+  int pilot[200] __attribute__((aligned(16)));
+  unsigned char aarx;
+  unsigned short k;
+  unsigned int pilot_cnt;
+  int16_t ch[2],*pil,*rxF,*dl_ch,*fl,*fm,*fr;
+  int ch_offset,symbol_offset;
+
+  //uint16_t Nid_cell = (eNB_offset == 0) ? ue->frame_parms.Nid_cell : ue->measurements.adj_cell_id[eNB_offset-1];
+
+  uint8_t nushift;
+  int **dl_ch_estimates  =ue->pbch_vars[eNB_offset]->dl_ch_estimates;
+  int **rxdataF=ue->common_vars.common_vars_rx_data_per_thread[ue->current_thread_id[Ns]].rxdataF;
+
+  nushift =  ue->frame_parms.Nid_cell%4;
+  ue->frame_parms.nushift = nushift;
+  unsigned int  ssb_offset = ue->frame_parms.first_carrier_offset + ue->frame_parms.ssb_start_subcarrier;
+  if (ssb_offset>= ue->frame_parms.ofdm_symbol_size) ssb_offset-=ue->frame_parms.ofdm_symbol_size;
+
+  if (ue->high_speed_flag == 0) // use second channel estimate position for temporary storage
+    ch_offset     = ue->frame_parms.ofdm_symbol_size ;
+  else
+    ch_offset     = ue->frame_parms.ofdm_symbol_size*symbol;
+
+  AssertFatal(dmrss >= 0 && dmrss < 3,
+	      "symbol %d is illegal for PBCH DM-RS \n",
+	      dmrss);
+
+  symbol_offset = ue->frame_parms.ofdm_symbol_size*symbol;
+
+
+  k = nushift;
+
+#ifdef DEBUG_CH
+  printf("PBCH Channel Estimation : ThreadId %d, eNB_offset %d ch_offset %d, OFDM size %d, Ncp=%d, Ns=%d, k=%d symbol %d\n",ue->current_thread_id[Ns], eNB_offset,ch_offset,ue->frame_parms.ofdm_symbol_size,
+         ue->frame_parms.Ncp,Ns,k, symbol);
 #endif
 
   switch (k) {
@@ -122,7 +276,7 @@ int nr_pbch_channel_estimation(PHY_VARS_NR_UE *ue,
     pil   = (int16_t *)&pilot[0];
     rxF   = (int16_t *)&rxdataF[aarx][(symbol_offset+k+re_offset)];
     dl_ch = (int16_t *)&dl_ch_estimates[aarx][ch_offset];
- 
+
     memset(dl_ch,0,4*(ue->frame_parms.ofdm_symbol_size));
     if (ue->high_speed_flag==0) // multiply previous channel estimate by ch_est_alpha
       multadd_complex_vector_real_scalar(dl_ch-(ue->frame_parms.ofdm_symbol_size<<1),
@@ -139,6 +293,7 @@ int nr_pbch_channel_estimation(PHY_VARS_NR_UE *ue,
     // Treat first 2 pilots specially (left edge)
     ch[0] = (int16_t)(((int32_t)pil[0]*rxF[0] - (int32_t)pil[1]*rxF[1])>>15);
     ch[1] = (int16_t)(((int32_t)pil[0]*rxF[1] + (int32_t)pil[1]*rxF[0])>>15);
+
 #ifdef DEBUG_CH
     printf("ch 0 %d\n",((int32_t)pil[0]*rxF[0] - (int32_t)pil[1]*rxF[1]));
     printf("pilot 0 : rxF - > (%d,%d) addr %p  ch -> (%d,%d), pil -> (%d,%d) \n",rxF[0],rxF[1],&rxF[0],ch[0],ch[1],pil[0],pil[1]);
@@ -156,6 +311,8 @@ int nr_pbch_channel_estimation(PHY_VARS_NR_UE *ue,
 
     ch[0] = (int16_t)(((int32_t)pil[0]*rxF[0] - (int32_t)pil[1]*rxF[1])>>15);
     ch[1] = (int16_t)(((int32_t)pil[0]*rxF[1] + (int32_t)pil[1]*rxF[0])>>15);
+
+
 #ifdef DEBUG_CH
     printf("pilot 1 : rxF - > (%d,%d) ch -> (%d,%d), pil -> (%d,%d) \n",rxF[0],rxF[1],ch[0],ch[1],pil[0],pil[1]);
 #endif
@@ -167,9 +324,6 @@ int nr_pbch_channel_estimation(PHY_VARS_NR_UE *ue,
     re_offset = (re_offset+4)&(ue->frame_parms.ofdm_symbol_size-1);
     rxF   = (int16_t *)&rxdataF[aarx][(symbol_offset+k+re_offset)];
 
-    ch[0] = (int16_t)(((int32_t)pil[0]*rxF[0] - (int32_t)pil[1]*rxF[1])>>15);
-    ch[1] = (int16_t)(((int32_t)pil[0]*rxF[1] + (int32_t)pil[1]*rxF[0])>>15);
-
 #ifdef DEBUG_CH
     printf("pilot 2 : rxF - > (%d,%d) ch -> (%d,%d), pil -> (%d,%d) \n",rxF[0],rxF[1],ch[0],ch[1],pil[0],pil[1]);
 #endif
@@ -197,6 +351,7 @@ int nr_pbch_channel_estimation(PHY_VARS_NR_UE *ue,
       }
       ch[0] = (int16_t)(((int32_t)pil[0]*rxF[0] - (int32_t)pil[1]*rxF[1])>>15);
       ch[1] = (int16_t)(((int32_t)pil[0]*rxF[1] + (int32_t)pil[1]*rxF[0])>>15);
+
 #ifdef DEBUG_CH
       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]);
 #endif
@@ -215,6 +370,7 @@ int nr_pbch_channel_estimation(PHY_VARS_NR_UE *ue,
   
       ch[0] = (int16_t)(((int32_t)pil[0]*rxF[0] - (int32_t)pil[1]*rxF[1])>>15);
       ch[1] = (int16_t)(((int32_t)pil[0]*rxF[1] + (int32_t)pil[1]*rxF[0])>>15);
+
 #ifdef DEBUG_CH
       printf("pilot %d : 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]);
 #endif
@@ -249,15 +405,12 @@ int nr_pbch_channel_estimation(PHY_VARS_NR_UE *ue,
     //}
 
   }
-
   return(0);
 }
 
 int nr_pdcch_channel_estimation(PHY_VARS_NR_UE *ue,
-				uint8_t eNB_id,
 				uint8_t eNB_offset,
 				unsigned char Ns,
-				unsigned char l,
 				unsigned char symbol,
 				unsigned short coreset_start_subcarrier,
 				unsigned short nb_rb_coreset)
@@ -272,7 +425,7 @@ int nr_pdcch_channel_estimation(PHY_VARS_NR_UE *ue,
   //uint16_t Nid_cell = (eNB_offset == 0) ? ue->frame_parms.Nid_cell : ue->measurements.adj_cell_id[eNB_offset-1];
 
   uint8_t nushift;
-  int **dl_ch_estimates  =ue->common_vars.common_vars_rx_data_per_thread[ue->current_thread_id[Ns]].dl_ch_estimates[eNB_offset];
+  int **dl_ch_estimates  =ue->pdcch_vars[ue->current_thread_id[Ns]][eNB_offset]->dl_ch_estimates;
   int **rxdataF=ue->common_vars.common_vars_rx_data_per_thread[ue->current_thread_id[Ns]].rxdataF;
 
   nushift = 1;
@@ -460,16 +613,16 @@ int nr_pdcch_channel_estimation(PHY_VARS_NR_UE *ue,
     break;
   }
 
-  if( (Ns== 1) && (l == 0))
+  if( (Ns== 1) && (symbol == 0))
   {
       // do ifft of channel estimate
       for (aarx=0; aarx<ue->frame_parms.nb_antennas_rx; aarx++)
           for (p=0; p<ue->frame_parms.nb_antenna_ports_eNB; p++) {
-              if (ue->common_vars.common_vars_rx_data_per_thread[ue->current_thread_id[Ns]].dl_ch_estimates[eNB_offset][(p<<1)+aarx])
+              if (ue->pdcch_vars[ue->current_thread_id[Ns]][eNB_offset]->dl_ch_estimates[(p<<1)+aarx])
               {
-                  LOG_D(PHY,"Channel Impulse Computation Slot %d ThreadId %d Symbol %d \n", Ns, ue->current_thread_id[Ns], l);
-                  idft((int16_t*) &ue->common_vars.common_vars_rx_data_per_thread[ue->current_thread_id[Ns]].dl_ch_estimates[eNB_offset][(p<<1)+aarx][0],
-                          (int16_t*) ue->common_vars.common_vars_rx_data_per_thread[ue->current_thread_id[Ns]].dl_ch_estimates_time[eNB_offset][(p<<1)+aarx],1);
+		LOG_D(PHY,"Channel Impulse Computation Slot %d ThreadId %d Symbol %d \n", Ns, ue->current_thread_id[Ns], symbol);
+		idft((int16_t*) &ue->pdcch_vars[ue->current_thread_id[Ns]][eNB_offset]->dl_ch_estimates[(p<<1)+aarx][0],
+		     (int16_t*) ue->pdcch_vars[ue->current_thread_id[Ns]][eNB_offset]->dl_ch_estimates_time[(p<<1)+aarx],1);
               }
           }
   }
@@ -478,14 +631,12 @@ int nr_pdcch_channel_estimation(PHY_VARS_NR_UE *ue,
 }
 
 int nr_pdsch_channel_estimation(PHY_VARS_NR_UE *ue,
-                              uint8_t eNB_id,
-                              uint8_t eNB_offset,
-                              unsigned char Ns,
-                              unsigned short p,
-                              unsigned char l,
-                              unsigned char symbol,
-							  unsigned short bwp_start_subcarrier,
-							  unsigned short nb_rb_pdsch)
+				uint8_t eNB_offset,
+				unsigned char Ns,
+				unsigned short p,
+				unsigned char symbol,
+				unsigned short bwp_start_subcarrier,
+				unsigned short nb_rb_pdsch)
 {
   int pilot[1320] __attribute__((aligned(16)));
   unsigned char aarx;
@@ -497,7 +648,7 @@ int nr_pdsch_channel_estimation(PHY_VARS_NR_UE *ue,
   //uint16_t Nid_cell = (eNB_offset == 0) ? ue->frame_parms.Nid_cell : ue->measurements.adj_cell_id[eNB_offset-1];
 
   uint8_t nushift;
-  int **dl_ch_estimates  =ue->common_vars.common_vars_rx_data_per_thread[ue->current_thread_id[Ns]].dl_ch_estimates[eNB_offset];
+  int **dl_ch_estimates  =ue->pdsch_vars[ue->current_thread_id[Ns]][eNB_offset]->dl_ch_estimates;
   int **rxdataF=ue->common_vars.common_vars_rx_data_per_thread[ue->current_thread_id[Ns]].rxdataF;
 
   nushift = (p>>1)&1;
diff --git a/openair1/PHY/NR_UE_ESTIMATION/nr_estimation.h b/openair1/PHY/NR_UE_ESTIMATION/nr_estimation.h
index ae4295a99b..1a4250028e 100644
--- a/openair1/PHY/NR_UE_ESTIMATION/nr_estimation.h
+++ b/openair1/PHY/NR_UE_ESTIMATION/nr_estimation.h
@@ -43,30 +43,35 @@
 \param symbol symbol within frame
 */
 int nr_pdcch_channel_estimation(PHY_VARS_NR_UE *ue,
-				uint8_t eNB_id,
 				uint8_t eNB_offset,
 				unsigned char Ns,
-				unsigned char l,
 				unsigned char symbol,
 				unsigned short coreset_start_subcarrier,
 				unsigned short nb_rb_coreset);
 
+int nr_pbch_dmrs_correlation(PHY_VARS_NR_UE *ue,
+                             uint8_t eNB_offset,
+                             unsigned char Ns,
+                             unsigned char symbol,
+			     int dmrss,
+			     NR_UE_SSB *current_ssb);
+
 int nr_pbch_channel_estimation(PHY_VARS_NR_UE *ue,
-                              uint8_t eNB_id,
-                              uint8_t eNB_offset,
-                              unsigned char Ns,
-                              unsigned char l,
-                              unsigned char symbol);
+                               uint8_t eNB_offset,
+                               unsigned char Ns,
+                               unsigned char symbol,
+			       int dmrss,
+			       uint8_t ssb_index,
+			       uint8_t n_hf);
 
 int nr_pdsch_channel_estimation(PHY_VARS_NR_UE *ue,
-                              uint8_t eNB_id,
                               uint8_t eNB_offset,
                               unsigned char Ns,
                               unsigned short p,
-                              unsigned char l,
                               unsigned char symbol,
-							  unsigned short bwp_start_subcarrier,
-							  unsigned short nb_rb_pdsch);
+			      unsigned short bwp_start_subcarrier,
+			      unsigned short nb_rb_pdsch);
+
 							  
 void nr_adjust_synch_ue(NR_DL_FRAME_PARMS *frame_parms,
                       PHY_VARS_NR_UE *ue,
diff --git a/openair1/PHY/NR_UE_TRANSPORT/dci_nr.c b/openair1/PHY/NR_UE_TRANSPORT/dci_nr.c
index 6f2f5bcf2d..9b309983b1 100644
--- a/openair1/PHY/NR_UE_TRANSPORT/dci_nr.c
+++ b/openair1/PHY/NR_UE_TRANSPORT/dci_nr.c
@@ -332,7 +332,9 @@ void nr_pdcch_extract_rbs_single(int32_t **rxdataF,
   //uint8_t rb_count_bit;
   uint8_t i, j, aarx, bitcnt_coreset_freq_dom=0;
   int32_t *dl_ch0, *dl_ch0_ext, *rxF, *rxF_ext;
+#ifdef NR_PDCCH_DCI_DEBUG
   int nushiftmod3 = frame_parms->nushift % 3;
+#endif
   uint8_t symbol_mod;
   symbol_mod = (symbol >= (7 - frame_parms->Ncp)) ? symbol - (7 - frame_parms->Ncp) : symbol;
   c_rb = n_BWP_start; // c_rb is the common resource block: RB within the BWP
@@ -809,8 +811,6 @@ int32_t nr_rx_pdcch(PHY_VARS_NR_UE *ue,
   // indicates the number of active CORESETs for the current BWP to decode PDCCH: max is 3 (this variable is not useful here, to be removed)
   //uint8_t  coreset_nbr_act;
   // indicates the number of REG contained in the PDCCH (number of RBs * number of symbols, in CORESET)
-  uint8_t  coreset_nbr_reg;
-  uint32_t coreset_C;
   uint32_t coreset_nbr_rb = 0;
   // for (int j=0; j < coreset_nbr_act; j++) {
   // for each active CORESET (max number of active CORESETs in a BWP is 3),
@@ -829,9 +829,9 @@ int32_t nr_rx_pdcch(PHY_VARS_NR_UE *ue,
 #ifdef NR_PDCCH_DCI_DEBUG
   printf("\t<-NR_PDCCH_DCI_DEBUG (nr_rx_pdcch)-> coreset_freq_dom=(%ld,%lx), coreset_nbr_rb=%d\n", coreset_freq_dom,coreset_freq_dom,coreset_nbr_rb);
 #endif
-  coreset_nbr_reg = coreset_time_dur * coreset_nbr_rb;
-  coreset_C = (uint32_t)(coreset_nbr_reg / (reg_bundle_size_L * coreset_interleaver_size_R));
 #ifdef NR_PDCCH_DCI_DEBUG
+  uint8_t  coreset_nbr_reg = coreset_time_dur * coreset_nbr_rb;
+  uint32_t coreset_C = (uint32_t)(coreset_nbr_reg / (reg_bundle_size_L * coreset_interleaver_size_R));
   printf("\t<-NR_PDCCH_DCI_DEBUG (nr_rx_pdcch)-> coreset_nbr_rb=%d, coreset_nbr_reg=%d, coreset_C=(%d/(%d*%d))=%d\n",
          coreset_nbr_rb, coreset_nbr_reg, coreset_nbr_reg, reg_bundle_size_L,coreset_interleaver_size_R, coreset_C);
 #endif
@@ -843,7 +843,7 @@ int32_t nr_rx_pdcch(PHY_VARS_NR_UE *ue,
     printf("\t<-NR_PDCCH_DCI_DEBUG (nr_rx_pdcch)-> in nr_pdcch_extract_rbs_single(rxdataF -> rxdataF_ext || dl_ch_estimates -> dl_ch_estimates_ext)\n");
 #endif
     nr_pdcch_extract_rbs_single(common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[nr_tti_rx]].rxdataF,
-                                common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[nr_tti_rx]].dl_ch_estimates[eNB_id],
+                                pdcch_vars[eNB_id]->dl_ch_estimates,
                                 pdcch_vars[eNB_id]->rxdataF_ext,
                                 pdcch_vars[eNB_id]->dl_ch_estimates_ext,
                                 s,
@@ -1418,27 +1418,25 @@ void nr_dci_decoding_procedure0(int s,
         *format_found=_format_2_3_found;
       }
 
-      //#ifdef NR_PDCCH_DCI_DEBUG
+
+#ifdef NR_PDCCH_DCI_DEBUG
       printf ("\t\t<-NR_PDCCH_DCI_DEBUG (nr_dci_decoding_procedure0)-> format_found=%d\n",*format_found);
       printf ("\t\t<-NR_PDCCH_DCI_DEBUG (nr_dci_decoding_procedure0)-> crc_scrambled=%d\n",*crc_scrambled);
+#endif
 
-      //#endif
       if (*format_found!=255) {
         dci_alloc[*dci_cnt].dci_length = sizeof_bits;
         dci_alloc[*dci_cnt].rnti = crc;
         dci_alloc[*dci_cnt].L = L;
         dci_alloc[*dci_cnt].firstCCE = CCEind;
-        dci_alloc[*dci_cnt].dci_pdu[0] = dci_estimation[0];
-        dci_alloc[*dci_cnt].dci_pdu[1] = dci_estimation[1];
-        dci_alloc[*dci_cnt].dci_pdu[2] = dci_estimation[2];
-        dci_alloc[*dci_cnt].dci_pdu[3] = dci_estimation[3];
-        //#ifdef NR_PDCCH_DCI_DEBUG
+        memcpy(&dci_alloc[*dci_cnt].dci_pdu[0],dci_estimation,8);
+
+#ifdef NR_PDCCH_DCI_DEBUG
         printf ("\t\t<-NR_PDCCH_DCI_DEBUG (nr_dci_decoding_procedure0)-> rnti matches -> DCI FOUND !!! crc =>0x%x, sizeof_bits %d, sizeof_bytes %d \n",
                 dci_alloc[*dci_cnt].rnti, dci_alloc[*dci_cnt].dci_length, sizeof_bytes);
         printf ("\t\t<-NR_PDCCH_DCI_DEBUG (nr_dci_decoding_procedure0)-> dci_cnt %d (format_css %d crc_scrambled %d) L %d, firstCCE %d pdu[0] 0x%lx pdu[1] 0x%lx \n",
                 *dci_cnt, format_css,*crc_scrambled,dci_alloc[*dci_cnt].L, dci_alloc[*dci_cnt].firstCCE,dci_alloc[*dci_cnt].dci_pdu[0],dci_alloc[*dci_cnt].dci_pdu[1]);
-
-        //#endif
+#endif
         if ((format_css == cformat0_0_and_1_0) || (format_uss == uformat0_0_and_1_0)) {
           if ((*crc_scrambled == _p_rnti) || (*crc_scrambled == _si_rnti) || (*crc_scrambled == _ra_rnti)) {
             dci_alloc[*dci_cnt].format = format1_0;
diff --git a/openair1/PHY/NR_UE_TRANSPORT/dci_tools_nr.c b/openair1/PHY/NR_UE_TRANSPORT/dci_tools_nr.c
index e821e9696a..48125a01f8 100644
--- a/openair1/PHY/NR_UE_TRANSPORT/dci_tools_nr.c
+++ b/openair1/PHY/NR_UE_TRANSPORT/dci_tools_nr.c
@@ -52,7 +52,7 @@
 
 //#define DEBUG_DCI
 #define NR_PDCCH_DCI_TOOLS
-#define NR_PDCCH_DCI_TOOLS_DEBUG
+//#define NR_PDCCH_DCI_TOOLS_DEBUG
 
 typedef unsigned __int128 uint128_t;
 
@@ -95,11 +95,8 @@ int nr_extract_dci_info(PHY_VARS_NR_UE *ue,
         uint8_t dci_length,
         uint16_t rnti,
         uint64_t dci_pdu[2],
-        NR_DCI_INFO_EXTRACTED_t *nr_pdci_info_extracted,
+        fapi_nr_dci_pdu_rel15_t *nr_pdci_info_extracted,
         uint8_t dci_fields_sizes[NBR_NR_DCI_FIELDS][NBR_NR_FORMATS],
-        NR_DL_UE_HARQ_t *pdlsch0_harq,
-        NR_UE_DLSCH_t *pdlsch0,
-        NR_UE_ULSCH_t *ulsch0,
         NR_DCI_format_t dci_format,
         uint8_t nr_tti_rx,
         uint16_t n_RB_ULBWP,
@@ -631,7 +628,7 @@ int nr_extract_dci_info(PHY_VARS_NR_UE *ue,
       case TB1_MCS: // 18 TB1_MCS: (field defined for -,-,-,format1_1,-,-,-,-)
         nr_pdci_info_extracted->tb1_mcs                          = (uint8_t)nr_dci_field(dci_pdu,dci_fields_sizes_format,dci_field);
         //(((((*(uint128_t *)dci_pdu)  << (left_shift - dci_fields_sizes[dci_field][dci_format]))) & pdu_bitmap) >> (dci_length - dci_fields_sizes[dci_field][dci_format]));
-        if (nr_pdci_info_extracted->mcs < 29) pdlsch0_harq->mcs  = nr_pdci_info_extracted->tb1_mcs;
+        //if (nr_pdci_info_extracted->mcs < 29) pdlsch0_harq->mcs  = nr_pdci_info_extracted->tb1_mcs;
         #ifdef NR_PDCCH_DCI_TOOLS_DEBUG
           printf("\t\t<-NR_PDCCH_DCI_TOOLS_DEBUG (nr_extract_dci_info) -> nr_pdci_info_extracted->tb1_mcs=%x\n",nr_pdci_info_extracted->tb1_mcs);
         #endif
@@ -1025,98 +1022,50 @@ int nr_generate_ue_ul_dlsch_params_from_dci(PHY_VARS_NR_UE *ue,
         uint16_t rnti,
         uint8_t dci_length,
         NR_DCI_format_t dci_format,
-        NR_UE_PDCCH *pdcch_vars,
-        NR_UE_PDSCH *pdsch_vars,
-        NR_UE_DLSCH_t **dlsch,
-        NR_UE_ULSCH_t *ulsch,
         NR_DL_FRAME_PARMS *frame_parms,
         PDSCH_CONFIG_DEDICATED *pdsch_config_dedicated,
-        uint8_t beamforming_mode,
         uint8_t dci_fields_sizes[NBR_NR_DCI_FIELDS][NBR_NR_FORMATS],
         uint16_t n_RB_ULBWP,
         uint16_t n_RB_DLBWP,
         uint16_t crc_scrambled_values[TOTAL_NBR_SCRAMBLED_VALUES],
-        NR_DCI_INFO_EXTRACTED_t *nr_dci_info_extracted)
+        fapi_nr_dci_pdu_rel15_t *nr_dci_info_extracted)
 {
   /*
    * Note only format0_0 and format1_0 are implemented
    */
 
-  //uint8_t harq_pid=0;
   uint8_t frame_type=frame_parms->frame_type;
-  //uint8_t tpmi=0;
-  NR_UE_DLSCH_t *dlsch0=NULL;//*dlsch1=NULL;
-  NR_DL_UE_HARQ_t *dlsch0_harq=NULL;//*dlsch1_harq=NULL;
-  NR_UE_ULSCH_t *ulsch0=NULL;//*ulsch1=NULL;
-  
-  
-  NR_DCI_INFO_EXTRACTED_t *ptr_nr_dci_info_extracted = nr_dci_info_extracted;
-  
-  
   uint8_t status=0;
-  #ifdef NR_PDCCH_DCI_TOOLS_DEBUG
-    printf("\t<-NR_PDCCH_DCI_TOOLS_DEBUG (nr_generate_ue_ul_dlsch_params_from_dci) -> dci_format=%d, rnti=%d, dci_length=%d, dci_pdu[0]=0x%lx, dci_pdu[1]=0x%lx\n",
-             dci_format,rnti,dci_length,dci_pdu[0],dci_pdu[1]);
-  #endif
 
-  
+  LOG_D(PHY,"\t<-NR_PDCCH_DCI_TOOLS_DEBUG (nr_generate_ue_ul_dlsch_params_from_dci) -> dci_format=%d, rnti=%d, dci_length=%d, dci_pdu[0]=0x%lx, dci_pdu[1]=0x%lx\n",dci_format,rnti,dci_length,dci_pdu[0],dci_pdu[1]);
 
-//  uint8_t dci_fields_sizes_format[NBR_NR_DCI_FIELDS] ={0};
-//  for (int m=0; m<NBR_NR_DCI_FIELDS; m++) dci_fields_sizes_format[m]=dci_fields_sizes[m][dci_format];
-/*
-  dlsch0 = dlsch[0];
-  dlsch0->active = 0;
-  if (dci_fields_sizes[HARQ_PROCESS_NUMBER][dci_format] != 0) { // 27 HARQ_PROCESS_NUMBER (27 is the position in dci_fields_sizes array for field HARQ_PROCESS_NUMBER)
-    //for (int i=0; i<=HARQ_PROCESS_NUMBER; i++) left_shift = left_shift + dci_fields_sizes[i][dci_format];
-    nr_dci_info_extracted->harq_process_number = (uint8_t)nr_dci_field(dci_pdu,dci_fields_sizes_format,HARQ_PROCESS_NUMBER);
-    //(((((*(uint128_t *)dci_pdu)  << (left_shift - dci_fields_sizes[HARQ_PROCESS_NUMBER][dci_format]))) & pdu_bitmap) >> (dci_length - dci_fields_sizes[HARQ_PROCESS_NUMBER][dci_format]));
-    //left_shift = 0;
-    #ifdef NR_PDCCH_DCI_TOOLS_DEBUG
-      printf("\t<-NR_PDCCH_DCI_TOOLS_DEBUG (nr_generate_ue_ul_dlsch_params_from_dci) -> nr_dci_info_extracted->harq_process_number=%x\n",nr_dci_info_extracted->harq_process_number);
-    for (int i=0; i<1000; i++) printf("%d",i);
-   #endif
-  }
+  memset(nr_dci_info_extracted,0,sizeof(*nr_dci_info_extracted));
 
+  LOG_D(PHY,"\t<-NR_PDCCH_DCI_TOOLS_DEBUG (nr_generate_ue_ul_dlsch_params_from_dci) -> Entering function nr_extract_dci_info(dci_format=%d) \n",dci_format);
 
-  dlsch0_harq   = dlsch[0]->harq_processes[nr_dci_info_extracted->harq_process_number];
-  ulsch0 = ulsch;
-  //printf("nr_dci_info_extracted.harq_process_number = %d\n",nr_dci_info_extracted.harq_process_number);
-  //printf("dlsch0 = %d\n",dlsch0);
-  //printf("dlsch0_harq = %d\n",dlsch0_harq);
-
-  if (!dlsch[0]) return -1;
-  if (!ulsch) return -1;
-*/
-  memset(&nr_dci_info_extracted,0,sizeof(nr_dci_info_extracted));
-//  printf("we reach this point\n");
-  #ifdef NR_PDCCH_DCI_TOOLS_DEBUG
-    printf("\t<-NR_PDCCH_DCI_TOOLS_DEBUG (nr_generate_ue_ul_dlsch_params_from_dci) -> Entering function nr_extract_dci_info(dci_format=%d) \n",dci_format);
-  #endif
   status = nr_extract_dci_info(ue,
                                eNB_id,
                                frame_type,
                                dci_length,
                                rnti,
                                dci_pdu,
-                               ptr_nr_dci_info_extracted,//&nr_dci_info_extracted,
+                               nr_dci_info_extracted,//&nr_dci_info_extracted,
                                dci_fields_sizes,
-                               dlsch0_harq,
-                               dlsch0,
-                               ulsch0,
                                dci_format,
                                nr_tti_rx,
                                n_RB_ULBWP,
                                n_RB_DLBWP,
                                crc_scrambled_values);
-  //printf("\n>>> inside nr_generate_ue_ul_dlsch_params_from_dci after nr_extract_dci_info: mcs=%d\n",nr_dci_info_extracted->mcs);
-  #ifdef NR_PDCCH_DCI_TOOLS_DEBUG
-    if(status == 0) {
-      printf("\t<-NR_PDCCH_DCI_TOOLS_DEBUG (nr_generate_ue_ul_dlsch_params_from_dci) -> bad DCI %d !!! \n",dci_format);
-      return(-1);
-    }
-    //printf("\n>>> inside nr_generate_ue_ul_dlsch_params_from_dci after nr_extract_dci_info: modified mcs=%d \n",nr_dci_info_extracted->mcs);
-    printf("\t<-NR_PDCCH_DCI_TOOLS_DEBUG (nr_generate_ue_ul_dlsch_params_from_dci) -> Ending function nr_extract_dci_info()\n");
-  #endif
+
+  if(status == 0) {
+    LOG_W(PHY,"\t<-NR_PDCCH_DCI_TOOLS_DEBUG (nr_generate_ue_ul_dlsch_params_from_dci) -> bad DCI %d !!! \n",dci_format);
+    return(-1);
+  }
+
+  LOG_D(PHY,"\t<-NR_PDCCH_DCI_TOOLS_DEBUG (nr_generate_ue_ul_dlsch_params_from_dci) -> Ending function nr_extract_dci_info()\n");
+
+  //fill 
+  
   return(0);
 }
 
diff --git a/openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_decoding.c b/openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_decoding.c
index def3a71754..73c5c3ef6f 100644
--- a/openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_decoding.c
+++ b/openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_decoding.c
@@ -39,7 +39,7 @@
 #include "PHY/NR_TRANSPORT/nr_dlsch.h"
 #include "SCHED_NR_UE/defs.h"
 #include "SIMULATION/TOOLS/sim.h"
-#include "targets/RT/USER/nr-uesoftmodem.h"
+#include "executables/nr-uesoftmodem.h"
 #include "PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.h"
 #include "PHY/CODING/nrLDPC_decoder/nrLDPC_types.h"
 //#define DEBUG_DLSCH_DECODING
@@ -76,11 +76,11 @@ void free_nr_ue_dlsch(NR_UE_DLSCH_t *dlsch)
           }
         
         for (r=0; r<(MAX_NUM_NR_DLSCH_SEGMENTS); r++) {
-			if (dlsch->harq_processes[i]->p_nrLDPC_procBuf[r]){
-			  nrLDPC_free_mem(dlsch->harq_processes[i]->p_nrLDPC_procBuf[r]);
-			  dlsch->harq_processes[i]->p_nrLDPC_procBuf[r] = NULL;
-			}
-		}
+          if (dlsch->harq_processes[i]->p_nrLDPC_procBuf[r]){
+            nrLDPC_free_mem(dlsch->harq_processes[i]->p_nrLDPC_procBuf[r]);
+            dlsch->harq_processes[i]->p_nrLDPC_procBuf[r] = NULL;
+          }
+        }
 
         free16(dlsch->harq_processes[i],sizeof(NR_DL_UE_HARQ_t));
         dlsch->harq_processes[i] = NULL;
@@ -143,7 +143,7 @@ NR_UE_DLSCH_t *new_nr_ue_dlsch(uint8_t Kmimo,uint8_t Mdlharq,uint32_t Nsoft,uint
 
         if (abstraction_flag == 0) {
           for (r=0; r<MAX_NUM_NR_DLSCH_SEGMENTS/bw_scaling; r++) { 
-			dlsch->harq_processes[i]->p_nrLDPC_procBuf[r] = nrLDPC_init_mem();
+            dlsch->harq_processes[i]->p_nrLDPC_procBuf[r] = nrLDPC_init_mem();
             dlsch->harq_processes[i]->c[r] = (uint8_t*)malloc16(1056);
 
             if (dlsch->harq_processes[i]->c[r])
@@ -192,7 +192,7 @@ void nr_dlsch_unscrambling(int16_t* llr,
       reset = 0;
     }
     if (((s>>(i&0x1f))&1)==1)
-        llr[i] = -llr[i];
+      llr[i] = -llr[i];
   }
 
 }
@@ -203,7 +203,7 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
                          NR_UE_DLSCH_t *dlsch,
                          NR_DL_UE_HARQ_t *harq_process,
                          uint32_t frame,
-						 uint16_t nb_symb_sch,
+                         uint16_t nb_symb_sch,
                          uint8_t nr_tti_rx,
                          uint8_t harq_pid,
                          uint8_t is_crnti,
@@ -231,14 +231,16 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
   int16_t z [68*384];
   int8_t l [68*384];
   //__m128i l;
-  int16_t inv_d [68*384];
+  //int16_t inv_d [68*384];
   uint8_t kc;
   uint8_t Ilbrm = 0;
   uint32_t Tbslbrm = 950984;
-  uint16_t nb_rb = 30; //to update
-  uint8_t nb_re_dmrs = 6;
-  uint16_t length_dmrs = 1;
+  uint16_t nb_rb = 30;
   double Coderate = 0.0;
+  nfapi_nr_config_request_t *cfg = &phy_vars_ue->nrUE_config;
+  uint8_t dmrs_type = cfg->pdsch_config.dmrs_type.value;
+  uint8_t nb_re_dmrs = (dmrs_type==NFAPI_NR_DMRS_TYPE1)?6:4;
+  uint16_t length_dmrs = 1; //cfg->pdsch_config.dmrs_max_length.value;
 
   uint32_t i,j;
 
@@ -247,7 +249,7 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
 
   //NR_DL_UE_HARQ_t *harq_process = dlsch->harq_processes[0];
 
-   if (!dlsch_llr) {
+  if (!dlsch_llr) {
     printf("dlsch_decoding.c: NULL dlsch_llr pointer\n");
     return(dlsch->max_ldpc_iterations);
   }
@@ -305,57 +307,59 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
     // This is a new packet, so compute quantities regarding segmentation
     harq_process->B = A+24;
     nr_segmentation(NULL,
-    	                    NULL,
-    	                    harq_process->B,
-    	                    &harq_process->C,
-    	                    &harq_process->K,
-     						&harq_process->Z,
-    	                    &harq_process->F);
-    						p_decParams->Z = harq_process->Z;
+                    NULL,
+                    harq_process->B,
+                    &harq_process->C,
+                    &harq_process->K,
+                    &harq_process->Z, // [hna] Z is Zc
+                    &harq_process->F);
 
 #ifdef DEBUG_DLSCH_DECODING
-    printf("dlsch decoding nr segmentation Z %d\n", p_decParams->Z);
-	if (!frame%100)
-    	printf("K %d C %d Z %d nl %d \n", harq_process->K, harq_process->C, p_decParams->Z, harq_process->Nl);
+    if (!frame%100)
+      printf("K %d C %d Z %d nl %d \n", harq_process->K, harq_process->C, p_decParams->Z, harq_process->Nl);
 #endif
   }
-      Coderate = (float) A /(float) G;
-      if ((A <=292) || ((A<=3824) && (Coderate <= 0.6667)) || Coderate <= 0.25){
-  		  p_decParams->BG = 2;
-  		  if (Coderate < 0.3333){
-  			  p_decParams->R = 15;
-  			  kc = 52;
-  		  }
-  		  else if (Coderate <0.6667){
-  			  p_decParams->R = 13;
-  			  kc = 32;
-  		  }
-  		  else {
-  		  	  p_decParams->R = 23;
-  		  	  kc = 17;
-  		  }
-  	  }
-  	  else{
-  		  p_decParams->BG = 1;
-  		  if (Coderate < 0.6667){
-  			  p_decParams->R = 13;
-  			  kc = 68;
-  		  }
-  		  else if (Coderate <0.8889){
-  			  p_decParams->R = 23;
-  			  kc = 35;
-  		  }
-  		  else {
-  			  p_decParams->R = 89;
-  			  kc = 27;
-  		  }
-  	  }
 
-  	  //printf("coderate %f kc %d \n", Coderate, kc);
+  p_decParams->Z = harq_process->Z;
+  //printf("dlsch decoding nr segmentation Z %d\n", p_decParams->Z);
 
-      p_decParams->numMaxIter = dlsch->max_ldpc_iterations;
-      p_decParams->outMode= 0;
+  Coderate = (float) A /(float) G;
+  if ((A <=292) || ((A<=3824) && (Coderate <= 0.6667)) || Coderate <= 0.25)
+  {
+    p_decParams->BG = 2;
+    if (Coderate < 0.3333){
+      p_decParams->R = 15;
+      kc = 52;
+    }
+    else if (Coderate <0.6667){
+      p_decParams->R = 13;
+      kc = 32;
+    }
+    else {
+      p_decParams->R = 23;
+      kc = 17;
+    }
+  }
+  else{
+    p_decParams->BG = 1;
+    if (Coderate < 0.6667){
+      p_decParams->R = 13;
+      kc = 68;
+    }
+    else if (Coderate <0.8889){
+      p_decParams->R = 23;
+      kc = 35;
+    }
+    else {
+      p_decParams->R = 89;
+      kc = 27;
+    }
+  }
 
+  //printf("coderate %f kc %d \n", Coderate, kc);
+
+  p_decParams->numMaxIter = dlsch->max_ldpc_iterations;
+  p_decParams->outMode= 0;
 
   err_flag = 0;
   r_offset = 0;
@@ -363,27 +367,27 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
   unsigned char bw_scaling =1;
 
   switch (frame_parms->N_RB_DL) {
+    case 106:
+      bw_scaling =2;
+      break;
 
-  case 106:
-    bw_scaling =2;
-    break;
-
-  default:
-    bw_scaling =1;
-    break;
+    default:
+      bw_scaling =1;
+      break;
   }
 
   if (harq_process->C > MAX_NUM_NR_DLSCH_SEGMENTS/bw_scaling) {
     LOG_E(PHY,"Illegal harq_process->C %d > %d\n",harq_process->C,MAX_NUM_NR_DLSCH_SEGMENTS/bw_scaling);
     return((1+dlsch->max_ldpc_iterations));
   }
+
 #ifdef DEBUG_DLSCH_DECODING
   printf("Segmentation: C %d, K %d\n",harq_process->C,harq_process->K);
 #endif
 
   opp_enabled=1;
 
-  Kr = harq_process->K;
+  Kr = harq_process->K; // [hna] overwrites this line "Kr = p_decParams->Z*kb"
   Kr_bytes = Kr>>3;
 
   K_bytes_F = Kr_bytes-(harq_process->F>>3);
@@ -400,11 +404,11 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
 #endif
     nr_deinterleaving_ldpc(E,
                            harq_process->Qm,
-                           harq_process->w[r],
+                           harq_process->w[r], // [hna] w is e
                            dlsch_llr+r_offset);
 
     //for (int i =0; i<16; i++)
-    //        	printf("rx output deinterleaving w[%d]= %d r_offset %d\n", i,harq_process->w[r][i], r_offset);
+    //          printf("rx output deinterleaving w[%d]= %d r_offset %d\n", i,harq_process->w[r][i], r_offset);
 
 #if UE_TIMING_TRACE
     stop_meas(dlsch_deinterleaving_stats);
@@ -441,31 +445,30 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
 #endif
       LOG_E(PHY,"dlsch_decoding.c: Problem in rate_matching\n");
       return(dlsch->max_ldpc_iterations);
-    } else
-    {
+    } else {
 #if UE_TIMING_TRACE
       stop_meas(dlsch_rate_unmatching_stats);
 #endif
     }
 
     //for (int i =0; i<16; i++)
-    //    	printf("rx output ratematching d[%d]= %d r_offset %d\n", i,harq_process->d[r][i], r_offset);
+    //      printf("rx output ratematching d[%d]= %d r_offset %d\n", i,harq_process->d[r][i], r_offset);
 
     r_offset += E;
 
 #ifdef DEBUG_DLSCH_DECODING
     if (r==0) {
-              write_output("decoder_llr.m","decllr",dlsch_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_llr.m","decllr",dlsch_llr,G,1,0);
+      write_output("decoder_in.m","dec",&harq_process->d[0][0],(3*8*Kr_bytes)+12,1,0);
     }
 
     printf("decoder input(segment %d) :",r);
-    int i; for (i=0;i<(3*8*Kr_bytes)+12;i++)
+    int i;
+    for (i=0;i<(3*8*Kr_bytes)+12;i++)
       printf("%d : %d\n",i,harq_process->d[r][i]);
-      printf("\n");
+    printf("\n");
 #endif
 
-
     //    printf("Clearing c, %p\n",harq_process->c[r]);
     memset(harq_process->c[r],0,Kr_bytes);
 
@@ -482,74 +485,70 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
     if (err_flag == 0) {
 
 #if UE_TIMING_TRACE
-        start_meas(dlsch_turbo_decoding_stats);
+      start_meas(dlsch_turbo_decoding_stats);
 #endif
 
       //LOG_E(PHY,"AbsSubframe %d.%d Start LDPC segment %d/%d A %d ",frame%1024,nr_tti_rx,r,harq_process->C-1, A);
 
       //printf("harq process dr iteration %d\n", p_decParams->numMaxIter);
 
+      memset(pv,0,2*harq_process->Z*sizeof(int16_t));
+      //memset(pl,0,2*p_decParams->Z*sizeof(int8_t));
+      memset((pv+K_bytes_F),127,harq_process->F*sizeof(int16_t));
 
-        memset(pv,0,2*harq_process->Z*sizeof(int16_t));
-        //memset(pl,0,2*p_decParams->Z*sizeof(int8_t));
-    	memset((pv+K_bytes_F),127,harq_process->F*sizeof(int16_t));
+      for (i=((2*p_decParams->Z)>>3), j = 0; i < K_bytes_F; i++, j++)
+      {
+        pv[i]= _mm_loadu_si128((__m128i*)(&harq_process->d[r][8*j]));
+      }
 
-      	for (i=((2*p_decParams->Z)>>3), j = 0; i < K_bytes_F; i++, j++)
-      	{
-      		pv[i]= _mm_loadu_si128((__m128i*)(&harq_process->d[r][8*j]));
-      	}
+      for (i=Kr_bytes,j=K_bytes_F-((2*p_decParams->Z)>>3); i < ((kc*p_decParams->Z)>>3); i++, j++)
+      {
+        pv[i]= _mm_loadu_si128((__m128i*)(&harq_process->d[r][8*j]));
+      }
 
-		for (i=Kr_bytes,j=K_bytes_F-((2*p_decParams->Z)>>3); i < ((kc*p_decParams->Z)>>3); i++, j++)
-		      	{
-		      		pv[i]= _mm_loadu_si128((__m128i*)(&harq_process->d[r][8*j]));
-		      	}
-      	
-		for (i=0, j=0; j < ((kc*p_decParams->Z)>>4);  i+=2, j++)
-      	      	{
-      				
-      	      		pl[j] = _mm_packs_epi16(pv[i],pv[i+1]);
-      	      		
-      	      	}
+      for (i=0, j=0; j < ((kc*p_decParams->Z)>>4);  i+=2, j++)
+      {
+        pl[j] = _mm_packs_epi16(pv[i],pv[i+1]);
+      }
 
-		no_iteration_ldpc = nrLDPC_decoder(p_decParams,
-						   (int8_t*)&pl[0],
-						   llrProcBuf,
+      no_iteration_ldpc = nrLDPC_decoder(p_decParams,
+                           (int8_t*)&pl[0],
+                           llrProcBuf,
                            p_nrLDPC_procBuf[r],
                            p_procTime);
 
-		// Fixme: correct type is unsigned, but nrLDPC_decoder and all called behind use signed int
-		if (check_crc((uint8_t*)llrProcBuf,length_dec,harq_process->F,crc_type)) {
-		  printf("Segment %d CRC OK\n",r);
-		  ret = 2;
-		}
-		else {
-		  printf("CRC NOK\n");
-		  ret = 1+dlsch->max_ldpc_iterations;
-		}
-		
+      // Fixme: correct type is unsigned, but nrLDPC_decoder and all called behind use signed int
+      if (check_crc((uint8_t*)llrProcBuf,length_dec,harq_process->F,crc_type)) {
+        printf("Segment %d CRC OK\n",r);
+        ret = 2;
+      }
+      else {
+        printf("CRC NOK\n");
+        ret = 1+dlsch->max_ldpc_iterations;
+      }
 
-		nb_total_decod++;
-		if (no_iteration_ldpc > dlsch->max_ldpc_iterations){
-		  nb_error_decod++;
-		}
+      nb_total_decod++;
+      if (no_iteration_ldpc > dlsch->max_ldpc_iterations){
+        nb_error_decod++;
+      }
 
-		ret=no_iteration_ldpc;
+      ret=no_iteration_ldpc;
 
-		//if (!nb_total_decod%10000){
-		//printf("Error number of iteration LPDC %d %ld/%ld \n", no_iteration_ldpc, nb_error_decod,nb_total_decod);fflush(stdout);
-		//}
-		//else
-		//printf("OK number of iteration LPDC %d\n", no_iteration_ldpc);
+      //if (!nb_total_decod%10000){
+      //printf("Error number of iteration LPDC %d %ld/%ld \n", no_iteration_ldpc, nb_error_decod,nb_total_decod);fflush(stdout);
+      //}
+      //else
+      //printf("OK number of iteration LPDC %d\n", no_iteration_ldpc);
 
-		for (int m=0; m < Kr>>3; m ++)
-		      	      	{
-		      				harq_process->c[r][m]= (uint8_t) llrProcBuf[m];
-		      	      	}
+      for (int m=0; m < Kr>>3; m ++)
+      {
+        harq_process->c[r][m]= (uint8_t) llrProcBuf[m];
+      }
 
 #ifdef DEBUG_DLSCH_DECODING
       //printf("output decoder %d %d %d %d %d \n", harq_process->c[r][0], harq_process->c[r][1], harq_process->c[r][2],harq_process->c[r][3], harq_process->c[r][4]);
       for (int k=0;k<A>>3;k++)
-       printf("output decoder [%d] =  0x%02x \n", k, harq_process->c[r][k]);
+        printf("output decoder [%d] =  0x%02x \n", k, harq_process->c[r][k]);
       printf("no_iterations_ldpc %d (ret %d)\n",no_iteration_ldpc,ret);
       //write_output("dec_output.m","dec0",harq_process->c[0],Kr_bytes,1,4);
 #endif
@@ -664,18 +663,18 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
 
 #ifdef UE_DLSCH_PARALLELISATION
 uint32_t  nr_dlsch_decoding_mthread(PHY_VARS_NR_UE *phy_vars_ue,
-			 UE_nr_rxtx_proc_t *proc,
-                         int eNB_id,
-                         short *dlsch_llr,
-                         NR_DL_FRAME_PARMS *frame_parms,
-                         NR_UE_DLSCH_t *dlsch,
-                         NR_DL_UE_HARQ_t *harq_process,
-                         uint32_t frame,
-			 uint16_t nb_symb_sch,
-                         uint8_t nr_tti_rx,
-                         uint8_t harq_pid,
-                         uint8_t is_crnti,
-                         uint8_t llr8_flag)
+                                    UE_nr_rxtx_proc_t *proc,
+                                    int eNB_id,
+                                    short *dlsch_llr,
+                                    NR_DL_FRAME_PARMS *frame_parms,
+                                    NR_UE_DLSCH_t *dlsch,
+                                    NR_DL_UE_HARQ_t *harq_process,
+                                    uint32_t frame,
+                                    uint16_t nb_symb_sch,
+                                    uint8_t nr_tti_rx,
+                                    uint8_t harq_pid,
+                                    uint8_t is_crnti,
+                                    uint8_t llr8_flag)
 {
 
 #if UE_TIMING_TRACE
@@ -786,27 +785,28 @@ uint32_t  nr_dlsch_decoding_mthread(PHY_VARS_NR_UE *phy_vars_ue,
       // This is a new packet, so compute quantities regarding segmentation
       harq_process->B = A+24;
       nr_segmentation(NULL,
-          	          NULL,
-          	          harq_process->B,
-          	          &harq_process->C,
-          	          &harq_process->K,
-           		  &harq_process->Z,
-          	          &harq_process->F);
-          		  p_decParams->Z = harq_process->Z;
+                      NULL,
+                      harq_process->B,
+                      &harq_process->C,
+                      &harq_process->K,
+                      &harq_process->Z,
+                      &harq_process->F);
+
+      p_decParams->Z = harq_process->Z;
 
     }
 
- 	kb = harq_process->K/harq_process->Z;
-  	  if ( kb==22){
-  		  p_decParams->BG = 1;
-  		  p_decParams->R = 13;
-  		  kc = 68;
-  	  }
-  	  else{
-  		  p_decParams->BG = 2;
-  		  p_decParams->R = 13;
-  		  kc = 52;
-  	  	  }
+  kb = harq_process->K/harq_process->Z;
+      if ( kb==22){
+        p_decParams->BG = 1;
+        p_decParams->R = 13;
+        kc = 68;
+      }
+      else{
+        p_decParams->BG = 2;
+        p_decParams->R = 13;
+        kc = 52;
+      }
 
       p_decParams->numMaxIter = 2;
       Kr = p_decParams->Z*kb;
@@ -842,135 +842,133 @@ uint32_t  nr_dlsch_decoding_mthread(PHY_VARS_NR_UE *phy_vars_ue,
 #endif
 
   opp_enabled=1;
-if (harq_process->C>1) { // wakeup worker if more than 1 segment
-     if (pthread_mutex_lock(&proc->mutex_dlsch_td) != 0) {
-         LOG_E( PHY, "[SCHED][UE %d][Slot0] error locking mutex for UE dlsch td\n",phy_vars_ue->Mod_id );
-         exit_fun("nothing to add");
-     }
+  if (harq_process->C>1) { // wakeup worker if more than 1 segment
+    if (pthread_mutex_lock(&proc->mutex_dlsch_td) != 0) {
+      LOG_E( PHY, "[SCHED][UE %d][Slot0] error locking mutex for UE dlsch td\n",phy_vars_ue->Mod_id );
+      exit_fun("nothing to add");
+    }
 
-     /*Qm= harq_process->Qm;
-     Nl=harq_process->Nl;
-     r_thread = harq_process->C/2-1;
-     C= harq_process->C;
+  /*Qm= harq_process->Qm;
+    Nl=harq_process->Nl;
+    r_thread = harq_process->C/2-1;
+    C= harq_process->C;
 
-     Gp = G/Nl/Qm;
-      GpmodC = Gp%C;
+    Gp = G/Nl/Qm;
+    GpmodC = Gp%C;
 
 
 
-      if (r_thread < (C-(GpmodC)))
-        Er = Nl*Qm * (Gp/C);
-      else
-        Er = Nl*Qm * ((GpmodC==0?0:1) + (Gp/C));
-     printf("mthread Er %d\n", Er);
+    if (r_thread < (C-(GpmodC)))
+      Er = Nl*Qm * (Gp/C);
+    else
+      Er = Nl*Qm * ((GpmodC==0?0:1) + (Gp/C));
+    printf("mthread Er %d\n", Er);
 
-     printf("mthread instance_cnt_dlsch_td %d\n",  proc->instance_cnt_dlsch_td);*/
+    printf("mthread instance_cnt_dlsch_td %d\n",  proc->instance_cnt_dlsch_td);*/
 
-     proc->instance_cnt_dlsch_td++;
-               proc->eNB_id    = eNB_id;
-               proc->harq_pid  = harq_pid;
-               proc->llr8_flag = llr8_flag;
-               //proc->r[0] = 1;
+    proc->instance_cnt_dlsch_td++;
+    proc->eNB_id    = eNB_id;
+    proc->harq_pid  = harq_pid;
+    proc->llr8_flag = llr8_flag;
+  //proc->r[0] = 1;
 
-     if (proc->instance_cnt_dlsch_td == 0)
-     {
-     LOG_D(PHY,"unblock dlsch td processing thread blocked on instance_cnt_dlsch_td : %d \n", proc->instance_cnt_dlsch_td );
-         if (pthread_cond_signal(&proc->cond_dlsch_td) != 0) {
-             LOG_E( PHY, "[SCHED][UE %d][Slot0] ERROR pthread_cond_signal for UE dlsch td\n", phy_vars_ue->Mod_id);
-             exit_fun("nothing to add");
-         }
-         if (pthread_mutex_unlock(&proc->mutex_dlsch_td) != 0) {
-             LOG_E( PHY, "[SCHED][UE %d][Slot0] error unlocking mutex for UE dlsch td \n",phy_vars_ue->Mod_id );
-             exit_fun("nothing to add");
-         }
+    if (proc->instance_cnt_dlsch_td == 0)
+    {
+      LOG_D(PHY,"unblock dlsch td processing thread blocked on instance_cnt_dlsch_td : %d \n", proc->instance_cnt_dlsch_td );
+      if (pthread_cond_signal(&proc->cond_dlsch_td) != 0) {
+        LOG_E( PHY, "[SCHED][UE %d][Slot0] ERROR pthread_cond_signal for UE dlsch td\n", phy_vars_ue->Mod_id);
+        exit_fun("nothing to add");
+      }
+      if (pthread_mutex_unlock(&proc->mutex_dlsch_td) != 0) {
+        LOG_E( PHY, "[SCHED][UE %d][Slot0] error unlocking mutex for UE dlsch td \n",phy_vars_ue->Mod_id );
+        exit_fun("nothing to add");
+      }
+    } else
+    {
+      LOG_E( PHY, "[SCHED][UE %d] UE dlsch td thread busy (IC %d)!!\n", phy_vars_ue->Mod_id, proc->instance_cnt_dlsch_td);
+      if (proc->instance_cnt_dlsch_td > 4)
+        exit_fun("instance_cnt_dlsch_td > 4");
+    }
+  //AssertFatal(pthread_cond_signal(&proc->cond_slot1_dl_processing) ==0 ,"");
+    AssertFatal(pthread_mutex_unlock(&proc->mutex_dlsch_td) ==0,"");
 
-     } else
-     {
-         LOG_E( PHY, "[SCHED][UE %d] UE dlsch td thread busy (IC %d)!!\n", phy_vars_ue->Mod_id, proc->instance_cnt_dlsch_td);
-         if (proc->instance_cnt_dlsch_td > 4)
-             exit_fun("instance_cnt_dlsch_td > 4");
-     }
-     //AssertFatal(pthread_cond_signal(&proc->cond_slot1_dl_processing) ==0 ,"");
-     AssertFatal(pthread_mutex_unlock(&proc->mutex_dlsch_td) ==0,"");
+    if (harq_process->C>2) {
+      if (pthread_mutex_lock(&proc->mutex_dlsch_td1) != 0) {
+        LOG_E( PHY, "[SCHED][UE %d][Slot0] error locking mutex for UE dlsch td\n",phy_vars_ue->Mod_id );
+        exit_fun("nothing to add");
+      }
 
-     if (harq_process->C>2) {
-    	 if (pthread_mutex_lock(&proc->mutex_dlsch_td1) != 0) {
-    	          LOG_E( PHY, "[SCHED][UE %d][Slot0] error locking mutex for UE dlsch td\n",phy_vars_ue->Mod_id );
-    	          exit_fun("nothing to add");
-    	      }
+      proc->instance_cnt_dlsch_td1++;
+      proc->eNB_id    = eNB_id;
+      proc->harq_pid  = harq_pid;
+      proc->llr8_flag = llr8_flag;
+   // proc->Er = Er;
 
-    	 proc->instance_cnt_dlsch_td1++;
-                    proc->eNB_id    = eNB_id;
-                    proc->harq_pid  = harq_pid;
-                    proc->llr8_flag = llr8_flag;
-                   // proc->Er = Er;
+      if (proc->instance_cnt_dlsch_td1 == 0)
+      {
+        LOG_D(PHY,"unblock slot1 dl processing thread blocked on instance_cnt_dlsch_td : %d \n", proc->instance_cnt_dlsch_td1 );
+        if (pthread_cond_signal(&proc->cond_dlsch_td1) != 0) {
+          LOG_E( PHY, "[SCHED][UE %d][Slot0] ERROR pthread_cond_signal for UE dlsch td\n", phy_vars_ue->Mod_id);
+          exit_fun("nothing to add");
+        }
+        if (pthread_mutex_unlock(&proc->mutex_dlsch_td1) != 0) {
+          LOG_E( PHY, "[SCHED][UE %d][Slot0] error unlocking mutex for UE dlsch td \n",phy_vars_ue->Mod_id );
+          exit_fun("nothing to add");
+        }
+      } else
+      {
+        LOG_E( PHY, "[SCHED][UE %d] UE dlsch td thread 1 busy (IC %d)!!\n", phy_vars_ue->Mod_id, proc->instance_cnt_dlsch_td1);
+        if (proc->instance_cnt_dlsch_td1 > 4)
+          exit_fun("instance_cnt_dlsch_td1 > 4");
+      }
 
-          if (proc->instance_cnt_dlsch_td1 == 0)
-          {
-          LOG_D(PHY,"unblock slot1 dl processing thread blocked on instance_cnt_dlsch_td : %d \n", proc->instance_cnt_dlsch_td1 );
-              if (pthread_cond_signal(&proc->cond_dlsch_td1) != 0) {
-                  LOG_E( PHY, "[SCHED][UE %d][Slot0] ERROR pthread_cond_signal for UE dlsch td\n", phy_vars_ue->Mod_id);
-                  exit_fun("nothing to add");
-              }
-              if (pthread_mutex_unlock(&proc->mutex_dlsch_td1) != 0) {
-                  LOG_E( PHY, "[SCHED][UE %d][Slot0] error unlocking mutex for UE dlsch td \n",phy_vars_ue->Mod_id );
-                  exit_fun("nothing to add");
-              }
+      AssertFatal(pthread_mutex_unlock(&proc->mutex_dlsch_td1) ==0,"");
 
-          } else
-          {
-              LOG_E( PHY, "[SCHED][UE %d] UE dlsch td thread 1 busy (IC %d)!!\n", phy_vars_ue->Mod_id, proc->instance_cnt_dlsch_td1);
-              if (proc->instance_cnt_dlsch_td1 > 4)
-                  exit_fun("instance_cnt_dlsch_td1 > 4");
-          }
+    }
+  /*
+    if (pthread_mutex_timedlock(&proc->mutex_td,&wait) != 0) {
+      printf("[eNB] ERROR pthread_mutex_lock for TD thread (IC %d)\n", proc->instance_cnt_td);
+      exit_fun( "error locking mutex_fep" );
+      return -1;
+    }
 
-          AssertFatal(pthread_mutex_unlock(&proc->mutex_dlsch_td1) ==0,"");
+    if (proc->instance_cnt_td==0) {
+      printf("[UE] TD thread busy\n");
+      exit_fun("TD thread busy");
+      pthread_mutex_unlock( &proc->mutex_td );
+      return -1;
+    }
 
-     }
-	/*
-	if (pthread_mutex_timedlock(&proc->mutex_td,&wait) != 0) {
-       printf("[eNB] ERROR pthread_mutex_lock for TD thread (IC %d)\n", proc->instance_cnt_td);
-       exit_fun( "error locking mutex_fep" );
-       return -1;
-     }
+    ++proc->instance_cnt_td;
 
-     if (proc->instance_cnt_td==0) {
-       printf("[UE] TD thread busy\n");
-       exit_fun("TD thread busy");
-       pthread_mutex_unlock( &proc->mutex_td );
-       return -1;
-     }
+    proc->tdp.UE        = phy_vars_ue;
+    proc->tdp.eNB_id    = eNB_id;
+    proc->tdp.harq_pid  = harq_pid;
+    proc->tdp.llr8_flag = llr8_flag;
 
-     ++proc->instance_cnt_td;
-
-     proc->tdp.UE        = phy_vars_ue;
-     proc->tdp.eNB_id    = eNB_id;
-     proc->tdp.harq_pid  = harq_pid;
-     proc->tdp.llr8_flag = llr8_flag;
-
-     printf("----- 2thread llr flag %d tdp flag %d\n",llr8_flag, proc->tdp.llr8_flag);
+    printf("----- 2thread llr flag %d tdp flag %d\n",llr8_flag, proc->tdp.llr8_flag);
 
 
-     // wakeup worker to do second half segments
-     if (pthread_cond_signal(&proc->cond_td) != 0) {
-       printf("[UE] ERROR pthread_cond_signal for td thread exit\n");
-       exit_fun( "ERROR pthread_cond_signal" );
-       return (1+dlsch->last_iteration_cnt);
-     }
+    // wakeup worker to do second half segments
+    if (pthread_cond_signal(&proc->cond_td) != 0) {
+      printf("[UE] ERROR pthread_cond_signal for td thread exit\n");
+      exit_fun( "ERROR pthread_cond_signal" );
+      return (1+dlsch->last_iteration_cnt);
+    }
 
-     pthread_mutex_unlock( &proc->mutex_td );*/
+    pthread_mutex_unlock( &proc->mutex_td );*/
 
 
-     Cby2 = 1; //harq_process->C/2;
-     //proc->decoder_main_available = 1;
-   }
-   else {
-     Cby2 = 1;
-   }
+    Cby2 = 1; //harq_process->C/2;
+  //proc->decoder_main_available = 1;
+  }
+  else {
+    Cby2 = 1;
+  }
 
-  //for (r=0; r<Cby2; r++) {
-	r = 0;  
-	if (r==0) r_offset =0;
+//for (r=0; r<Cby2; r++) {
+    r = 0;  
+    if (r==0) r_offset =0;
 
     Kr = harq_process->K;
     Kr_bytes = Kr>>3;
@@ -1041,27 +1039,27 @@ if (harq_process->C>1) { // wakeup worker if more than 1 segment
     }
 
     //for (int i =0; i<16; i++)
-    //    	printf("rx output ratematching d[%d]= %d r_offset %d\n", i,harq_process->d[r][i], r_offset);
+    //      printf("rx output ratematching d[%d]= %d r_offset %d\n", i,harq_process->d[r][i], r_offset);
 
     //r_offset += E;
     //printf("main thread r_offset %d\n",r_offset);
  
 #ifdef DEBUG_DLSCH_DECODING   
     for (int i =0; i<16; i++)
-             printf("rx output ratematching d[%d]= %d r_offset %d\n", i,harq_process->d[r][i], r_offset);
+      printf("rx output ratematching d[%d]= %d r_offset %d\n", i,harq_process->d[r][i], r_offset);
 #endif
 
 #ifdef DEBUG_DLSCH_DECODING
 
     if (r==0) {
-              write_output("decoder_llr.m","decllr",dlsch_llr,G,1,0);
-              write_output("decoder_in.m","dec",&harq_process->d[0][96],(3*8*Kr_bytes)+12,1,0);
+      write_output("decoder_llr.m","decllr",dlsch_llr,G,1,0);
+      write_output("decoder_in.m","dec",&harq_process->d[0][96],(3*8*Kr_bytes)+12,1,0);
     }
 
     printf("decoder input(segment %d) :",r);
     for (int i=0;i<(3*8*Kr_bytes);i++)
       printf("%d : %d\n",i,harq_process->d[r][i]);
-      printf("\n");
+    printf("\n");
 #endif
 
 
@@ -1082,98 +1080,94 @@ if (harq_process->C>1) { // wakeup worker if more than 1 segment
                             Kr,r,harq_process->C,harq_process->nb_rb,crc_type,A,harq_process->TBS,
                             harq_process->B,harq_process->mcs,harq_process->Qm,harq_process->rvidx,harq_process->round,dlsch->max_ldpc_iterations);
 */
-    	if (llr8_flag) {
-    		AssertFatal (Kr >= 256, "turbo algo issue Kr=%d cb_cnt=%d C=%d nbRB=%d TBSInput=%d TBSHarq=%d TBSplus24=%d mcs=%d Qm=%d RIV=%d round=%d\n",
-    				Kr,r,harq_process->C,harq_process->nb_rb,A,harq_process->TBS,harq_process->B,harq_process->mcs,harq_process->Qm,harq_process->rvidx,harq_process->round);
-    	}
+      if (llr8_flag) {
+        AssertFatal (Kr >= 256, "turbo algo issue Kr=%d cb_cnt=%d C=%d nbRB=%d TBSInput=%d TBSHarq=%d TBSplus24=%d mcs=%d Qm=%d RIV=%d round=%d\n",
+            Kr,r,harq_process->C,harq_process->nb_rb,A,harq_process->TBS,harq_process->B,harq_process->mcs,harq_process->Qm,harq_process->rvidx,harq_process->round);
+      }
 #if UE_TIMING_TRACE
-        start_meas(dlsch_turbo_decoding_stats);
+      start_meas(dlsch_turbo_decoding_stats);
 #endif
       LOG_D(PHY,"mthread AbsSubframe %d.%d Start turbo segment %d/%d \n",frame%1024,nr_tti_rx,r,harq_process->C-1);
-      
-            for (int cnt =0; cnt < (kc-2)*p_decParams->Z; cnt++){
-            inv_d[cnt] = (1)*harq_process->d[r][cnt];
-            }
 
-		memset(pv,0,2*p_decParams->Z*sizeof(int16_t));
-        //memset(pl,0,2*p_decParams->Z*sizeof(int8_t));
-		memset((pv+K_bytes_F),127,harq_process->F*sizeof(int16_t));
+      for (int cnt =0; cnt < (kc-2)*p_decParams->Z; cnt++){
+        inv_d[cnt] = (1)*harq_process->d[r][cnt];
+      }
+
+      memset(pv,0,2*p_decParams->Z*sizeof(int16_t));
+      //memset(pl,0,2*p_decParams->Z*sizeof(int8_t));
+      memset((pv+K_bytes_F),127,harq_process->F*sizeof(int16_t));
 
 
-      	for (i=((2*p_decParams->Z)>>3), j = 0; i < K_bytes_F+((2*p_decParams->Z)>>3); i++, j++)
-      	{
-      		pv[i]= _mm_loadu_si128((__m128i*)(&inv_d[8*j]));
-      	}
+      for (i=((2*p_decParams->Z)>>3), j = 0; i < K_bytes_F+((2*p_decParams->Z)>>3); i++, j++)
+      {
+        pv[i]= _mm_loadu_si128((__m128i*)(&inv_d[8*j]));
+      }
 
-		for (i=Kr_bytes+((2*p_decParams->Z)>>3),j=Kr_bytes; i < ((kc*p_decParams->Z)>>3); i++, j++)
-		      	{
-		      		pv[i]= _mm_loadu_si128((__m128i*)(&inv_d[8*j]));
-		      	}
+      for (i=Kr_bytes+((2*p_decParams->Z)>>3),j=Kr_bytes; i < ((kc*p_decParams->Z)>>3); i++, j++)
+      {
+        pv[i]= _mm_loadu_si128((__m128i*)(&inv_d[8*j]));
+      }
 
-		for (i=0, j=0; j < ((kc*p_decParams->Z)>>4);  i+=2, j++)
-      	      	{
+      for (i=0, j=0; j < ((kc*p_decParams->Z)>>4);  i+=2, j++)
+      {
+        pl[j] = _mm_packs_epi16(pv[i],pv[i+1]);
+      }
 
-      	      		pl[j] = _mm_packs_epi16(pv[i],pv[i+1]);
+      no_iteration_ldpc = nrLDPC_decoder(p_decParams,
+               (int8_t*)&pl[0],
+               llrProcBuf,
+               p_nrLDPC_procBuf,
+               p_procTime);
 
-      	      	}
+      nb_total_decod++;
+      if (no_iteration_ldpc > 10){
+        nb_error_decod++;
+        ret = 1+dlsch->max_ldpc_iterations;
+      }
+      else {
+        ret=2;
+      }
 
-		no_iteration_ldpc = nrLDPC_decoder(p_decParams,
-						   (int8_t*)&pl[0],
-						   llrProcBuf,
-                           p_nrLDPC_procBuf,
-						   p_procTime);
+      if (check_crc(llrProcBuf,harq_process->B,harq_process->F,crc_type)) {
+        printf("CRC OK\n");
+        ret = 2;
+      }
+      else {
+        printf("CRC NOK\n");
+        ret = 1+dlsch->max_ldpc_iterations;
+      }
 
-		nb_total_decod++;
-		if (no_iteration_ldpc > 10){
-		  nb_error_decod++;
-		  ret = 1+dlsch->max_ldpc_iterations;
-		}
-		else {
-		  ret=2;
-		}
-		
-		if (check_crc(llrProcBuf,harq_process->B,harq_process->F,crc_type)) {
-		  printf("CRC OK\n");
-		  ret = 2;
-		}
-		else {
-		  printf("CRC NOK\n");
-		  ret = 1+dlsch->max_ldpc_iterations;
-		}
-		
-		//if (!nb_total_decod%10000){
-				printf("Error number of iteration LPDC %d %ld/%ld \n", no_iteration_ldpc, nb_error_decod,nb_total_decod);fflush(stdout);
-		//}
+    //if (!nb_total_decod%10000){
+        printf("Error number of iteration LPDC %d %ld/%ld \n", no_iteration_ldpc, nb_error_decod,nb_total_decod);fflush(stdout);
+    //}
 
-		//else
-			//printf("OK number of iteration LPDC %d\n", no_iteration_ldpc);
+    //else
+      //printf("OK number of iteration LPDC %d\n", no_iteration_ldpc);
 
-		for (int m=0; m < Kr>>3; m ++)
-		      	      	{
-		      				harq_process->c[r][m]= (uint8_t) llrProcBuf[m];
-		      	      	}
+      for (int m=0; m < Kr>>3; m ++)
+      {
+        harq_process->c[r][m]= (uint8_t) llrProcBuf[m];
+      }
 
-		      	/*for (int u=0; u < Kr>>3; u ++)
-		      	      	      	{
-		      						ullrProcBuf[u]= (uint8_t) llrProcBuf[u];
-		      	      	      	}
+    /*for (int u=0; u < Kr>>3; u ++)
+      {
+        ullrProcBuf[u]= (uint8_t) llrProcBuf[u];
+      }
 
 
-		      	printf("output unsigned ullrProcBuf \n");
+      printf("output unsigned ullrProcBuf \n");
 
-		      	for (int j=0; j < Kr>>3; j ++)
-		      	      	       	      	{
+      for (int j=0; j < Kr>>3; j ++)
+      {
+        printf(" %d \n", ullrProcBuf[j]);
+      }
+      printf(" \n");*/
+    //printf("output channel decoder %d %d %d %d %d \n", harq_process->c[r][0], harq_process->c[r][1], harq_process->c[r][2],harq_process->c[r][3], harq_process->c[r][4]);
 
-		      	      						printf(" %d \n", ullrProcBuf[j]);
-
-		      	      	      	      	}
-		     	printf(" \n");*/
-		//printf("output channel decoder %d %d %d %d %d \n", harq_process->c[r][0], harq_process->c[r][1], harq_process->c[r][2],harq_process->c[r][3], harq_process->c[r][4]);
-
-		 //printf("output decoder %d %d %d %d %d \n", harq_process->c[r][0], harq_process->c[r][1], harq_process->c[r][2],harq_process->c[r][3], harq_process->c[r][4]);
+    //printf("output decoder %d %d %d %d %d \n", harq_process->c[r][0], harq_process->c[r][1], harq_process->c[r][2],harq_process->c[r][3], harq_process->c[r][4]);
 #ifdef DEBUG_DLSCH_DECODING
-	for (int k=0;k<32;k++)
-       		printf("output decoder [%d] =  0x%02x \n", k, harq_process->c[r][k]);
+      for (int k=0;k<32;k++)
+        printf("output decoder [%d] =  0x%02x \n", k, harq_process->c[r][k]);
 #endif
 
 #if UE_TIMING_TRACE
@@ -1252,40 +1246,40 @@ if (harq_process->C>1) { // wakeup worker if more than 1 segment
   */
   uint32_t wait = 0;
   if (harq_process->C==2){
-	  while((proc->decoder_thread_available == 0) )
+    while((proc->decoder_thread_available == 0) )
   {
           usleep(1);
           wait++;
   }
   }
   else if ((harq_process->C==3) ){
-	  while((proc->decoder_thread_available == 0) || (proc->decoder_thread_available1 == 0))
-			  {
-			            usleep(1);
-			            wait++;
-			    }
+    while((proc->decoder_thread_available == 0) || (proc->decoder_thread_available1 == 0))
+        {
+                  usleep(1);
+                  wait++;
+          }
   }
 
   proc->decoder_main_available = 0;
   
   for (r=0; r<harq_process->C; r++) {
 
-	  Kr = harq_process->K; //to check if same K in all segments
-	  Kr_bytes = Kr>>3;
+    Kr = harq_process->K; //to check if same K in all segments
+    Kr_bytes = Kr>>3;
 
-	    memcpy(harq_process->b+offset,
-	             harq_process->c[r],
-	             Kr_bytes- - (harq_process->F>>3) -((harq_process->C>1)?3:0));
-	    offset += (Kr_bytes - (harq_process->F>>3) - ((harq_process->C>1)?3:0));
+      memcpy(harq_process->b+offset,
+               harq_process->c[r],
+               Kr_bytes- - (harq_process->F>>3) -((harq_process->C>1)?3:0));
+      offset += (Kr_bytes - (harq_process->F>>3) - ((harq_process->C>1)?3:0));
 
 #ifdef DEBUG_DLSCH_DECODING
-	    printf("Segment %d : Kr= %d bytes\n",r,Kr_bytes);
-	    printf("copied %d bytes to b sequence (harq_pid %d)\n",
-	              (Kr_bytes - (harq_process->F>>3)-((harq_process->C>1)?3:0)),harq_pid);
-	              printf("b[0] = %x,c[%d] = %x\n",
-	              harq_process->b[offset],
-	              harq_process->F>>3,
-	              harq_process->c[r]);
+      printf("Segment %d : Kr= %d bytes\n",r,Kr_bytes);
+      printf("copied %d bytes to b sequence (harq_pid %d)\n",
+                (Kr_bytes - (harq_process->F>>3)-((harq_process->C>1)?3:0)),harq_pid);
+                printf("b[0] = %x,c[%d] = %x\n",
+                harq_process->b[offset],
+                harq_process->F>>3,
+                harq_process->c[r]);
 #endif
   }
 
@@ -1346,14 +1340,14 @@ void *nr_dlsch_decoding_2thread0(void *arg)
     char threadname[256];
     sprintf(threadname,"UE_thread_dlsch_td_%d", proc->sub_frame_start);
 
-	cpu_set_t cpuset;
+  cpu_set_t cpuset;
     CPU_ZERO(&cpuset);
     if ( (proc->sub_frame_start+1)%RX_NB_TH == 0 && threads.dlsch_td_one != -1 )
-    	CPU_SET(threads.dlsch_td_one, &cpuset);
+      CPU_SET(threads.dlsch_td_one, &cpuset);
     if ( (proc->sub_frame_start+1)%RX_NB_TH == 1 && threads.dlsch_td_two != -1 )
-    	CPU_SET(threads.dlsch_td_two, &cpuset);
+      CPU_SET(threads.dlsch_td_two, &cpuset);
     if ( (proc->sub_frame_start+1)%RX_NB_TH == 2 && threads.dlsch_td_three != -1 )
-    	CPU_SET(threads.dlsch_td_three, &cpuset);
+      CPU_SET(threads.dlsch_td_three, &cpuset);
 
 
 
@@ -1376,42 +1370,42 @@ void *nr_dlsch_decoding_2thread0(void *arg)
   init_thread(900000,1000000 , FIFO_PRIORITY-1, &cpuset, threadname);
   while (!oai_exit) {
 
-		//proc->decoder_thread_available = 1;
-		
-	        if (pthread_mutex_lock(&proc->mutex_dlsch_td) != 0) {
-	            LOG_E( PHY, "[SCHED][UE] error locking mutex for UE dlsch td\n" );
-	            exit_fun("nothing to add");
-	        }
-	        while (proc->instance_cnt_dlsch_td < 0) {
-	            // most of the time, the thread is waiting here
-	            pthread_cond_wait( &proc->cond_dlsch_td, &proc->mutex_dlsch_td );
-	        }
-	        if (pthread_mutex_unlock(&proc->mutex_dlsch_td) != 0) {
-	            LOG_E( PHY, "[SCHED][UE] error unlocking mutex for UE dlsch_td \n" );
-	            exit_fun("nothing to add");
-	        }
+    //proc->decoder_thread_available = 1;
+    
+          if (pthread_mutex_lock(&proc->mutex_dlsch_td) != 0) {
+              LOG_E( PHY, "[SCHED][UE] error locking mutex for UE dlsch td\n" );
+              exit_fun("nothing to add");
+          }
+          while (proc->instance_cnt_dlsch_td < 0) {
+              // most of the time, the thread is waiting here
+              pthread_cond_wait( &proc->cond_dlsch_td, &proc->mutex_dlsch_td );
+          }
+          if (pthread_mutex_unlock(&proc->mutex_dlsch_td) != 0) {
+              LOG_E( PHY, "[SCHED][UE] error unlocking mutex for UE dlsch_td \n" );
+              exit_fun("nothing to add");
+          }
 
-	        uint32_t wait = 0;
-	        while(proc->decoder_main_available == 0)
-	        {
-	            usleep(1);
-	            wait++;
-	        }
+          uint32_t wait = 0;
+          while(proc->decoder_main_available == 0)
+          {
+              usleep(1);
+              wait++;
+          }
 
-	        //proc->decoder_thread_available = 0;
-	        //PHY_VARS_NR_UE *phy_vars_ue   		= tdp->UE;
-	        int eNB_id         				= proc->eNB_id;
-	        int harq_pid      				= proc->harq_pid;
-	        llr8_flag1     					= proc->llr8_flag;
-	        //r_offset						= proc->Er;
-	        //UE_rxtx_proc_t *proc    		= tdp->proc;
-	        int frame                       = proc->frame_rx;
-	        int subframe      				= proc->nr_tti_rx;
-	        NR_UE_DLSCH_t *dlsch 			= phy_vars_ue->dlsch[phy_vars_ue->current_thread_id[subframe]][eNB_id][0];
-	        NR_DL_UE_HARQ_t *harq_process  = dlsch->harq_processes[harq_pid];
-	        short *dlsch_llr 				= phy_vars_ue->pdsch_vars[phy_vars_ue->current_thread_id[subframe]][eNB_id]->llr[0];
-	        //printf("2thread0 llr flag %d tdp flag %d\n",llr8_flag1, tdp->llr8_flag);
-	        p_nrLDPC_procBuf = harq_process->p_nrLDPC_procBuf[1];
+          //proc->decoder_thread_available = 0;
+          //PHY_VARS_NR_UE *phy_vars_ue       = tdp->UE;
+          int eNB_id                = proc->eNB_id;
+          int harq_pid              = proc->harq_pid;
+          llr8_flag1              = proc->llr8_flag;
+          //r_offset            = proc->Er;
+          //UE_rxtx_proc_t *proc        = tdp->proc;
+          int frame                       = proc->frame_rx;
+          int subframe              = proc->nr_tti_rx;
+          NR_UE_DLSCH_t *dlsch      = phy_vars_ue->dlsch[phy_vars_ue->current_thread_id[subframe]][eNB_id][0];
+          NR_DL_UE_HARQ_t *harq_process  = dlsch->harq_processes[harq_pid];
+          short *dlsch_llr        = phy_vars_ue->pdsch_vars[phy_vars_ue->current_thread_id[subframe]][eNB_id]->llr[0];
+          //printf("2thread0 llr flag %d tdp flag %d\n",llr8_flag1, tdp->llr8_flag);
+          p_nrLDPC_procBuf = harq_process->p_nrLDPC_procBuf[1];
 
   /*
   if (nb_rb > frame_parms->N_RB_DL) {
@@ -1444,27 +1438,27 @@ void *nr_dlsch_decoding_2thread0(void *arg)
     harq_process->B = A+24;
 
     nr_segmentation(NULL,
-    	                    NULL,
-    	                    harq_process->B,
-    	                    &harq_process->C,
-    	                    &harq_process->K,
-   			    &harq_process->Z,
-    	                    &harq_process->F);
-    	p_decParams->Z = harq_process->Z;
+                          NULL,
+                          harq_process->B,
+                          &harq_process->C,
+                          &harq_process->K,
+            &harq_process->Z,
+                          &harq_process->F);
+      p_decParams->Z = harq_process->Z;
 
     }
 
   kb = harq_process->K/harq_process->Z;
-	  if ( kb==22){
-		  p_decParams->BG = 1;
-		  p_decParams->R = 13;
-		  kc = 68;
-	  }
-	  else{
-		  p_decParams->BG = 2;
-		  p_decParams->R = 13;
-		  kc = 52;
-	  	  }
+    if ( kb==22){
+      p_decParams->BG = 1;
+      p_decParams->R = 13;
+      kc = 68;
+    }
+    else{
+      p_decParams->BG = 2;
+      p_decParams->R = 13;
+      kc = 52;
+        }
 
   p_decParams->numMaxIter = 2;
   Kr = p_decParams->Z*kb;
@@ -1510,14 +1504,14 @@ void *nr_dlsch_decoding_2thread0(void *arg)
   Cprime = C; //assume CBGTI not present
 
   if (r <= Cprime - ((G/(Nl*Qm))%Cprime) - 1)
-	  r_offset = Nl*Qm*(G/(Nl*Qm*Cprime));
+    r_offset = Nl*Qm*(G/(Nl*Qm*Cprime));
   else
-	  r_offset = Nl*Qm*((G/(Nl*Qm*Cprime))+1);
+    r_offset = Nl*Qm*((G/(Nl*Qm*Cprime))+1);
 
-		//	printf("thread0 r_offset %d\n",r_offset);
-  	       
+    //  printf("thread0 r_offset %d\n",r_offset);
+           
   //for (r=(harq_process->C/2); r<harq_process->C; r++) {
-  	     r=1; //(harq_process->C/2);
+         r=1; //(harq_process->C/2);
 
 
   Kr = harq_process->K;
@@ -1537,7 +1531,7 @@ void *nr_dlsch_decoding_2thread0(void *arg)
                            dlsch_llr+r_offset);
 
     //for (int i =0; i<16; i++)
-    //        	printf("rx output deinterleaving w[%d]= %d r_offset %d\n", i,harq_process->w[r][i], r_offset);
+    //          printf("rx output deinterleaving w[%d]= %d r_offset %d\n", i,harq_process->w[r][i], r_offset);
 
 #if UE_TIMING_TRACE
     stop_meas(dlsch_deinterleaving_stats);
@@ -1582,7 +1576,7 @@ void *nr_dlsch_decoding_2thread0(void *arg)
     }
 
     //for (int i =0; i<16; i++)
-    //    	printf("rx output ratematching d[%d]= %d r_offset %d\n", i,harq_process->d[r][i], r_offset);
+    //      printf("rx output ratematching d[%d]= %d r_offset %d\n", i,harq_process->d[r][i], r_offset);
 
     //r_offset += E;
 
@@ -1616,10 +1610,10 @@ void *nr_dlsch_decoding_2thread0(void *arg)
                             Kr,r,harq_process->C,harq_process->nb_rb,crc_type,A,harq_process->TBS,
                             harq_process->B,harq_process->mcs,harq_process->Qm,harq_process->rvidx,harq_process->round,dlsch->max_ldpc_iterations);
 */
-    	if (llr8_flag1) {
-    		AssertFatal (Kr >= 256, "turbo algo issue Kr=%d cb_cnt=%d C=%d nbRB=%d TBSInput=%d TBSHarq=%d TBSplus24=%d mcs=%d Qm=%d RIV=%d round=%d\n",
-    				Kr,r,harq_process->C,harq_process->nb_rb,A,harq_process->TBS,harq_process->B,harq_process->mcs,harq_process->Qm,harq_process->rvidx,harq_process->round);
-    	}
+      if (llr8_flag1) {
+        AssertFatal (Kr >= 256, "turbo algo issue Kr=%d cb_cnt=%d C=%d nbRB=%d TBSInput=%d TBSHarq=%d TBSplus24=%d mcs=%d Qm=%d RIV=%d round=%d\n",
+            Kr,r,harq_process->C,harq_process->nb_rb,A,harq_process->TBS,harq_process->B,harq_process->mcs,harq_process->Qm,harq_process->rvidx,harq_process->round);
+      }
 #if UE_TIMING_TRACE
         start_meas(dlsch_turbo_decoding_stats);
 #endif
@@ -1634,58 +1628,58 @@ void *nr_dlsch_decoding_2thread0(void *arg)
         memset((pv+K_bytes_F),127,harq_process->F*sizeof(int16_t));
 
         for (i=((2*p_decParams->Z)>>3), j = 0; i < K_bytes_F+((2*p_decParams->Z)>>3); i++, j++)
-      	{
-      		pv[i]= _mm_loadu_si128((__m128i*)(&inv_d[8*j]));
-      	}
+        {
+          pv[i]= _mm_loadu_si128((__m128i*)(&inv_d[8*j]));
+        }
 
-		for (i=Kr_bytes+((2*p_decParams->Z)>>3),j=Kr_bytes; i < ((kc*p_decParams->Z)>>3); i++, j++)
-		      	{
-		      		pv[i]= _mm_loadu_si128((__m128i*)(&inv_d[8*j]));
-		      	}
+    for (i=Kr_bytes+((2*p_decParams->Z)>>3),j=Kr_bytes; i < ((kc*p_decParams->Z)>>3); i++, j++)
+            {
+              pv[i]= _mm_loadu_si128((__m128i*)(&inv_d[8*j]));
+            }
 
-		for (i=0, j=0; j < ((kc*p_decParams->Z)>>4);  i+=2, j++)
-      	      	{
+    for (i=0, j=0; j < ((kc*p_decParams->Z)>>4);  i+=2, j++)
+                {
 
-      	      		pl[j] = _mm_packs_epi16(pv[i],pv[i+1]);
+                  pl[j] = _mm_packs_epi16(pv[i],pv[i+1]);
 
-      	      	}
+                }
 
-		no_iteration_ldpc = nrLDPC_decoder(p_decParams,
-						   (int8_t*)&pl[0],
-						   llrProcBuf,
+    no_iteration_ldpc = nrLDPC_decoder(p_decParams,
+               (int8_t*)&pl[0],
+               llrProcBuf,
                            p_nrLDPC_procBuf,                
-						   p_procTime);
+               p_procTime);
 
-		if (no_iteration_ldpc > 10)
-			printf("Error number of iteration LPDC %d\n", no_iteration_ldpc);
-		//else
-			//printf("OK number of iteration LPDC %d\n", no_iteration_ldpc);
+    if (no_iteration_ldpc > 10)
+      printf("Error number of iteration LPDC %d\n", no_iteration_ldpc);
+    //else
+      //printf("OK number of iteration LPDC %d\n", no_iteration_ldpc);
 
-		for (int m=0; m < Kr>>3; m ++)
-		      	      	{
-		      				harq_process->c[r][m]= (uint8_t) llrProcBuf[m];
-		      	      	}
+    for (int m=0; m < Kr>>3; m ++)
+                    {
+                  harq_process->c[r][m]= (uint8_t) llrProcBuf[m];
+                    }
 
-		      	/*for (int u=0; u < Kr>>3; u ++)
-		      	      	      	{
-		      						ullrProcBuf[u]= (uint8_t) llrProcBuf[u];
-		      	      	      	}
+            /*for (int u=0; u < Kr>>3; u ++)
+                            {
+                      ullrProcBuf[u]= (uint8_t) llrProcBuf[u];
+                            }
 
 
-		      	printf("output unsigned ullrProcBuf \n");
+            printf("output unsigned ullrProcBuf \n");
 
-		      	for (int j=0; j < Kr>>3; j ++)
-		      	      	       	      	{
+            for (int j=0; j < Kr>>3; j ++)
+                                    {
 
-		      	      						printf(" %d \n", ullrProcBuf[j]);
+                              printf(" %d \n", ullrProcBuf[j]);
 
-		      	      	      	      	}
-		     	printf(" \n");*/
-#ifdef DEBUG_DLSCH_DECODING	     	
-	for (int k=0;k<2;k++)
-  		printf("segment 1 output decoder [%d] =  0x%02x \n", k, harq_process->c[r][k]);
+                                    }
+          printf(" \n");*/
+#ifdef DEBUG_DLSCH_DECODING       
+  for (int k=0;k<2;k++)
+      printf("segment 1 output decoder [%d] =  0x%02x \n", k, harq_process->c[r][k]);
 #endif 
-		
+    
 #if UE_TIMING_TRACE
       stop_meas(dlsch_turbo_decoding_stats);
 #endif
@@ -1818,7 +1812,7 @@ void *nr_dlsch_decoding_2thread0(void *arg)
 #define FIFO_PRIORITY   39
 void *nr_dlsch_decoding_2thread1(void *arg)
 {
-	static __thread int UE_dlsch_td_retval1;
+  static __thread int UE_dlsch_td_retval1;
     struct nr_rxtx_thread_data *rtd = arg;
     UE_nr_rxtx_proc_t *proc = rtd->proc;
     PHY_VARS_NR_UE    *phy_vars_ue   = rtd->UE;
@@ -1860,14 +1854,14 @@ void *nr_dlsch_decoding_2thread1(void *arg)
     char threadname[256];
     sprintf(threadname,"UE_thread_dlsch_td1_%d", proc->sub_frame_start);
 
-	cpu_set_t cpuset;
+  cpu_set_t cpuset;
     CPU_ZERO(&cpuset);
     if ( (proc->sub_frame_start+1)%RX_NB_TH == 0 && threads.dlsch_td_one != -1 )
-    	CPU_SET(threads.dlsch_td_one, &cpuset);
+      CPU_SET(threads.dlsch_td_one, &cpuset);
     if ( (proc->sub_frame_start+1)%RX_NB_TH == 1 && threads.dlsch_td_two != -1 )
-    	CPU_SET(threads.dlsch_td_two, &cpuset);
+      CPU_SET(threads.dlsch_td_two, &cpuset);
     if ( (proc->sub_frame_start+1)%RX_NB_TH == 2 && threads.dlsch_td_three != -1 )
-    	CPU_SET(threads.dlsch_td_three, &cpuset);
+      CPU_SET(threads.dlsch_td_three, &cpuset);
 
 
 
@@ -1881,51 +1875,51 @@ void *nr_dlsch_decoding_2thread1(void *arg)
     uint32_t ret,offset;
     uint32_t r,r_offset=0,Kr,Kr_bytes,err_flag=0,K_bytes_F;
     uint8_t crc_type;
-  	uint8_t C,Cprime;
+    uint8_t C,Cprime;
     uint8_t Qm;
-   	uint8_t Nl;
+    uint8_t Nl;
     //uint32_t Er;
 
-	init_thread(900000,1000000 , FIFO_PRIORITY-1, &cpuset, threadname);
-	printf("2thread1 oai_exit %d\n", oai_exit);
-	while (!oai_exit) {
-	        if (pthread_mutex_lock(&proc->mutex_dlsch_td1) != 0) {
-	            LOG_E( PHY, "[SCHED][UE] error locking mutex for UE dlsch td\n" );
-	            exit_fun("nothing to add");
-	        }
-	        while (proc->instance_cnt_dlsch_td1 < 0) {
-	            // most of the time, the thread is waiting here
-	            pthread_cond_wait( &proc->cond_dlsch_td1, &proc->mutex_dlsch_td1 );
-	        }
-	        if (pthread_mutex_unlock(&proc->mutex_dlsch_td1) != 0) {
-	            LOG_E( PHY, "[SCHED][UE] error unlocking mutex for UE dlsch_td \n" );
-	            exit_fun("nothing to add");
-	        }
+  init_thread(900000,1000000 , FIFO_PRIORITY-1, &cpuset, threadname);
+  printf("2thread1 oai_exit %d\n", oai_exit);
+  while (!oai_exit) {
+          if (pthread_mutex_lock(&proc->mutex_dlsch_td1) != 0) {
+              LOG_E( PHY, "[SCHED][UE] error locking mutex for UE dlsch td\n" );
+              exit_fun("nothing to add");
+          }
+          while (proc->instance_cnt_dlsch_td1 < 0) {
+              // most of the time, the thread is waiting here
+              pthread_cond_wait( &proc->cond_dlsch_td1, &proc->mutex_dlsch_td1 );
+          }
+          if (pthread_mutex_unlock(&proc->mutex_dlsch_td1) != 0) {
+              LOG_E( PHY, "[SCHED][UE] error unlocking mutex for UE dlsch_td \n" );
+              exit_fun("nothing to add");
+          }
 
-	        //printf("2thread1 main available %d\n", proc->decoder_main_available);
+          //printf("2thread1 main available %d\n", proc->decoder_main_available);
 
-	        uint32_t wait = 0;
-	        	          while(proc->decoder_main_available == 0)
-	        	          {
-	        	                  usleep(1);
-	        	                  wait++;
-	        	          }
-	        	
-	        //proc->decoder_thread_available1 = 0;
-	        //PHY_VARS_NR_UE *phy_vars_ue   		= tdp->UE;
-	        int eNB_id         				= proc->eNB_id;
-	        int harq_pid      				= proc->harq_pid;
-	        llr8_flag1     					= proc->llr8_flag;
-	        //r_offset						= proc->Er;
-	        //UE_rxtx_proc_t *proc    		= tdp->proc;
-	        int frame                       = proc->frame_rx;
-	        int subframe      				= proc->nr_tti_rx;
-	        NR_UE_DLSCH_t *dlsch 			= phy_vars_ue->dlsch[phy_vars_ue->current_thread_id[subframe]][eNB_id][0];
-	        NR_DL_UE_HARQ_t *harq_process  = dlsch->harq_processes[harq_pid];
-	        short *dlsch_llr 				= phy_vars_ue->pdsch_vars[phy_vars_ue->current_thread_id[subframe]][eNB_id]->llr[0];
-	        //printf("2thread0 llr flag %d tdp flag %d\n",llr8_flag1, tdp->llr8_flag);
-	        //printf("2thread1 nr_tti_tx %d subframe %d SF thread id %d r_offset %d\n", proc->nr_tti_rx, subframe, phy_vars_ue->current_thread_id[subframe], r_offset);
-	        p_nrLDPC_procBuf = harq_process->p_nrLDPC_procBuf[2];
+          uint32_t wait = 0;
+                      while(proc->decoder_main_available == 0)
+                      {
+                              usleep(1);
+                              wait++;
+                      }
+            
+          //proc->decoder_thread_available1 = 0;
+          //PHY_VARS_NR_UE *phy_vars_ue       = tdp->UE;
+          int eNB_id                = proc->eNB_id;
+          int harq_pid              = proc->harq_pid;
+          llr8_flag1              = proc->llr8_flag;
+          //r_offset            = proc->Er;
+          //UE_rxtx_proc_t *proc        = tdp->proc;
+          int frame                       = proc->frame_rx;
+          int subframe              = proc->nr_tti_rx;
+          NR_UE_DLSCH_t *dlsch      = phy_vars_ue->dlsch[phy_vars_ue->current_thread_id[subframe]][eNB_id][0];
+          NR_DL_UE_HARQ_t *harq_process  = dlsch->harq_processes[harq_pid];
+          short *dlsch_llr        = phy_vars_ue->pdsch_vars[phy_vars_ue->current_thread_id[subframe]][eNB_id]->llr[0];
+          //printf("2thread0 llr flag %d tdp flag %d\n",llr8_flag1, tdp->llr8_flag);
+          //printf("2thread1 nr_tti_tx %d subframe %d SF thread id %d r_offset %d\n", proc->nr_tti_rx, subframe, phy_vars_ue->current_thread_id[subframe], r_offset);
+          p_nrLDPC_procBuf = harq_process->p_nrLDPC_procBuf[2];
 
   /*
   if (nb_rb > frame_parms->N_RB_DL) {
@@ -1960,27 +1954,27 @@ void *nr_dlsch_decoding_2thread1(void *arg)
     // This is a new packet, so compute quantities regarding segmentation
     harq_process->B = A+24;
     nr_segmentation(NULL,
-        	          NULL,
-        	          harq_process->B,
-        	          &harq_process->C,
-        	          &harq_process->K,
-         		  &harq_process->Z,
-        	          &harq_process->F);
-        			  p_decParams->Z = harq_process->Z;
+                    NULL,
+                    harq_process->B,
+                    &harq_process->C,
+                    &harq_process->K,
+              &harq_process->Z,
+                    &harq_process->F);
+                p_decParams->Z = harq_process->Z;
 
     }
 
     kb = harq_process->K/harq_process->Z;
-  	  if ( kb==22){
-  		  p_decParams->BG = 1;
-  		  p_decParams->R = 89;
-  		  kc = 68;
-  	  }
-  	  else{
-  		  p_decParams->BG = 2;
-  		  p_decParams->R = 13;
-  		  kc = 52;
-  	  	  }
+      if ( kb==22){
+        p_decParams->BG = 1;
+        p_decParams->R = 89;
+        kc = 68;
+      }
+      else{
+        p_decParams->BG = 2;
+        p_decParams->R = 13;
+        kc = 52;
+          }
 
     p_decParams->numMaxIter = 2;
     Kr = p_decParams->Z*kb;
@@ -2025,23 +2019,23 @@ void *nr_dlsch_decoding_2thread1(void *arg)
   Cprime = C; //assume CBGTI not present
 
   if (r <= Cprime - ((G/(Nl*Qm))%Cprime) - 1)
-	  r_offset = Nl*Qm*(G/(Nl*Qm*Cprime));
+    r_offset = Nl*Qm*(G/(Nl*Qm*Cprime));
   else
-	  r_offset = Nl*Qm*((G/(Nl*Qm*Cprime))+1);
+    r_offset = Nl*Qm*((G/(Nl*Qm*Cprime))+1);
 
-  	       //printf("sub thread r_offset %d\n", r_offset);
+           //printf("sub thread r_offset %d\n", r_offset);
 
   //for (r=(harq_process->C/2); r<harq_process->C; r++) {
-  	     r=2; //(harq_process->C/2);
-  	   r_offset = r*r_offset;
-	 //printf("thread1 r=%d r_offset %d \n",r, r_offset);
+         r=2; //(harq_process->C/2);
+       r_offset = r*r_offset;
+   //printf("thread1 r=%d r_offset %d \n",r, r_offset);
 
 
-  	  Kr = harq_process->K;
-  	  Kr_bytes = Kr>>3;
-  	  K_bytes_F = Kr_bytes-(harq_process->F>>3);
+      Kr = harq_process->K;
+      Kr_bytes = Kr>>3;
+      K_bytes_F = Kr_bytes-(harq_process->F>>3);
 
-  	  Tbslbrm = nr_compute_tbs(28,nb_rb,frame_parms->symbols_per_slot,0,0, harq_process->Nl);
+      Tbslbrm = nr_compute_tbs(28,nb_rb,frame_parms->symbols_per_slot,0,0, harq_process->Nl);
 
     E = nr_get_E(G, harq_process->C, harq_process->Qm, harq_process->Nl, r);
 
@@ -2059,7 +2053,7 @@ void *nr_dlsch_decoding_2thread1(void *arg)
                            dlsch_llr+r_offset);
 
     //for (int i =0; i<16; i++)
-    //        	printf("rx output deinterleaving w[%d]= %d r_offset %d\n", i,harq_process->w[r][i], r_offset);
+    //          printf("rx output deinterleaving w[%d]= %d r_offset %d\n", i,harq_process->w[r][i], r_offset);
 
 #if UE_TIMING_TRACE
     stop_meas(dlsch_deinterleaving_stats);
@@ -2082,15 +2076,15 @@ void *nr_dlsch_decoding_2thread1(void *arg)
 #endif
 
     if (nr_rate_matching_ldpc_rx(Ilbrm,
-     	 	 	 	 Tbslbrm,
-				 p_decParams->BG,
-				 p_decParams->Z,
-				 harq_process->d[r],
-				 harq_process->w[r],
-				 harq_process->C,
-				 harq_process->rvidx,
-				 (harq_process->round==0)?1:0,
-				 E)==-1) {
+             Tbslbrm,
+         p_decParams->BG,
+         p_decParams->Z,
+         harq_process->d[r],
+         harq_process->w[r],
+         harq_process->C,
+         harq_process->rvidx,
+         (harq_process->round==0)?1:0,
+         E)==-1) {
 #if UE_TIMING_TRACE
       stop_meas(dlsch_rate_unmatching_stats);
 #endif
@@ -2104,7 +2098,7 @@ void *nr_dlsch_decoding_2thread1(void *arg)
     }
 
     //for (int i =0; i<16; i++)
-    //    	printf("rx output ratematching d[%d]= %d r_offset %d\n", i,harq_process->d[r][i], r_offset);
+    //      printf("rx output ratematching d[%d]= %d r_offset %d\n", i,harq_process->d[r][i], r_offset);
 
     //r_offset += E;
 
@@ -2136,71 +2130,71 @@ void *nr_dlsch_decoding_2thread1(void *arg)
                             Kr,r,harq_process->C,harq_process->nb_rb,crc_type,A,harq_process->TBS,
                             harq_process->B,harq_process->mcs,harq_process->Qm,harq_process->rvidx,harq_process->round,dlsch->max_ldpc_iterations);
 */
-    	if (llr8_flag1) {
-    		AssertFatal (Kr >= 256, "turbo algo issue Kr=%d cb_cnt=%d C=%d nbRB=%d TBSInput=%d TBSHarq=%d TBSplus24=%d mcs=%d Qm=%d RIV=%d round=%d\n",
-    				Kr,r,harq_process->C,harq_process->nb_rb,A,harq_process->TBS,harq_process->B,harq_process->mcs,harq_process->Qm,harq_process->rvidx,harq_process->round);
-    	}
+      if (llr8_flag1) {
+        AssertFatal (Kr >= 256, "turbo algo issue Kr=%d cb_cnt=%d C=%d nbRB=%d TBSInput=%d TBSHarq=%d TBSplus24=%d mcs=%d Qm=%d RIV=%d round=%d\n",
+            Kr,r,harq_process->C,harq_process->nb_rb,A,harq_process->TBS,harq_process->B,harq_process->mcs,harq_process->Qm,harq_process->rvidx,harq_process->round);
+      }
 #if UE_TIMING_TRACE
         start_meas(dlsch_turbo_decoding_stats);
 #endif
 //      LOG_D(PHY,"AbsSubframe %d.%d Start turbo segment %d/%d \n",frame%1024,subframe,r,harq_process->C-1);
 
-		memset(pv,0,2*p_decParams->Z*sizeof(int16_t));
+    memset(pv,0,2*p_decParams->Z*sizeof(int16_t));
         //memset(pl,0,2*p_decParams->Z*sizeof(int8_t));
-		memset((pv+K_bytes_F),127,harq_process->F*sizeof(int16_t));
+    memset((pv+K_bytes_F),127,harq_process->F*sizeof(int16_t));
 
         for (i=((2*p_decParams->Z)>>3), j = 0; i < K_bytes_F+((2*p_decParams->Z)>>3); i++, j++)
-      	{
-      		pv[i]= _mm_loadu_si128((__m128i*)(&inv_d[8*j]));
-      	}
+        {
+          pv[i]= _mm_loadu_si128((__m128i*)(&inv_d[8*j]));
+        }
 
-		for (i=Kr_bytes+((2*p_decParams->Z)>>3),j=Kr_bytes; i < ((kc*p_decParams->Z)>>3); i++, j++)
-		      	{
-		      		pv[i]= _mm_loadu_si128((__m128i*)(&inv_d[8*j]));
-		      	}
+    for (i=Kr_bytes+((2*p_decParams->Z)>>3),j=Kr_bytes; i < ((kc*p_decParams->Z)>>3); i++, j++)
+            {
+              pv[i]= _mm_loadu_si128((__m128i*)(&inv_d[8*j]));
+            }
 
-		for (i=0, j=0; j < ((kc*p_decParams->Z)>>4);  i+=2, j++)
-      	      	{
+    for (i=0, j=0; j < ((kc*p_decParams->Z)>>4);  i+=2, j++)
+                {
 
-      	      		pl[j] = _mm_packs_epi16(pv[i],pv[i+1]);
+                  pl[j] = _mm_packs_epi16(pv[i],pv[i+1]);
 
-      	      	}
+                }
 
-		no_iteration_ldpc = nrLDPC_decoder(p_decParams,
-						   (int8_t*)&pl[0],
-						   llrProcBuf,
+    no_iteration_ldpc = nrLDPC_decoder(p_decParams,
+               (int8_t*)&pl[0],
+               llrProcBuf,
                            p_nrLDPC_procBuf,                
-						   p_procTime);
+               p_procTime);
 
-		if (no_iteration_ldpc > 10)
-			printf("Error number of iteration LPDC %d\n", no_iteration_ldpc);
-		//else
-		//	printf("OK number of iteration LPDC %d\n", no_iteration_ldpc);
+    if (no_iteration_ldpc > 10)
+      printf("Error number of iteration LPDC %d\n", no_iteration_ldpc);
+    //else
+    //  printf("OK number of iteration LPDC %d\n", no_iteration_ldpc);
 
-		for (int m=0; m < Kr>>3; m ++)
-		      	      	{
-		      				harq_process->c[r][m]= (uint8_t) llrProcBuf[m];
-		      	      	}
+    for (int m=0; m < Kr>>3; m ++)
+                    {
+                  harq_process->c[r][m]= (uint8_t) llrProcBuf[m];
+                    }
 
-		      	/*for (int u=0; u < Kr>>3; u ++)
-		      	      	      	{
-		      						ullrProcBuf[u]= (uint8_t) llrProcBuf[u];
-		      	      	      	}
+            /*for (int u=0; u < Kr>>3; u ++)
+                            {
+                      ullrProcBuf[u]= (uint8_t) llrProcBuf[u];
+                            }
 
 
-		      	printf("output unsigned ullrProcBuf \n");
+            printf("output unsigned ullrProcBuf \n");
 
-		      	for (int j=0; j < Kr>>3; j ++)
-		      	      	       	      	{
+            for (int j=0; j < Kr>>3; j ++)
+                                    {
 
-		      	      						printf(" %d \n", ullrProcBuf[j]);
+                              printf(" %d \n", ullrProcBuf[j]);
 
-		      	      	      	      	}
-		     	printf(" \n");*/
+                                    }
+          printf(" \n");*/
 #endif
-		//printf("output channel decoder %d %d %d %d %d \n", harq_process->c[r][0], harq_process->c[r][1], harq_process->c[r][2],harq_process->c[r][3], harq_process->c[r][4]);
+    //printf("output channel decoder %d %d %d %d %d \n", harq_process->c[r][0], harq_process->c[r][1], harq_process->c[r][2],harq_process->c[r][3], harq_process->c[r][4]);
 
-		 //printf("output decoder %d %d %d %d %d \n", harq_process->c[r][0], harq_process->c[r][1], harq_process->c[r][2],harq_process->c[r][3], harq_process->c[r][4]);
+     //printf("output decoder %d %d %d %d %d \n", harq_process->c[r][0], harq_process->c[r][1], harq_process->c[r][2],harq_process->c[r][3], harq_process->c[r][4]);
 
 #if UE_TIMING_TRACE
       stop_meas(dlsch_turbo_decoding_stats);
@@ -2239,7 +2233,7 @@ void *nr_dlsch_decoding_2thread1(void *arg)
           //printf("end 2thread1 proc->instance_cnt_dlsch_td1 %d\n", proc->instance_cnt_dlsch_td1);
       }
 
-	//printf("after 2thread1 after oai exit proc->instance_cnt_dlsch_td %d\n", proc->instance_cnt_dlsch_td1);
+  //printf("after 2thread1 after oai exit proc->instance_cnt_dlsch_td %d\n", proc->instance_cnt_dlsch_td1);
       // thread finished
           free(arg);
           return &UE_dlsch_td_retval1;
diff --git a/openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_demodulation.c b/openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_demodulation.c
index ca0aa50d0e..4bdc30540d 100644
--- a/openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_demodulation.c
+++ b/openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_demodulation.c
@@ -36,6 +36,7 @@
 //#include "extern.h"
 #include "PHY/sse_intrin.h"
 #include "T.h"
+#include "openair1/PHY/NR_TRANSPORT/nr_dlsch.h"
 
 #ifndef USER_MODE
 #define NOCYGWIN_STATIC static
@@ -84,6 +85,20 @@ unsigned char offset_mumimo_llr_drange[29][3]={{8,8,8},{7,7,7},{7,7,7},{7,7,7},{
 
 extern void print_shorts(char *s,int16_t *x);
 
+static void nr_dlsch_dual_stream_correlation_core(int **dl_ch_estimates_ext,
+						  int **dl_ch_estimates_ext_i,
+						  int **dl_ch_rho_ext,
+						  unsigned char n_tx,
+						  unsigned char n_rx,
+						  unsigned char output_shift,
+						  int length,
+						  int start_point);
+
+static void nr_dlsch_layer_demapping(int16_t **llr_cw,
+				     uint8_t Nl,
+				     uint8_t mod_order,
+				     uint16_t length,
+				     int16_t **llr_layers);
 
 int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
              PDSCH_t type,
@@ -112,14 +127,13 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
   uint8_t slot = 0;
 #endif
 
-  unsigned char aatx,aarx;
+  unsigned char aatx=0,aarx=0;
 
-  unsigned short nb_rb = 0, nb_re =0, round;
+  unsigned short nb_rb = 0, round;
   int avgs = 0;// rb;
   NR_DL_UE_HARQ_t *dlsch0_harq,*dlsch1_harq = 0;
 
   uint8_t beamforming_mode;
-  uint32_t *rballoc;
 
   int32_t **rxdataF_comp_ptr;
   int32_t **dl_ch_mag_ptr;
@@ -131,11 +145,16 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
   unsigned short nb_rb_pdsch = 50;
   int16_t  *pllr_symbol_cw0;
   int16_t  *pllr_symbol_cw1;
+  int16_t  *pllr_symbol_layer0;
+  int16_t  *pllr_symbol_layer1;
   //int16_t  *pllr_symbol_cw0_deint;
   //int16_t  *pllr_symbol_cw1_deint;
   uint32_t llr_offset_symbol;
   //uint16_t bundle_L = 2;
-  uint8_t l0 =2;
+  uint8_t l0 =2, pilots=0;
+  uint16_t n_tx=1, n_rx=1;
+  int32_t median[16];
+  uint32_t len;
   
   switch (type) {
   case SI_PDSCH:
@@ -155,16 +174,9 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
   case PDSCH:
     pdsch_vars = ue->pdsch_vars[ue->current_thread_id[nr_tti_rx]];
     dlsch = ue->dlsch[ue->current_thread_id[nr_tti_rx]][eNB_id];
-    
-    
-  //set active for testing -> to be removed
-  dlsch[0]->harq_processes[harq_pid]->status = ACTIVE;
-  dlsch[0]->harq_processes[harq_pid]->Qm = 2;
-  dlsch[0]->harq_processes[harq_pid]->mcs = 9;
-  dlsch[0]->harq_processes[harq_pid]->Nl=1;
-  dlsch[0]->harq_processes[harq_pid]->round=0;
-  dlsch[0]->harq_processes[harq_pid]->nb_rb = nb_rb_pdsch;
-  frame_parms->nushift = 0;
+
+
+  dlsch[0]->harq_processes[harq_pid]->Qm = nr_get_Qm(dlsch[0]->harq_processes[harq_pid]->mcs, 1);;
   
   //printf("status TB0 = %d, status TB1 = %d \n", dlsch[0]->harq_processes[harq_pid]->status, dlsch[1]->harq_processes[harq_pid]->status);
     LOG_D(PHY,"AbsSubframe %d.%d / Sym %d harq_pid %d,  harq status %d.%d \n",
@@ -203,14 +215,14 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
 #endif
     }
     else {
-      LOG_E(PHY,"[UE][FATAL] Frame %d nr_tti_rx %d: no active DLSCH\n",ue->proc.proc_rxtx[0].frame_rx,nr_tti_rx);
+      LOG_E(PHY,"[UE][FATAL] nr_tti_rx %d: no active DLSCH\n",nr_tti_rx);
       return(-1);
     }
     beamforming_mode  = ue->transmission_mode[eNB_id]<7?0:ue->transmission_mode[eNB_id];
     break;
 
   default:
-    LOG_E(PHY,"[UE][FATAL] Frame %d nr_tti_rx %d: Unknown PDSCH format %d\n",ue->proc.proc_rxtx[0].frame_rx,nr_tti_rx,type);
+    LOG_E(PHY,"[UE][FATAL] nr_tti_rx %d: Unknown PDSCH format %d\n",nr_tti_rx,type);
     return(-1);
     break;
   }
@@ -219,6 +231,10 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
   printf("[DEMOD] cw for TB0 = %d, cw for TB1 = %d\n", codeword_TB0, codeword_TB1);
 #endif
 
+  start_rb = dlsch0_harq->start_rb;
+  nb_rb_pdsch =  dlsch0_harq->nb_rb;
+  l0 = dlsch0_harq->start_symbol;
+
   DevAssert(dlsch0_harq);
   round = dlsch0_harq->round;
   //printf("round = %d\n", round);
@@ -248,25 +264,14 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
     return(-1);
   }
 
-  if (((frame_parms->Ncp == NORMAL) && (symbol>=7)) ||
-      ((frame_parms->Ncp == EXTENDED) && (symbol>=6)))
-    rballoc = dlsch0_harq->rb_alloc_odd;
-  else
-    rballoc = dlsch0_harq->rb_alloc_even;
-
-
-  if (dlsch0_harq->mimo_mode>DUALSTREAM_PUSCH_PRECODING) {
+  if (dlsch0_harq->mimo_mode>NR_DUALSTREAM) {
     LOG_E(PHY,"This transmission mode is not yet supported!\n");
     return(-1);
   }
 
 
-  if ((dlsch0_harq->mimo_mode==LARGE_CDD) || ((dlsch0_harq->mimo_mode>=DUALSTREAM_UNIFORM_PRECODING1) && (dlsch0_harq->mimo_mode<=DUALSTREAM_PUSCH_PRECODING)))  {
+  if (dlsch0_harq->mimo_mode==NR_DUALSTREAM)  {
     DevAssert(dlsch1_harq);
-    if (eNB_id!=eNB_id_i) {
-      LOG_E(PHY,"TM3/TM4 requires to set eNB_id==eNB_id_i!\n");
-      return(-1);
-    }
   }
 
 #if UE_TIMING_TRACE
@@ -279,122 +284,87 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
 #ifdef DEBUG_HARQ
   printf("Demod  dlsch0_harq->pmi_alloc %d\n",  dlsch0_harq->pmi_alloc);
 #endif
-#if 0
+
+  pilots = (symbol==l0) ? 1 : 0;
+
   if (frame_parms->nb_antenna_ports_eNB>1 && beamforming_mode==0) {
 #ifdef DEBUG_DLSCH_MOD
-    LOG_I(PHY,"dlsch: using pmi %x (%p), rb_alloc %x\n",pmi2hex_2Ar1(dlsch0_harq->pmi_alloc),dlsch[0],dlsch0_harq->rb_alloc_even[0]);
+    LOG_I(PHY,"dlsch: using pmi %x (%p)\n",pmi2hex_2Ar1(dlsch0_harq->pmi_alloc),dlsch[0]);
 #endif
 
 #if UE_TIMING_TRACE
     start_meas(&ue->generic_stat_bis[ue->current_thread_id[nr_tti_rx]][slot]);
 #endif
-    nb_rb = dlsch_extract_rbs_dual(common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[nr_tti_rx]].rxdataF,
-                                   common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[nr_tti_rx]].dl_ch_estimates[eNB_id],
+    nb_rb = nr_dlsch_extract_rbs_dual(common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[nr_tti_rx]].rxdataF,
+    							   pdsch_vars[eNB_id]->dl_ch_estimates,
                                    pdsch_vars[eNB_id]->rxdataF_ext,
                                    pdsch_vars[eNB_id]->dl_ch_estimates_ext,
                                    dlsch0_harq->pmi_alloc,
                                    pdsch_vars[eNB_id]->pmi_ext,
-                                   rballoc,
                                    symbol,
+								   pilots,
+								   start_rb,
+								   nb_rb_pdsch,
                                    nr_tti_rx,
                                    ue->high_speed_flag,
                                    frame_parms,
                                    dlsch0_harq->mimo_mode);
 #ifdef DEBUG_DLSCH_MOD
-      printf("dlsch: using pmi %lx, rb_alloc %x, pmi_ext ",pmi2hex_2Ar1(dlsch0_harq->pmi_alloc),*rballoc);
+      printf("dlsch: using pmi %lx, pmi_ext ",pmi2hex_2Ar1(dlsch0_harq->pmi_alloc));
        for (rb=0;rb<nb_rb;rb++)
           printf("%d",pdsch_vars[eNB_id]->pmi_ext[rb]);
        printf("\n");
 #endif
 
-
    if (rx_type >= rx_IC_single_stream) {
       if (eNB_id_i<ue->n_connected_eNB) // we are in TM5
-      nb_rb = dlsch_extract_rbs_dual(common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[nr_tti_rx]].rxdataF,
-                                       common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[nr_tti_rx]].dl_ch_estimates[eNB_id_i],
+      nb_rb = nr_dlsch_extract_rbs_dual(common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[nr_tti_rx]].rxdataF,
+    		  	  	  	  	  	       pdsch_vars[eNB_id]->dl_ch_estimates,
                                        pdsch_vars[eNB_id_i]->rxdataF_ext,
                                        pdsch_vars[eNB_id_i]->dl_ch_estimates_ext,
                                        dlsch0_harq->pmi_alloc,
                                        pdsch_vars[eNB_id_i]->pmi_ext,
-                                       rballoc,
                                        symbol,
+									   pilots,
+									   start_rb,
+									   nb_rb_pdsch,
                                        nr_tti_rx,
                                        ue->high_speed_flag,
                                        frame_parms,
                                        dlsch0_harq->mimo_mode);
       else
-        nb_rb = dlsch_extract_rbs_dual(common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[nr_tti_rx]].rxdataF,
-                                       common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[nr_tti_rx]].dl_ch_estimates[eNB_id],
+        nb_rb = nr_dlsch_extract_rbs_dual(common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[nr_tti_rx]].rxdataF,
+        							   pdsch_vars[eNB_id]->dl_ch_estimates,
                                        pdsch_vars[eNB_id_i]->rxdataF_ext,
                                        pdsch_vars[eNB_id_i]->dl_ch_estimates_ext,
                                        dlsch0_harq->pmi_alloc,
                                        pdsch_vars[eNB_id_i]->pmi_ext,
-                                       rballoc,
                                        symbol,
+									   pilots,
+									   start_rb,
+									   nb_rb_pdsch,
                                        nr_tti_rx,
                                        ue->high_speed_flag,
                                        frame_parms,
                                        dlsch0_harq->mimo_mode);
     }
-  } else
-
-#endif
-	  if (beamforming_mode==0) { //else if nb_antennas_ports_eNB==1 && beamforming_mode == 0
+  } else if (beamforming_mode==0) { //else if nb_antennas_ports_eNB==1 && beamforming_mode == 0
 		  //printf("start nr dlsch extract nr_tti_rx %d thread id %d \n", nr_tti_rx, ue->current_thread_id[nr_tti_rx]);
     nb_rb = nr_dlsch_extract_rbs_single(common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[nr_tti_rx]].rxdataF,
-                                     common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[nr_tti_rx]].dl_ch_estimates[eNB_id],
+                                     pdsch_vars[eNB_id]->dl_ch_estimates,
                                      pdsch_vars[eNB_id]->rxdataF_ext,
                                      pdsch_vars[eNB_id]->dl_ch_estimates_ext,
                                      dlsch0_harq->pmi_alloc,
                                      pdsch_vars[eNB_id]->pmi_ext,
-                                     rballoc,
                                      symbol,
+									 pilots,
 									 start_rb,
 									 nb_rb_pdsch,
                                      nr_tti_rx,
                                      ue->high_speed_flag,
                                      frame_parms);
 
-
-/*
-   if (rx_type==rx_IC_single_stream) {
-     if (eNB_id_i<ue->n_connected_eNB)
-        nb_rb = dlsch_extract_rbs_single(common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[nr_tti_rx]].rxdataF,
-                                         common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[nr_tti_rx]].dl_ch_estimates[eNB_id_i],
-                                         pdsch_vars[eNB_id_i]->rxdataF_ext,
-                                         pdsch_vars[eNB_id_i]->dl_ch_estimates_ext,
-                                         dlsch0_harq->pmi_alloc,
-                                         pdsch_vars[eNB_id_i]->pmi_ext,
-                                         rballoc,
-                                         symbol,
-                                         nr_tti_rx,
-                                         ue->high_speed_flag,
-                                         frame_parms);
-      else
-        nb_rb = dlsch_extract_rbs_single(common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[nr_tti_rx]].rxdataF,
-                                         common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[nr_tti_rx]].dl_ch_estimates[eNB_id],
-                                         pdsch_vars[eNB_id_i]->rxdataF_ext,
-                                         pdsch_vars[eNB_id_i]->dl_ch_estimates_ext,
-                                         dlsch0_harq->pmi_alloc,
-                                         pdsch_vars[eNB_id_i]->pmi_ext,
-                                         rballoc,
-                                         symbol,
-                                         nr_tti_rx,
-                                         ue->high_speed_flag,
-                                         frame_parms);
-    }*/
-  } /*else if (beamforming_mode==7) { //else if beamforming_mode == 7
-    nb_rb = dlsch_extract_rbs_TM7(common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[nr_tti_rx]].rxdataF,
-                                  pdsch_vars[eNB_id]->dl_bf_ch_estimates,
-                                  pdsch_vars[eNB_id]->rxdataF_ext,
-                                  pdsch_vars[eNB_id]->dl_bf_ch_estimates_ext,
-                                  rballoc,
-                                  symbol,
-                                  nr_tti_rx,
-                                  ue->high_speed_flag,
-                                  frame_parms);
-
-  } else if(beamforming_mode>7) {
+  } /*else if(beamforming_mode>7) {
     LOG_W(PHY,"dlsch_demodulation: beamforming mode not supported yet.\n");
   }*/
 
@@ -404,6 +374,8 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
     return(-1);
   }
 
+  len = (symbol==l0)? (nb_rb*6):(nb_rb*12);
+
 #if UE_TIMING_TRACE
     stop_meas(&ue->generic_stat_bis[ue->current_thread_id[nr_tti_rx]][slot]);
 #if DISABLE_LOG_X
@@ -418,28 +390,16 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
 #if UE_TIMING_TRACE
     start_meas(&ue->generic_stat_bis[ue->current_thread_id[nr_tti_rx]][slot]);
 #endif
-  aatx = frame_parms->nb_antenna_ports_eNB;
-  aarx = frame_parms->nb_antennas_rx;
+  n_tx = frame_parms->nb_antenna_ports_eNB;
+  n_rx = frame_parms->nb_antennas_rx;
 
   nr_dlsch_scale_channel(pdsch_vars[eNB_id]->dl_ch_estimates_ext,
                       frame_parms,
                       dlsch,
                       symbol,
+					  pilots,
                       nb_rb);
 
-  if ((dlsch0_harq->mimo_mode<DUALSTREAM_UNIFORM_PRECODING1) &&
-      (rx_type==rx_IC_single_stream) &&
-      (eNB_id_i==ue->n_connected_eNB) &&
-      (dlsch0_harq->dl_power_off==0)
-     )  // TM5 two-user
-  {
-    nr_dlsch_scale_channel(pdsch_vars[eNB_id_i]->dl_ch_estimates_ext,
-                        frame_parms,
-                        dlsch,
-                        symbol,
-                        nb_rb);
-  }
-
 #if UE_TIMING_TRACE
     stop_meas(&ue->generic_stat_bis[ue->current_thread_id[nr_tti_rx]][slot]);
 #if DISABLE_LOG_X
@@ -454,11 +414,12 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
 #endif
   if (first_symbol_flag==1) {
     if (beamforming_mode==0){
-      if (dlsch0_harq->mimo_mode<LARGE_CDD) {
+      if (dlsch0_harq->mimo_mode<NR_DUALSTREAM) {
         nr_dlsch_channel_level(pdsch_vars[eNB_id]->dl_ch_estimates_ext,
                            frame_parms,
                            avg,
                            symbol,
+						   len,
                            nb_rb);
         avgs = 0;
         for (aatx=0;aatx<frame_parms->nb_antenna_ports_eNB;aatx++)
@@ -466,83 +427,36 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
             avgs = cmax(avgs,avg[(aatx<<1)+aarx]);
 
         pdsch_vars[eNB_id]->log2_maxh = (log2_approx(avgs)/2)+1;
-     }/*
-     else if ((dlsch0_harq->mimo_mode == LARGE_CDD) ||
-           ((dlsch0_harq->mimo_mode >=DUALSTREAM_UNIFORM_PRECODING1) &&
-            (dlsch0_harq->mimo_mode <=DUALSTREAM_PUSCH_PRECODING)))
+     }
+     else if (dlsch0_harq->mimo_mode == NR_DUALSTREAM)
      {
-      dlsch_channel_level_TM34(pdsch_vars[eNB_id]->dl_ch_estimates_ext,
-                                 frame_parms,
-                                 pdsch_vars[eNB_id]->pmi_ext,
-                                 avg_0,
-                                 avg_1,
-                                 symbol,
-                                 nb_rb,
-                                 dlsch0_harq->mimo_mode);
+    	 nr_dlsch_channel_level_median(pdsch_vars[eNB_id]->dl_ch_estimates_ext,
+    	                             median,
+    	                             n_tx,
+    	                             n_rx,
+    	                             2*len,// subcarriers Re Im
+    	                             0);
 
-      LOG_D(PHY,"Channel Level TM34  avg_0 %d, avg_1 %d, rx_type %d, rx_standard %d, dlsch_demod_shift %d \n", avg_0[0],
-              avg_1[0], rx_type, rx_standard, dlsch_demod_shift);
-        if (rx_type>rx_standard) {
-          avg_0[0] = (log2_approx(avg_0[0])/2) + dlsch_demod_shift;// + 2 ;//+ 4;
-          avg_1[0] = (log2_approx(avg_1[0])/2) + dlsch_demod_shift;// + 2 ;//+ 4;
-          pdsch_vars[eNB_id]->log2_maxh0 = cmax(avg_0[0],0);
-          pdsch_vars[eNB_id]->log2_maxh1 = cmax(avg_1[0],0);
-         // printf("dlsch_demod_shift  %d\n", dlsch_demod_shift);
-         }
-          else {
-          avg_0[0] = (log2_approx(avg_0[0])/2) - 13 + interf_unaw_shift;
-          avg_1[0] = (log2_approx(avg_1[0])/2) - 13 + interf_unaw_shift;
-          pdsch_vars[eNB_id]->log2_maxh0 = cmax(avg_0[0],0);
-          pdsch_vars[eNB_id]->log2_maxh1 = cmax(avg_1[0],0);
-        }
-      }
-      else if (dlsch0_harq->mimo_mode<DUALSTREAM_UNIFORM_PRECODING1) {// single-layer precoding (TM5, TM6)
-        if ((rx_type==rx_IC_single_stream) && (eNB_id_i==ue->n_connected_eNB) && (dlsch0_harq->dl_power_off==0)) {
-            dlsch_channel_level_TM56(pdsch_vars[eNB_id]->dl_ch_estimates_ext,
-                                frame_parms,
-                                pdsch_vars[eNB_id]->pmi_ext,
-                                avg,
-                                symbol,
-                                nb_rb);
-            avg[0] = log2_approx(avg[0]) - 13 + offset_mumimo_llr_drange[dlsch0_harq->mcs][(i_mod>>1)-1];
-            pdsch_vars[eNB_id]->log2_maxh = cmax(avg[0],0);
+    	  for (aatx = 0; aatx < n_tx; ++aatx)
+    	  {
+    	    for (aarx = 0; aarx < n_rx; ++aarx)
+    	    {
+    	      avgs = cmax(avgs, median[aatx*n_rx + aarx]);
+    	    }
+    	  }
 
-        }
-        else if (dlsch0_harq->dl_power_off==1) { //TM6
-
-          nr_dlsch_channel_level(pdsch_vars[eNB_id]->dl_ch_estimates_ext,
-                                   frame_parms,
-                                   avg,
-                                   symbol,
-                                   nb_rb);
-
-          avgs = 0;
-          for (aatx=0;aatx<frame_parms->nb_antenna_ports_eNB;aatx++)
-            for (aarx=0;aarx<frame_parms->nb_antennas_rx;aarx++)
-              avgs = cmax(avgs,avg[(aatx<<1)+aarx]);
-
-          pdsch_vars[eNB_id]->log2_maxh = (log2_approx(avgs)/2) + 1;
-          pdsch_vars[eNB_id]->log2_maxh++;
-
-        }
-      }
+    	  pdsch_vars[eNB_id]->log2_maxh = (log2_approx(avgs)/2) + 1; // this might need to be tuned
 
+     }
     }
-    else if (beamforming_mode==7)
-       dlsch_channel_level_TM7(pdsch_vars[eNB_id]->dl_bf_ch_estimates_ext,
-                              frame_parms,
-                              avg,
-                              symbol,
-                              nb_rb);*/
-    }
-//#ifdef UE_DEBUG_TRACE
+#ifdef UE_DEBUG_TRACE
     LOG_I(PHY,"[DLSCH] AbsSubframe %d.%d log2_maxh = %d [log2_maxh0 %d log2_maxh1 %d] (%d,%d)\n",
             frame%1024,nr_tti_rx, pdsch_vars[eNB_id]->log2_maxh,
                                                  pdsch_vars[eNB_id]->log2_maxh0,
                                                  pdsch_vars[eNB_id]->log2_maxh1,
                                                  avg[0],avgs);
     //LOG_D(PHY,"[DLSCH] mimo_mode = %d\n", dlsch0_harq->mimo_mode);
-//#endif
+#endif
 
     //wait until pdcch is decoded
     //proc->channel_level = 1;
@@ -579,7 +493,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
     start_meas(&ue->generic_stat_bis[ue->current_thread_id[nr_tti_rx]][slot]);
 #endif
 // Now channel compensation
-  if (dlsch0_harq->mimo_mode<LARGE_CDD) {
+  if (dlsch0_harq->mimo_mode<NR_DUALSTREAM) {
     nr_dlsch_channel_compensation(pdsch_vars[eNB_id]->rxdataF_ext,
                                pdsch_vars[eNB_id]->dl_ch_estimates_ext,
                                pdsch_vars[eNB_id]->dl_ch_mag0,
@@ -588,6 +502,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                                (aatx>1) ? pdsch_vars[eNB_id]->rho : NULL,
                                frame_parms,
                                symbol,
+							   pilots,
                                first_symbol_flag,
                                dlsch0_harq->Qm,
                                nb_rb,
@@ -629,22 +544,19 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
     }*/
   }
 
-#if 0
-  else if ((dlsch0_harq->mimo_mode == LARGE_CDD) || ((dlsch0_harq->mimo_mode >=DUALSTREAM_UNIFORM_PRECODING1) &&
-            (dlsch0_harq->mimo_mode <=DUALSTREAM_PUSCH_PRECODING))){
-      dlsch_channel_compensation_TM34(frame_parms,
-                                     pdsch_vars[eNB_id],
-                                     measurements,
-                                     eNB_id,
-                                     symbol,
-                                     dlsch0_harq->Qm,
-                                     dlsch1_harq->Qm,
-                                     harq_pid,
-                                     dlsch0_harq->round,
-                                     dlsch0_harq->mimo_mode,
-                                     nb_rb,
-                                     pdsch_vars[eNB_id]->log2_maxh0,
-                                     pdsch_vars[eNB_id]->log2_maxh1);
+  else if (dlsch0_harq->mimo_mode == NR_DUALSTREAM){
+	  nr_dlsch_channel_compensation_core(pdsch_vars[eNB_id]->rxdataF_ext,
+			  	  	  	  	  	  	  	pdsch_vars[eNB_id]->dl_ch_estimates_ext,
+										pdsch_vars[eNB_id]->dl_ch_mag0,
+										pdsch_vars[eNB_id]->dl_ch_magb0,
+										pdsch_vars[eNB_id]->rxdataF_comp0, //rxdataF_comp
+	                                    NULL,
+	                                    n_tx,
+	                                    n_rx,
+										dlsch0_harq->Qm,
+										pdsch_vars[eNB_id]->log2_maxh,
+	                                    2*len, // subcarriers Re Im
+	                                    0); // we start from the beginning of the vector
   /*   if (symbol == 5) {
      write_output("rxF_comp_d00.m","rxF_c_d00",&pdsch_vars[eNB_id]->rxdataF_comp0[0][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);// should be QAM
      write_output("rxF_comp_d01.m","rxF_c_d01",&pdsch_vars[eNB_id]->rxdataF_comp0[1][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);//should be almost 0
@@ -652,22 +564,23 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
      write_output("rxF_comp_d11.m","rxF_c_d11",&pdsch_vars[eNB_id]->rxdataF_comp1[harq_pid][round][1][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);//should be QAM
         } */
       // compute correlation between signal and interference channels (rho12 and rho21)
-        dlsch_dual_stream_correlation(frame_parms, // this is doing h11'*h12 and h21'*h22
-                                    symbol,
-                                    nb_rb,
-                                    pdsch_vars[eNB_id]->dl_ch_estimates_ext,
-                                    &(pdsch_vars[eNB_id]->dl_ch_estimates_ext[2]),
-                                    pdsch_vars[eNB_id]->dl_ch_rho2_ext,
-                                    pdsch_vars[eNB_id]->log2_maxh0);
+        nr_dlsch_dual_stream_correlation_core(pdsch_vars[eNB_id]->dl_ch_estimates_ext,
+        									 &(pdsch_vars[eNB_id]->dl_ch_estimates_ext[2]),
+											 pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
+                                             n_tx,
+                                             n_rx,
+											 pdsch_vars[eNB_id]->log2_maxh,
+                                             2*len,
+                                             0);
         //printf("rho stream1 =%d\n", &pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round] );
-      //to be optimized (just take complex conjugate)
-      dlsch_dual_stream_correlation(frame_parms, // this is doing h12'*h11 and h22'*h21
-                                    symbol,
-                                    nb_rb,
-                                    &(pdsch_vars[eNB_id]->dl_ch_estimates_ext[2]),
-                                    pdsch_vars[eNB_id]->dl_ch_estimates_ext,
-                                    pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
-                                    pdsch_vars[eNB_id]->log2_maxh1);
+        nr_dlsch_dual_stream_correlation_core(&(pdsch_vars[eNB_id]->dl_ch_estimates_ext[2]),
+        									pdsch_vars[eNB_id]->dl_ch_estimates_ext,
+											pdsch_vars[eNB_id]->dl_ch_rho2_ext,
+                                            n_tx,
+                                            n_rx,
+       										pdsch_vars[eNB_id]->log2_maxh,
+                                            2*len,
+                                            0);
     //  printf("rho stream2 =%d\n",&pdsch_vars[eNB_id]->dl_ch_rho2_ext );
       //printf("TM3 log2_maxh : %d\n",pdsch_vars[eNB_id]->log2_maxh);
   /*     if (symbol == 5) {
@@ -677,105 +590,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
      write_output("rho2_1.m","rho2_1",&pdsch_vars[eNB_id]->dl_ch_rho2_ext[1][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);//should be QAM
         } */
 
-    } else if (dlsch0_harq->mimo_mode<DUALSTREAM_UNIFORM_PRECODING1) {// single-layer precoding (TM5, TM6)
-        if ((rx_type==rx_IC_single_stream) && (eNB_id_i==ue->n_connected_eNB) && (dlsch0_harq->dl_power_off==0)) {
-          dlsch_channel_compensation_TM56(pdsch_vars[eNB_id]->rxdataF_ext,
-                                      pdsch_vars[eNB_id]->dl_ch_estimates_ext,
-                                      pdsch_vars[eNB_id]->dl_ch_mag0,
-                                      pdsch_vars[eNB_id]->dl_ch_magb0,
-                                      pdsch_vars[eNB_id]->rxdataF_comp0,
-                                      pdsch_vars[eNB_id]->pmi_ext,
-                                      frame_parms,
-                                      measurements,
-                                      eNB_id,
-                                      symbol,
-                                      dlsch0_harq->Qm,
-                                      nb_rb,
-                                      pdsch_vars[eNB_id]->log2_maxh,
-                                      dlsch0_harq->dl_power_off);
-
-        for (rb=0; rb<nb_rb; rb++) {
-          switch(pdsch_vars[eNB_id]->pmi_ext[rb]) {
-          case 0:
-            pdsch_vars[eNB_id_i]->pmi_ext[rb]=1;
-            break;
-         case 1:
-            pdsch_vars[eNB_id_i]->pmi_ext[rb]=0;
-            break;
-         case 2:
-            pdsch_vars[eNB_id_i]->pmi_ext[rb]=3;
-            break;
-          case 3:
-            pdsch_vars[eNB_id_i]->pmi_ext[rb]=2;
-            break;
-          }
-       //  if (rb==0)
-        //    printf("pmi %d, pmi_i %d\n",pdsch_vars[eNB_id]->pmi_ext[rb],pdsch_vars[eNB_id_i]->pmi_ext[rb]);
-      }
-      dlsch_channel_compensation_TM56(pdsch_vars[eNB_id_i]->rxdataF_ext,
-                                      pdsch_vars[eNB_id_i]->dl_ch_estimates_ext,
-                                      pdsch_vars[eNB_id_i]->dl_ch_mag0,
-                                      pdsch_vars[eNB_id_i]->dl_ch_magb0,
-                                      pdsch_vars[eNB_id_i]->rxdataF_comp0,
-                                      pdsch_vars[eNB_id_i]->pmi_ext,
-                                      frame_parms,
-                                      measurements,
-                                      eNB_id_i,
-                                      symbol,
-                                      i_mod,
-                                      nb_rb,
-                                      pdsch_vars[eNB_id]->log2_maxh,
-                                      dlsch0_harq->dl_power_off);
-#ifdef DEBUG_PHY
-      if (symbol==5) {
-        write_output("rxF_comp_d.m","rxF_c_d",&pdsch_vars[eNB_id]->rxdataF_comp0[0][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);
-       write_output("rxF_comp_i.m","rxF_c_i",&pdsch_vars[eNB_id_i]->rxdataF_comp0[0][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);
-      }
-#endif
-      dlsch_dual_stream_correlation(frame_parms,
-                                    symbol,
-                                    nb_rb,
-                                    pdsch_vars[eNB_id]->dl_ch_estimates_ext,
-                                    pdsch_vars[eNB_id_i]->dl_ch_estimates_ext,
-                                    pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
-                                    pdsch_vars[eNB_id]->log2_maxh);
-    }  else if (dlsch0_harq->dl_power_off==1)  {
-      dlsch_channel_compensation_TM56(pdsch_vars[eNB_id]->rxdataF_ext,
-                                      pdsch_vars[eNB_id]->dl_ch_estimates_ext,
-                                      pdsch_vars[eNB_id]->dl_ch_mag0,
-                                      pdsch_vars[eNB_id]->dl_ch_magb0,
-                                      pdsch_vars[eNB_id]->rxdataF_comp0,
-                                      pdsch_vars[eNB_id]->pmi_ext,
-                                      frame_parms,
-                                      measurements,
-                                      eNB_id,
-                                      symbol,
-                                      dlsch0_harq->Qm,
-                                      nb_rb,
-                                      pdsch_vars[eNB_id]->log2_maxh,
-                                      1);
-
-      }
-
-
-    } else if (dlsch0_harq->mimo_mode==TM7) { //TM7
-
-      nr_dlsch_channel_compensation(pdsch_vars[eNB_id]->rxdataF_ext,
-                                 pdsch_vars[eNB_id]->dl_bf_ch_estimates_ext,
-                                 pdsch_vars[eNB_id]->dl_ch_mag0,
-                                 pdsch_vars[eNB_id]->dl_ch_magb0,
-                                 pdsch_vars[eNB_id]->rxdataF_comp0,
-                                 (aatx>1) ? pdsch_vars[eNB_id]->rho : NULL,
-                                 frame_parms,
-                                 symbol,
-                                 first_symbol_flag,
-                                 get_Qm(dlsch0_harq->mcs),
-                                 nb_rb,
-                                 //9,
-                                 pdsch_vars[eNB_id]->log2_maxh,
-                                 measurements); // log2_maxh+I0_shift
-  }
-#endif
+    }
 
 #if UE_TIMING_TRACE
     stop_meas(&ue->generic_stat_bis[ue->current_thread_id[nr_tti_rx]][slot]);
@@ -790,65 +605,29 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
     start_meas(&ue->generic_stat_bis[ue->current_thread_id[nr_tti_rx]][slot]);
 #endif
 
-#if 0
     if (frame_parms->nb_antennas_rx > 1) {
-    if ((dlsch0_harq->mimo_mode == LARGE_CDD) ||
-        ((dlsch0_harq->mimo_mode >=DUALSTREAM_UNIFORM_PRECODING1) &&
-         (dlsch0_harq->mimo_mode <=DUALSTREAM_PUSCH_PRECODING))){  // TM3 or TM4
-      if (frame_parms->nb_antenna_ports_eNB == 2) {
-        dlsch_detection_mrc_TM34(frame_parms,
-                                 pdsch_vars[eNB_id],
-                                 harq_pid,
-                                 dlsch0_harq->round,
-                                 symbol,
-                                 nb_rb,
-                                 1);
+    if (dlsch0_harq->mimo_mode == NR_DUALSTREAM){
+        nr_dlsch_detection_mrc_core(pdsch_vars[eNB_id]->rxdataF_comp0,
+                                   NULL,
+								   pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
+								   pdsch_vars[eNB_id]->dl_ch_rho2_ext,
+								   pdsch_vars[eNB_id]->dl_ch_mag0,
+								   pdsch_vars[eNB_id]->dl_ch_magb0,
+                                   NULL,
+                                   NULL,
+                                   n_tx,
+                                   n_rx,
+                                   2*len,
+                                   0);
     /*   if (symbol == 5) {
      write_output("rho0_mrc.m","rho0_0",&pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round][0][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);// should be QAM
      write_output("rho2_mrc.m","rho2_0",&pdsch_vars[eNB_id]->dl_ch_rho2_ext[0][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);//should be almost 0
         } */
-      }
-    } else {
-      dlsch_detection_mrc(frame_parms,
-                          pdsch_vars[eNB_id]->rxdataF_comp0,
-                          pdsch_vars[eNB_id_i]->rxdataF_comp0,
-                          pdsch_vars[eNB_id]->rho,
-                          pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
-                          pdsch_vars[eNB_id]->dl_ch_mag0,
-                          pdsch_vars[eNB_id]->dl_ch_magb0,
-                          pdsch_vars[eNB_id_i]->dl_ch_mag0,
-                          pdsch_vars[eNB_id_i]->dl_ch_magb0,
-                          symbol,
-                          nb_rb,
-                          rx_type==rx_IC_single_stream);
     }
   }
-  //  printf("Combining");
-  if ((dlsch0_harq->mimo_mode == SISO) ||
-      ((dlsch0_harq->mimo_mode >= UNIFORM_PRECODING11) &&
-       (dlsch0_harq->mimo_mode <= PUSCH_PRECODING0)) ||
-       (dlsch0_harq->mimo_mode == TM7)) {
-    /*
-      dlsch_siso(frame_parms,
-      pdsch_vars[eNB_id]->rxdataF_comp,
-      pdsch_vars[eNB_id_i]->rxdataF_comp,
-      symbol,
-      nb_rb);
-    */
-  } else if (dlsch0_harq->mimo_mode == ALAMOUTI) {
-    dlsch_alamouti(frame_parms,
-                   pdsch_vars[eNB_id]->rxdataF_comp0,
-                   pdsch_vars[eNB_id]->dl_ch_mag0,
-                   pdsch_vars[eNB_id]->dl_ch_magb0,
-                   symbol,
-                   nb_rb);
-  }
-#endif
 
       //printf("start compute LLR\n");
-  if ((dlsch0_harq->mimo_mode == LARGE_CDD) ||
-      ((dlsch0_harq->mimo_mode >=DUALSTREAM_UNIFORM_PRECODING1) &&
-       (dlsch0_harq->mimo_mode <=DUALSTREAM_PUSCH_PRECODING)))  {
+  if (dlsch0_harq->mimo_mode == NR_DUALSTREAM)  {
     rxdataF_comp_ptr = pdsch_vars[eNB_id]->rxdataF_comp1[harq_pid][round];
     dl_ch_mag_ptr = pdsch_vars[eNB_id]->dl_ch_mag1[harq_pid][round];
   }
@@ -878,13 +657,16 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
   llr_offset_symbol = pdsch_vars[eNB_id]->llr_offset[symbol-1];
   //pllr_symbol_cw0_deint  = (int8_t*)pdsch_vars[eNB_id]->llr[0];
   //pllr_symbol_cw1_deint  = (int8_t*)pdsch_vars[eNB_id]->llr[1];
+  pllr_symbol_layer0 = pdsch_vars[eNB_id]->layer_llr[0];
+  pllr_symbol_layer1 = pdsch_vars[eNB_id]->layer_llr[1];
+  pllr_symbol_layer0 += llr_offset_symbol;
+  pllr_symbol_layer1 += llr_offset_symbol;
   pllr_symbol_cw0 = pdsch_vars[eNB_id]->llr[0];
   pllr_symbol_cw1 = pdsch_vars[eNB_id]->llr[1];
   pllr_symbol_cw0 += llr_offset_symbol;
   pllr_symbol_cw1 += llr_offset_symbol;
   
-  nb_re= (symbol==l0)? (nb_rb*6):(nb_rb*12);
-  pdsch_vars[eNB_id]->llr_offset[symbol] = nb_re*dlsch0_harq->Qm + llr_offset_symbol;
+  pdsch_vars[eNB_id]->llr_offset[symbol] = len*dlsch0_harq->Qm + llr_offset_symbol;
  
   /*LOG_I(PHY,"compute LLRs [symbol %d] NbRB %d Qm %d LLRs-Length %d LLR-Offset %d @LLR Buff %x @LLR Buff(symb) %x\n",
              symbol,
@@ -909,6 +691,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                        pdsch_vars[eNB_id]->rxdataF_comp0,
                        pllr_symbol_cw0,
                        symbol,
+					   len,
                        first_symbol_flag,
                        nb_rb,
                        beamforming_mode);
@@ -919,6 +702,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                        pdsch_vars[eNB_id]->rxdataF_comp0,
                        pllr_symbol_cw1,
                        symbol,
+					   len,
                        first_symbol_flag,
                        nb_rb,
                        beamforming_mode);
@@ -929,8 +713,8 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                               pdsch_vars[eNB_id]->rxdataF_comp0,
                               rxdataF_comp_ptr,
                               pdsch_vars[eNB_id]->dl_ch_rho2_ext,
-                              pdsch_vars[eNB_id]->llr[0],
-                              symbol,first_symbol_flag,nb_rb,
+                              pdsch_vars[eNB_id]->layer_llr[0],
+                              symbol,len,first_symbol_flag,nb_rb,
                               adjust_G2(frame_parms,dlsch0_harq->rb_alloc_even,2,nr_tti_rx,symbol),
                               pdsch_vars[eNB_id]->llr128);
           if (rx_type==rx_IC_dual_stream) {
@@ -938,8 +722,8 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                                 rxdataF_comp_ptr,
                                 pdsch_vars[eNB_id]->rxdataF_comp0,
                                 pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
-                                pdsch_vars[eNB_id]->llr[1],
-                                symbol,first_symbol_flag,nb_rb,
+                                pdsch_vars[eNB_id]->layer_llr[1],
+                                symbol,len,first_symbol_flag,nb_rb,
                                 adjust_G2(frame_parms,dlsch1_harq->rb_alloc_even,2,nr_tti_rx,symbol),
                                 pdsch_vars[eNB_id]->llr128_2ndstream);
           }
@@ -950,7 +734,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                                rxdataF_comp_ptr,//i
                                dl_ch_mag_ptr,//i
                                pdsch_vars[eNB_id]->dl_ch_rho2_ext,
-                               pdsch_vars[eNB_id]->llr[0],
+                               pdsch_vars[eNB_id]->layer_llr[0],
                                symbol,first_symbol_flag,nb_rb,
                                adjust_G2(frame_parms,dlsch0_harq->rb_alloc_even,2,nr_tti_rx,symbol),
                                pdsch_vars[eNB_id]->llr128);
@@ -960,7 +744,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                                  pdsch_vars[eNB_id]->rxdataF_comp0,//i
                                  dl_ch_mag_ptr,
                                  pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
-                                 pdsch_vars[eNB_id]->llr[1],
+                                 pdsch_vars[eNB_id]->layer_llr[1],
                                  symbol,first_symbol_flag,nb_rb,
                                  adjust_G2(frame_parms,dlsch1_harq->rb_alloc_even,4,nr_tti_rx,symbol),
                                  pdsch_vars[eNB_id]->llr128_2ndstream);
@@ -972,7 +756,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                                rxdataF_comp_ptr,//i
                                dl_ch_mag_ptr,//i
                                pdsch_vars[eNB_id]->dl_ch_rho2_ext,
-                               pdsch_vars[eNB_id]->llr[0],
+                               pdsch_vars[eNB_id]->layer_llr[0],
                                symbol,first_symbol_flag,nb_rb,
                                adjust_G2(frame_parms,dlsch0_harq->rb_alloc_even,2,nr_tti_rx,symbol),
                                pdsch_vars[eNB_id]->llr128);
@@ -982,7 +766,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                                  pdsch_vars[eNB_id]->rxdataF_comp0,//i
                                  dl_ch_mag_ptr,
                                  pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
-                                 pdsch_vars[eNB_id]->llr[1],
+                                 pdsch_vars[eNB_id]->layer_llr[1],
                                  symbol,first_symbol_flag,nb_rb,
                                  adjust_G2(frame_parms,dlsch1_harq->rb_alloc_even,6,nr_tti_rx,symbol),
                                  pdsch_vars[eNB_id]->llr128_2ndstream);
@@ -996,7 +780,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                       pdsch_vars[eNB_id]->rxdataF_comp0,
                       pdsch_vars[eNB_id]->llr[0],
                       pdsch_vars[eNB_id]->dl_ch_mag0,
-                      symbol,first_symbol_flag,nb_rb,
+                      symbol,len,first_symbol_flag,nb_rb,
                       pdsch_vars[eNB_id]->llr128,
                       beamforming_mode);
     } else if (codeword_TB0 == -1){
@@ -1004,7 +788,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                       pdsch_vars[eNB_id]->rxdataF_comp0,
                       pdsch_vars[eNB_id]->llr[1],
                       pdsch_vars[eNB_id]->dl_ch_mag0,
-                      symbol,first_symbol_flag,nb_rb,
+                      symbol,len,first_symbol_flag,nb_rb,
                       pdsch_vars[eNB_id]->llr128_2ndstream,
                       beamforming_mode);
     }
@@ -1015,7 +799,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                              rxdataF_comp_ptr,//i
                              pdsch_vars[eNB_id]->dl_ch_mag0,
                              pdsch_vars[eNB_id]->dl_ch_rho2_ext,
-                             pdsch_vars[eNB_id]->llr[0],
+                             pdsch_vars[eNB_id]->layer_llr[0],
                              symbol,first_symbol_flag,nb_rb,
                              adjust_G2(frame_parms,dlsch0_harq->rb_alloc_even,4,nr_tti_rx,symbol),
                              pdsch_vars[eNB_id]->llr128);
@@ -1025,7 +809,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                                pdsch_vars[eNB_id]->rxdataF_comp0,//i
                                pdsch_vars[eNB_id]->dl_ch_mag0,//i
                                pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
-                               pdsch_vars[eNB_id]->llr[1],
+                               pdsch_vars[eNB_id]->layer_llr[1],
                                symbol,first_symbol_flag,nb_rb,
                                adjust_G2(frame_parms,dlsch1_harq->rb_alloc_even,2,nr_tti_rx,symbol),
                                pdsch_vars[eNB_id]->llr128_2ndstream);
@@ -1038,8 +822,8 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                               pdsch_vars[eNB_id]->dl_ch_mag0,
                               dl_ch_mag_ptr,//i
                               pdsch_vars[eNB_id]->dl_ch_rho2_ext,
-                              pdsch_vars[eNB_id]->llr[0],
-                              symbol,first_symbol_flag,nb_rb,
+                              pdsch_vars[eNB_id]->layer_llr[0],
+                              symbol,len,first_symbol_flag,nb_rb,
                               adjust_G2(frame_parms,dlsch0_harq->rb_alloc_even,4,nr_tti_rx,symbol),
                               pdsch_vars[eNB_id]->llr128);
         if (rx_type==rx_IC_dual_stream) {
@@ -1049,8 +833,8 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                                 dl_ch_mag_ptr,
                                 pdsch_vars[eNB_id]->dl_ch_mag0,//i
                                 pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
-                                pdsch_vars[eNB_id]->llr[1],
-                                symbol,first_symbol_flag,nb_rb,
+                                pdsch_vars[eNB_id]->layer_llr[1],
+                                symbol,len,first_symbol_flag,nb_rb,
                                 adjust_G2(frame_parms,dlsch1_harq->rb_alloc_even,4,nr_tti_rx,symbol),
                                 pdsch_vars[eNB_id]->llr128_2ndstream);
         }
@@ -1062,7 +846,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                               pdsch_vars[eNB_id]->dl_ch_mag0,
                               dl_ch_mag_ptr,//i
                               pdsch_vars[eNB_id]->dl_ch_rho2_ext,
-                              pdsch_vars[eNB_id]->llr[0],
+                              pdsch_vars[eNB_id]->layer_llr[0],
                               symbol,first_symbol_flag,nb_rb,
                               adjust_G2(frame_parms,dlsch0_harq->rb_alloc_even,4,nr_tti_rx,symbol),
                               pdsch_vars[eNB_id]->llr128);
@@ -1073,7 +857,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                                 dl_ch_mag_ptr,
                                 pdsch_vars[eNB_id]->dl_ch_mag0,
                                 pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
-                                pdsch_vars[eNB_id]->llr[1],
+                                pdsch_vars[eNB_id]->layer_llr[1],
                                 symbol,first_symbol_flag,nb_rb,
                                 adjust_G2(frame_parms,dlsch1_harq->rb_alloc_even,6,nr_tti_rx,symbol),
                                 pdsch_vars[eNB_id]->llr128_2ndstream);
@@ -1088,7 +872,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                       (int16_t*)pllr_symbol_cw0,
                       pdsch_vars[eNB_id]->dl_ch_mag0,
                       pdsch_vars[eNB_id]->dl_ch_magb0,
-                      symbol,first_symbol_flag,nb_rb,
+                      symbol,len,first_symbol_flag,nb_rb,
                       pdsch_vars[eNB_id]->llr_offset[symbol],
                       beamforming_mode);
     } else if (codeword_TB0 == -1){
@@ -1097,7 +881,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                       pllr_symbol_cw1,
                       pdsch_vars[eNB_id]->dl_ch_mag0,
                       pdsch_vars[eNB_id]->dl_ch_magb0,
-                      symbol,first_symbol_flag,nb_rb,
+                      symbol,len,first_symbol_flag,nb_rb,
                       pdsch_vars[eNB_id]->llr_offset[symbol],
                       beamforming_mode);
     }
@@ -1108,7 +892,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                              rxdataF_comp_ptr,//i
                              pdsch_vars[eNB_id]->dl_ch_mag0,
                              pdsch_vars[eNB_id]->dl_ch_rho2_ext,
-                             pdsch_vars[eNB_id]->llr[0],
+                             pdsch_vars[eNB_id]->layer_llr[0],
                              symbol,first_symbol_flag,nb_rb,
                              adjust_G2(frame_parms,dlsch0_harq->rb_alloc_even,6,nr_tti_rx,symbol),
                              pdsch_vars[eNB_id]->llr128);
@@ -1118,7 +902,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                                pdsch_vars[eNB_id]->rxdataF_comp0,//i
                                pdsch_vars[eNB_id]->dl_ch_mag0,
                                pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
-                               pdsch_vars[eNB_id]->llr[1],
+                               pdsch_vars[eNB_id]->layer_llr[1],
                                symbol,first_symbol_flag,nb_rb,
                                adjust_G2(frame_parms,dlsch1_harq->rb_alloc_even,2,nr_tti_rx,symbol),
                                pdsch_vars[eNB_id]->llr128_2ndstream);
@@ -1131,7 +915,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                               pdsch_vars[eNB_id]->dl_ch_mag0,
                               dl_ch_mag_ptr,//i
                               pdsch_vars[eNB_id]->dl_ch_rho2_ext,
-                              pdsch_vars[eNB_id]->llr[0],
+                              pdsch_vars[eNB_id]->layer_llr[0],
                               symbol,first_symbol_flag,nb_rb,
                               adjust_G2(frame_parms,dlsch0_harq->rb_alloc_even,6,nr_tti_rx,symbol),
                               pdsch_vars[eNB_id]->llr128);
@@ -1142,7 +926,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                                 dl_ch_mag_ptr,
                                 pdsch_vars[eNB_id]->dl_ch_mag0,//i
                                 pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
-                                pdsch_vars[eNB_id]->llr[1],
+                                pdsch_vars[eNB_id]->layer_llr[1],
                                 symbol,first_symbol_flag,nb_rb,
                                 adjust_G2(frame_parms,dlsch1_harq->rb_alloc_even,4,nr_tti_rx,symbol),
                                 pdsch_vars[eNB_id]->llr128_2ndstream);
@@ -1155,8 +939,8 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                               pdsch_vars[eNB_id]->dl_ch_mag0,
                               dl_ch_mag_ptr,//i
                               pdsch_vars[eNB_id]->dl_ch_rho2_ext,
-                              (int16_t*)pllr_symbol_cw0,
-                              symbol,first_symbol_flag,nb_rb,
+                              (int16_t*)pllr_symbol_layer0,
+                              symbol,len,first_symbol_flag,nb_rb,
                               adjust_G2(frame_parms,dlsch0_harq->rb_alloc_even,6,nr_tti_rx,symbol),
                               pdsch_vars[eNB_id]->llr_offset[symbol]);
         if (rx_type==rx_IC_dual_stream) {
@@ -1166,8 +950,8 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                                 dl_ch_mag_ptr,
                                 pdsch_vars[eNB_id]->dl_ch_mag0,//i
                                 pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
-                                pllr_symbol_cw1,
-                                symbol,first_symbol_flag,nb_rb,
+                                pllr_symbol_layer1,
+                                symbol,len,first_symbol_flag,nb_rb,
                                 adjust_G2(frame_parms,dlsch1_harq->rb_alloc_even,6,nr_tti_rx,symbol),
                                 pdsch_vars[eNB_id]->llr_offset[symbol]);
         }
@@ -1186,7 +970,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
         nr_dlsch_qpsk_llr(frame_parms,
                        pdsch_vars[eNB_id]->rxdataF_comp0,
                        pllr_symbol_cw0,
-                       symbol,first_symbol_flag,nb_rb,
+                       symbol,len,first_symbol_flag,nb_rb,
                        beamforming_mode);
     }
     break;
@@ -1196,7 +980,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                       pdsch_vars[eNB_id]->rxdataF_comp0,
                       pdsch_vars[eNB_id]->llr[0],
                       pdsch_vars[eNB_id]->dl_ch_mag0,
-                      symbol,first_symbol_flag,nb_rb,
+                      symbol,len,first_symbol_flag,nb_rb,
                       pdsch_vars[eNB_id]->llr128,
                       beamforming_mode);
     }
@@ -1208,7 +992,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                       pllr_symbol_cw0,
                       pdsch_vars[eNB_id]->dl_ch_mag0,
                       pdsch_vars[eNB_id]->dl_ch_magb0,
-                      symbol,first_symbol_flag,nb_rb,
+                      symbol,len,first_symbol_flag,nb_rb,
                       pdsch_vars[eNB_id]->llr_offset[symbol],
                       beamforming_mode);
   }
@@ -1222,6 +1006,14 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
 
   //nr_dlsch_deinterleaving(symbol,bundle_L,(int16_t*)pllr_symbol_cw0,(int16_t*)pllr_symbol_cw0_deint, nb_rb_pdsch);
   
+ if (rx_type==rx_IC_dual_stream) {  
+	nr_dlsch_layer_demapping(pdsch_vars[eNB_id]->llr,
+				 dlsch[0]->harq_processes[harq_pid]->Nl,
+				 dlsch[0]->harq_processes[harq_pid]->Qm,
+				 dlsch[0]->harq_processes[harq_pid]->G,
+				 pdsch_vars[eNB_id]->layer_llr);
+ }
+
 #if UE_TIMING_TRACE
     stop_meas(&ue->generic_stat_bis[ue->current_thread_id[nr_tti_rx]][slot]);
 #if DISABLE_LOG_X
@@ -1281,6 +1073,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
 }
 
 void nr_dlsch_deinterleaving(uint8_t symbol,
+							uint8_t start_symbol,
 							uint16_t L,
 							uint16_t *llr,
 							uint16_t *llr_deint,
@@ -1299,7 +1092,7 @@ void nr_dlsch_deinterleaving(uint8_t symbol,
 
   printf("N_bundle %d L %d nb_rb_pdsch %d\n",N_bundle, L,nb_rb_pdsch);
 
-  if (symbol==2)
+  if (symbol==start_symbol)
 	  nb_re = 6;
   else
 	  nb_re = 12;
@@ -1337,6 +1130,7 @@ void nr_dlsch_channel_compensation(int **rxdataF_ext,
                                 int **rho,
                                 NR_DL_FRAME_PARMS *frame_parms,
                                 unsigned char symbol,
+								uint8_t pilots,
                                 uint8_t first_symbol_flag,
                                 unsigned char mod_order,
                                 unsigned short nb_rb,
@@ -1347,16 +1141,11 @@ void nr_dlsch_channel_compensation(int **rxdataF_ext,
 #if defined(__i386) || defined(__x86_64)
 
   unsigned short rb;
-  unsigned char aatx,aarx,pilots=0;
+  unsigned char aatx,aarx;
   __m128i *dl_ch128,*dl_ch128_2,*dl_ch_mag128,*dl_ch_mag128b,*rxdataF128,*rxdataF_comp128,*rho128;
   __m128i mmtmpD0,mmtmpD1,mmtmpD2,mmtmpD3,QAM_amp128,QAM_amp128b;
   QAM_amp128b = _mm_setzero_si128();
 
-  if (symbol == 2){
-      pilots=1;
-  }
-
-
   for (aatx=0; aatx<frame_parms->nb_antenna_ports_eNB; aatx++) {
     if (mod_order == 4) {
       QAM_amp128 = _mm_set1_epi16(QAM16_n1);  // 2/sqrt(10)
@@ -1382,10 +1171,10 @@ void nr_dlsch_channel_compensation(int **rxdataF_ext,
           // get channel amplitude if not QPSK
 
           mmtmpD0 = _mm_madd_epi16(dl_ch128[0],dl_ch128[0]);
-          mmtmpD0 = _mm_srai_epi32(mmtmpD0,(output_shift-2));
+          mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
 
           mmtmpD1 = _mm_madd_epi16(dl_ch128[1],dl_ch128[1]);
-          mmtmpD1 = _mm_srai_epi32(mmtmpD1,(output_shift-2));
+          mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
 
           mmtmpD0 = _mm_packs_epi32(mmtmpD0,mmtmpD1);
 
@@ -1793,31 +1582,234 @@ void nr_dlsch_channel_compensation(int **rxdataF_ext,
 #endif
 }
 
+void nr_dlsch_channel_compensation_core(int **rxdataF_ext,
+                                     int **dl_ch_estimates_ext,
+                                     int **dl_ch_mag,
+                                     int **dl_ch_magb,
+                                     int **rxdataF_comp,
+                                     int **rho,
+                                     unsigned char n_tx,
+                                     unsigned char n_rx,
+                                     unsigned char mod_order,
+                                     unsigned char output_shift,
+                                     int length,
+                                     int start_point)
+
+{
+
+  unsigned short ii;
+  int length_mod8 = 0;
+  int length2;
+  __m128i *dl_ch128,*dl_ch_mag128,*dl_ch_mag128b, *dl_ch128_2, *rxdataF128,*rxdataF_comp128,*rho128;
+  __m128i mmtmpD0,mmtmpD1,mmtmpD2,mmtmpD3,QAM_amp128,QAM_amp128b;
+  int aatx = 0, aarx = 0;
+
+  for (aatx=0; aatx<n_tx; aatx++) {
+
+    if (mod_order == 4) {
+      QAM_amp128 = _mm_set1_epi16(QAM16_n1);  // 2/sqrt(10)
+      QAM_amp128b = _mm_setzero_si128();
+    } else if (mod_order == 6) {
+      QAM_amp128  = _mm_set1_epi16(QAM64_n1); //
+      QAM_amp128b = _mm_set1_epi16(QAM64_n2);
+    }
+
+    for (aarx=0; aarx<n_rx; aarx++) {
+      /* TODO: hack to be removed. There is crash for 1 antenna case, so
+       * for 1 antenna case, I put back the value 2 as it was before
+       * Elena's commit.
+       */
+      int x = n_rx > 1 ? n_rx : 2;
+
+    dl_ch128          = (__m128i *)&dl_ch_estimates_ext[aatx*x + aarx][start_point];
+    dl_ch_mag128      = (__m128i *)&dl_ch_mag[aatx*x + aarx][start_point];
+    dl_ch_mag128b     = (__m128i *)&dl_ch_magb[aatx*x + aarx][start_point];
+    rxdataF128        = (__m128i *)&rxdataF_ext[aarx][start_point];
+    rxdataF_comp128   = (__m128i *)&rxdataF_comp[aatx*x + aarx][start_point];
+
+      length_mod8 = length&7;
+      if (length_mod8 == 0){
+        length2 = length>>3;
+
+        for (ii=0; ii<length2; ++ii) {
+          if (mod_order>2) {
+            // get channel amplitude if not QPSK
+
+            mmtmpD0 = _mm_madd_epi16(dl_ch128[0],dl_ch128[0]);
+            mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
+
+            mmtmpD1 = _mm_madd_epi16(dl_ch128[1],dl_ch128[1]);
+            mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
+
+            mmtmpD0 = _mm_packs_epi32(mmtmpD0,mmtmpD1);
+
+            // store channel magnitude here in a new field of dlsch
+
+            dl_ch_mag128[0] = _mm_unpacklo_epi16(mmtmpD0,mmtmpD0);
+            dl_ch_mag128b[0] = dl_ch_mag128[0];
+            dl_ch_mag128[0] = _mm_mulhi_epi16(dl_ch_mag128[0],QAM_amp128);
+            dl_ch_mag128[0] = _mm_slli_epi16(dl_ch_mag128[0],1);
+            //print_ints("Re(ch):",(int16_t*)&mmtmpD0);
+            //print_shorts("QAM_amp:",(int16_t*)&QAM_amp128);
+            //print_shorts("mag:",(int16_t*)&dl_ch_mag128[0]);
+            dl_ch_mag128[1] = _mm_unpackhi_epi16(mmtmpD0,mmtmpD0);
+            dl_ch_mag128b[1] = dl_ch_mag128[1];
+            dl_ch_mag128[1] = _mm_mulhi_epi16(dl_ch_mag128[1],QAM_amp128);
+            dl_ch_mag128[1] = _mm_slli_epi16(dl_ch_mag128[1],1);
+
+            dl_ch_mag128b[0] = _mm_mulhi_epi16(dl_ch_mag128b[0],QAM_amp128b);
+            dl_ch_mag128b[0] = _mm_slli_epi16(dl_ch_mag128b[0],1);
+
+            dl_ch_mag128b[1] = _mm_mulhi_epi16(dl_ch_mag128b[1],QAM_amp128b);
+            dl_ch_mag128b[1] = _mm_slli_epi16(dl_ch_mag128b[1],1);
+
+          }
+
+          // multiply by conjugated channel
+          mmtmpD0 = _mm_madd_epi16(dl_ch128[0],rxdataF128[0]);
+
+          // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
+          mmtmpD1 = _mm_shufflelo_epi16(dl_ch128[0],_MM_SHUFFLE(2,3,0,1));
+          mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
+          mmtmpD1 = _mm_sign_epi16(mmtmpD1,*(__m128i*)&conjugate[0]);
+          //  print_ints("im",&mmtmpD1);
+          mmtmpD1 = _mm_madd_epi16(mmtmpD1,rxdataF128[0]);
+          // mmtmpD1 contains imag part of 4 consecutive outputs (32-bit)
+          mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
+          //  print_ints("re(shift)",&mmtmpD0);
+          mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
+          //  print_ints("im(shift)",&mmtmpD1);
+          mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
+          mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
+          //        print_ints("c0",&mmtmpD2);
+          //  print_ints("c1",&mmtmpD3);
+          rxdataF_comp128[0] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
+          //  print_shorts("rx:",rxdataF128);
+          //  print_shorts("ch:",dl_ch128);
+          //  print_shorts("pack:",rxdataF_comp128);
+
+          // multiply by conjugated channel
+          mmtmpD0 = _mm_madd_epi16(dl_ch128[1],rxdataF128[1]);
+          // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
+          mmtmpD1 = _mm_shufflelo_epi16(dl_ch128[1],_MM_SHUFFLE(2,3,0,1));
+          mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
+          mmtmpD1 = _mm_sign_epi16(mmtmpD1,*(__m128i*)conjugate);
+          mmtmpD1 = _mm_madd_epi16(mmtmpD1,rxdataF128[1]);
+          // mmtmpD1 contains imag part of 4 consecutive outputs (32-bit)
+          mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
+          mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
+          mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
+          mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
+
+          rxdataF_comp128[1] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
+          //  print_shorts("rx:",rxdataF128+1);
+          //  print_shorts("ch:",dl_ch128+1);
+          //print_shorts("pack:",rxdataF_comp128+1);
+
+          dl_ch128+=2;
+          dl_ch_mag128+=2;
+          dl_ch_mag128b+=2;
+          rxdataF128+=2;
+          rxdataF_comp128+=2;
+        }
+      }else {
+        printf ("Channel Compensation: Received number of subcarriers is not multiple of 8, \n"
+                 "need to adapt the code!\n");
+      }
+    }
+  }
+
+/*This part of code makes sense only for processing in 2x2 blocks*/
+  if (rho) {
+
+
+    for (aarx=0; aarx<n_rx; aarx++) {
+      rho128        = (__m128i *)&rho[aarx][start_point];
+      dl_ch128      = (__m128i *)&dl_ch_estimates_ext[aarx][start_point];
+      dl_ch128_2    = (__m128i *)&dl_ch_estimates_ext[2+aarx][start_point];
+
+      if (length_mod8 == 0){
+        length2 = length>>3;
+
+        for (ii=0; ii<length2; ++ii) {
+          // multiply by conjugated channel
+          mmtmpD0 = _mm_madd_epi16(dl_ch128[0],dl_ch128_2[0]);
+          //  print_ints("re",&mmtmpD0);
+
+          // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
+          mmtmpD1 = _mm_shufflelo_epi16(dl_ch128[0],_MM_SHUFFLE(2,3,0,1));
+          mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
+          mmtmpD1 = _mm_sign_epi16(mmtmpD1,*(__m128i*)&conjugate[0]);
+          //  print_ints("im",&mmtmpD1);
+          mmtmpD1 = _mm_madd_epi16(mmtmpD1,dl_ch128_2[0]);
+          // mmtmpD1 contains imag part of 4 consecutive outputs (32-bit)
+          mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
+          //  print_ints("re(shift)",&mmtmpD0);
+          mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
+          //  print_ints("im(shift)",&mmtmpD1);
+          mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
+          mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
+          //        print_ints("c0",&mmtmpD2);
+          //  print_ints("c1",&mmtmpD3);
+          rho128[0] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
+
+          //print_shorts("rx:",dl_ch128_2);
+          //print_shorts("ch:",dl_ch128);
+          //print_shorts("pack:",rho128);
+
+          // multiply by conjugated channel
+          mmtmpD0 = _mm_madd_epi16(dl_ch128[1],dl_ch128_2[1]);
+          // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
+          mmtmpD1 = _mm_shufflelo_epi16(dl_ch128[1],_MM_SHUFFLE(2,3,0,1));
+          mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
+          mmtmpD1 = _mm_sign_epi16(mmtmpD1,*(__m128i*)conjugate);
+          mmtmpD1 = _mm_madd_epi16(mmtmpD1,dl_ch128_2[1]);
+          // mmtmpD1 contains imag part of 4 consecutive outputs (32-bit)
+          mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
+          mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
+          mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
+          mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
+
+          rho128[1] =_mm_packs_epi32(mmtmpD2,mmtmpD3);
+          dl_ch128+=2;
+          dl_ch128_2+=2;
+          rho128+=2;
+        }
+      }else {
+        printf ("Channel Compensation: Received number of subcarriers is not multiple of 8, \n"
+                 "need to adapt the code!\n");
+      }
+    }
+  }
+  _mm_empty();
+  _m_empty();
+}
+
 
 void nr_dlsch_scale_channel(int **dl_ch_estimates_ext,
                          NR_DL_FRAME_PARMS *frame_parms,
                          NR_UE_DLSCH_t **dlsch_ue,
                          uint8_t symbol,
+						 uint8_t pilots,
                          unsigned short nb_rb)
 {
 
 #if defined(__x86_64__)||defined(__i386__)
 
   short rb, ch_amp;
-  unsigned char aatx,aarx,pilots=0,symbol_mod;
+  unsigned char aatx,aarx;
   __m128i *dl_ch128, ch_amp128;
 
   
-  if (symbol==2){
+  if (pilots==1){
 	  nb_rb = nb_rb>>1;
-	  pilots=1;
   }
 
   // Determine scaling amplitude based the symbol
 
 ch_amp = 1024*8; //((pilots) ? (dlsch_ue[0]->sqrt_rho_b) : (dlsch_ue[0]->sqrt_rho_a));
 
-    LOG_D(PHY,"Scaling PDSCH Chest in OFDM symbol %d by %d, pilots %d nb_rb %d NCP %d symbol %d\n",symbol_mod,ch_amp,pilots,nb_rb,frame_parms->Ncp,symbol);
+    LOG_D(PHY,"Scaling PDSCH Chest in OFDM symbol %d by %d, pilots %d nb_rb %d NCP %d symbol %d\n",symbol,ch_amp,pilots,nb_rb,frame_parms->Ncp,symbol);
    // printf("Scaling PDSCH Chest in OFDM symbol %d by %d\n",symbol_mod,ch_amp);
 
   ch_amp128 = _mm_set1_epi16(ch_amp); // Q3.13
@@ -1858,23 +1850,19 @@ void nr_dlsch_channel_level(int **dl_ch_estimates_ext,
                          NR_DL_FRAME_PARMS *frame_parms,
                          int32_t *avg,
                          uint8_t symbol,
+						 uint32_t len,
                          unsigned short nb_rb)
 {
 
 #if defined(__x86_64__)||defined(__i386__)
 
   short rb;
-  unsigned char aatx,aarx,nre=12;
+  unsigned char aatx,aarx;
   __m128i *dl_ch128, avg128D;
 
-    if (symbol==2) //assume start symbol 2
-      nre=6;
-    else
-      nre=12;
-
   //nb_rb*nre = y * 2^x
-  int16_t x = factor2(nb_rb*nre);
-  int16_t y = (nb_rb*nre)>>x;
+  int16_t x = factor2(len);
+  int16_t y = (len)>>x;
   //printf("nb_rb*nre = %d = %d * 2^(%d)\n",nb_rb*nre,y,x);
 
   for (aatx=0; aatx<frame_parms->nb_antenna_ports_eNB; aatx++)
@@ -1980,23 +1968,406 @@ void nr_dlsch_channel_level(int **dl_ch_estimates_ext,
 #endif
 }
 
+void nr_dlsch_channel_level_median(int **dl_ch_estimates_ext,
+                                int32_t *median,
+                                int n_tx,
+                                int n_rx,
+                                int length,
+                                int start_point)
+{
+
+#if defined(__x86_64__)||defined(__i386__)
+
+  short ii;
+  int aatx,aarx;
+  int length2;
+  int max = 0, min=0;
+  int norm_pack;
+  __m128i *dl_ch128, norm128D;
+
+  for (aatx=0; aatx<n_tx; aatx++){
+    for (aarx=0; aarx<n_rx; aarx++) {
+      max = 0;
+      min = 0;
+      norm128D = _mm_setzero_si128();
+
+      dl_ch128=(__m128i *)&dl_ch_estimates_ext[aatx*2 + aarx][start_point];
+
+      length2 = length>>2;
+
+      for (ii=0;ii<length2;ii++) {
+        norm128D = _mm_srai_epi32( _mm_madd_epi16(dl_ch128[0],dl_ch128[0]), 1);
+          //print_ints("norm128D",&norm128D[0]);
+
+        norm_pack = ((int32_t*)&norm128D)[0] +
+                    ((int32_t*)&norm128D)[1] +
+                    ((int32_t*)&norm128D)[2] +
+                    ((int32_t*)&norm128D)[3];
+
+        if (norm_pack > max)
+          max = norm_pack;
+        if (norm_pack < min)
+          min = norm_pack;
+
+        dl_ch128+=1;
+      }
+
+        median[aatx*n_rx + aarx]  = (max+min)>>1;
+
+     // printf("Channel level  median [%d]: %d\n",aatx*n_rx + aarx, median[aatx*n_rx + aarx]);
+      }
+    }
+
+  _mm_empty();
+  _m_empty();
+
+#elif defined(__arm__)
+
+  short rb;
+  unsigned char aatx,aarx,nre=12,symbol_mod;
+  int32x4_t norm128D;
+  int16x4_t *dl_ch128;
+
+  for (aatx=0; aatx<frame_parms->nb_antenna_ports_eNB; aatx++){
+    for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
+      max = 0;
+      min = 0;
+      norm128D = vdupq_n_s32(0);
+
+      dl_ch128=(int16x4_t *)&dl_ch_estimates_ext[aatx*n_rx + aarx][start_point];
+
+      length_mod8=length&3;
+      length2 = length>>2;
+
+      for (ii=0;ii<length2;ii++) {
+        norm128D = vshrq_n_u32(vmull_s16(dl_ch128[0],dl_ch128[0]), 1);
+        norm_pack = ((int32_t*)&norm128D)[0] +
+                    ((int32_t*)&norm128D)[1] +
+                    ((int32_t*)&norm128D)[2] +
+                    ((int32_t*)&norm128D)[3];
+
+        if (norm_pack > max)
+          max = norm_pack;
+        if (norm_pack < min)
+          min = norm_pack;
+
+          dl_ch128+=1;
+      }
+
+        median[aatx*n_rx + aarx]  = (max+min)>>1;
+
+      //printf("Channel level  median [%d]: %d\n",aatx*n_rx + aarx, median[aatx*n_rx + aarx]);
+      }
+    }
+#endif
+
+}
+
+static void nr_dlsch_dual_stream_correlation_core(int **dl_ch_estimates_ext,
+                                        int **dl_ch_estimates_ext_i,
+                                        int **dl_ch_rho_ext,
+                                        unsigned char n_tx,
+                                        unsigned char n_rx,
+                                        unsigned char output_shift,
+                                        int length,
+                                        int start_point)
+{
+#if defined(__x86_64__)||defined(__i386__)
+
+  __m128i *dl_ch128,*dl_ch128i,*dl_ch_rho128,mmtmpD0,mmtmpD1,mmtmpD2,mmtmpD3;
+  unsigned char aarx;
+  int ii, length2, length_mod8;
+
+
+  for (aarx=0; aarx<n_rx; aarx++) {
+
+    dl_ch128          = (__m128i *)&dl_ch_estimates_ext[aarx][start_point];
+
+    if (dl_ch_estimates_ext_i == NULL)
+      dl_ch128i         = (__m128i *)&dl_ch_estimates_ext[aarx + n_rx][start_point];
+    else
+      dl_ch128i         = (__m128i *)&dl_ch_estimates_ext_i[aarx][start_point];
+
+    dl_ch_rho128      = (__m128i *)&dl_ch_rho_ext[aarx][start_point];
+
+    length_mod8 = length&7;
+
+    if (length_mod8 == 0){
+      length2 = length>>3;
+
+      for (ii=0; ii<length2; ++ii) {
+      // multiply by conjugated channel
+        mmtmpD0 = _mm_madd_epi16(dl_ch128[0],dl_ch128i[0]);
+        //      print_ints("re",&mmtmpD0);
+        // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
+        mmtmpD1 = _mm_shufflelo_epi16(dl_ch128[0],_MM_SHUFFLE(2,3,0,1));
+        mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
+        mmtmpD1 = _mm_sign_epi16(mmtmpD1,*(__m128i*)&conjugate[0]);
+        mmtmpD1 = _mm_madd_epi16(mmtmpD1,dl_ch128i[0]);
+        //      print_ints("im",&mmtmpD1);
+        // mmtmpD1 contains imag part of 4 consecutive outputs (32-bit)
+        mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
+        //      print_ints("re(shift)",&mmtmpD0);
+        mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
+        //      print_ints("im(shift)",&mmtmpD1);
+        mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
+        mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
+        //      print_ints("c0",&mmtmpD2);
+        //      print_ints("c1",&mmtmpD3);
+        dl_ch_rho128[0] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
+      // print_shorts("rho 0:",dl_ch_rho128);
+        // multiply by conjugated channel
+        mmtmpD0 = _mm_madd_epi16(dl_ch128[1],dl_ch128i[1]);
+        // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
+        mmtmpD1 = _mm_shufflelo_epi16(dl_ch128[1],_MM_SHUFFLE(2,3,0,1));
+        mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
+        mmtmpD1 = _mm_sign_epi16(mmtmpD1,*(__m128i*)conjugate);
+        mmtmpD1 = _mm_madd_epi16(mmtmpD1,dl_ch128i[1]);
+        // mmtmpD1 contains imag part of 4 consecutive outputs (32-bit)
+        mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
+        mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
+        mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
+        mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
+        dl_ch_rho128[1] =_mm_packs_epi32(mmtmpD2,mmtmpD3);
+
+        dl_ch128+=2;
+        dl_ch128i+=2;
+        dl_ch_rho128+=2;
+      }
+
+    }else {
+        printf ("Channel Correlarion: Received number of subcarriers is not multiple of 8, \n"
+                 "need to adapt the code!\n");
+      }
+
+  }
+
+  _mm_empty();
+  _m_empty();
+
+#elif defined(__arm__)
+
+#endif
+}
+
+void nr_dlsch_detection_mrc_core(int **rxdataF_comp,
+                              int **rxdataF_comp_i,
+                              int **rho,
+                              int **rho_i,
+                              int **dl_ch_mag,
+                              int **dl_ch_magb,
+                              int **dl_ch_mag_i,
+                              int **dl_ch_magb_i,
+                              unsigned char n_tx,
+                              unsigned char n_rx,
+                              int length,
+                              int start_point)
+{
+
+#if defined(__x86_64__)||defined(__i386__)
+
+  unsigned char aatx;
+  int i;
+  __m128i *rxdataF_comp128_0, *rxdataF_comp128_1, *rxdataF_comp128_2, *rxdataF_comp128_3;
+  __m128i *dl_ch_mag128_0, *dl_ch_mag128_1, *dl_ch_mag128_2, *dl_ch_mag128_3;
+  __m128i *dl_ch_mag128_0b, *dl_ch_mag128_1b,  *dl_ch_mag128_2b,  *dl_ch_mag128_3b;
+  __m128i *rho128_0, *rho128_1, *rho128_2=NULL, *rho128_3=NULL;
+  __m128i *rho128_i0, *rho128_i1, *rho128_i2, *rho128_i3;
+  int length_mod4 = 0;
+  int length2;
+
+  if (n_rx>1) {
+
+    for (aatx=0; aatx<n_tx; aatx++) {
+
+      rxdataF_comp128_0   = (__m128i *)&rxdataF_comp[(aatx<<1)][start_point];
+      rxdataF_comp128_1   = (__m128i *)&rxdataF_comp[(aatx<<1)+1][start_point];
+      dl_ch_mag128_0      = (__m128i *)&dl_ch_mag[(aatx<<1)][start_point];
+      dl_ch_mag128_1      = (__m128i *)&dl_ch_mag[(aatx<<1)+1][start_point];
+      dl_ch_mag128_0b     = (__m128i *)&dl_ch_magb[(aatx<<1)][start_point];
+      dl_ch_mag128_1b     = (__m128i *)&dl_ch_magb[(aatx<<1)+1][start_point];
+
+      if (length_mod4 == 0){
+        length2 = length>>2;
+
+        for (i=0; i<length2; ++i) {
+          rxdataF_comp128_0[i] = _mm_adds_epi16(_mm_srai_epi16(rxdataF_comp128_0[i],1),_mm_srai_epi16(rxdataF_comp128_1[i],1));
+          dl_ch_mag128_0[i] = _mm_adds_epi16(_mm_srai_epi16(dl_ch_mag128_0[i],1),_mm_srai_epi16(dl_ch_mag128_1[i],1));
+          dl_ch_mag128_0b[i] = _mm_adds_epi16(_mm_srai_epi16(dl_ch_mag128_0b[i],1),_mm_srai_epi16(dl_ch_mag128_1b[i],1));
+        }
+      }
+    }
+
+
+    if (rho) {
+      rho128_0 = (__m128i *) &rho[0][start_point];
+      rho128_1 = (__m128i *) &rho[1][start_point];
+
+      if (n_tx == 4){
+        rho128_2 = (__m128i *) &rho[2][start_point];
+        rho128_3 = (__m128i *) &rho[3][start_point];
+      }
+        if (length_mod4 == 0){
+          length2 = length>>2;
+
+          for (i=0; i<length2; ++i) {
+            rho128_0[i] = _mm_adds_epi16(_mm_srai_epi16(rho128_0[i],1),_mm_srai_epi16(rho128_1[i],1));
+          if (n_tx == 4){
+            rho128_2[i] = _mm_adds_epi16(_mm_srai_epi16(rho128_2[i],1),_mm_srai_epi16(rho128_3[i],1));
+          }
+        }
+      }
+    }
+
+    if (rho_i){
+      rho128_i0 = (__m128i *) &rho_i[0][start_point];
+      rho128_i1 = (__m128i *) &rho_i[1][start_point];
+      if (n_tx == 4){
+        rho128_i2 = (__m128i *) &rho_i[2][start_point];
+        rho128_i3 = (__m128i *) &rho_i[3][start_point];
+      }
+      if (length_mod4 == 0){
+        length2 = length>>2;
+
+        for (i=0; i<length2; ++i){
+          rho128_i0[i] = _mm_adds_epi16(_mm_srai_epi16(rho128_i0[i],1),_mm_srai_epi16(rho128_i1[i],1));
+          if (n_tx == 4){
+            rho128_i2[i] = _mm_adds_epi16(_mm_srai_epi16(rho128_i2[i],1),_mm_srai_epi16(rho128_i3[i],1));
+          }
+        }
+      }
+    }
+
+      if (n_tx == 4){
+
+      rxdataF_comp128_0 = (__m128i *)&rxdataF_comp[0][start_point];
+      rxdataF_comp128_1 = (__m128i *)&rxdataF_comp[2][start_point];
+      rxdataF_comp128_2 = (__m128i *)&rxdataF_comp[4][start_point];
+      rxdataF_comp128_3 = (__m128i *)&rxdataF_comp[6][start_point];
+
+      dl_ch_mag128_0 = (__m128i *)&dl_ch_mag[0][start_point];
+      dl_ch_mag128_1 = (__m128i *)&dl_ch_mag[2][start_point];
+      dl_ch_mag128_2 = (__m128i *)&dl_ch_mag[4][start_point];
+      dl_ch_mag128_3 = (__m128i *)&dl_ch_mag[6][start_point];
+
+      dl_ch_mag128_0b = (__m128i *)&dl_ch_magb[0][start_point];
+      dl_ch_mag128_1b = (__m128i *)&dl_ch_magb[2][start_point];
+      dl_ch_mag128_2b = (__m128i *)&dl_ch_magb[4][start_point];
+      dl_ch_mag128_3b = (__m128i *)&dl_ch_magb[6][start_point];
+
+      rho128_0 = (__m128i *)&rho[0][start_point];
+      rho128_1 = (__m128i *)&rho[2][start_point];
+
+      rho128_i0 = (__m128i *)&rho_i[0][start_point];
+      rho128_i1 = (__m128i *)&rho_i[2][start_point];
+
+
+      if (length_mod4 == 0){
+
+        length2 = length>>2;
+
+        for (i=0; i<length2; ++i) {
+          rxdataF_comp128_0[i] = _mm_adds_epi16(_mm_srai_epi16(rxdataF_comp128_0[i],1),_mm_srai_epi16(rxdataF_comp128_1[i],1));
+          rxdataF_comp128_2[i] = _mm_adds_epi16(_mm_srai_epi16(rxdataF_comp128_2[i],1),_mm_srai_epi16(rxdataF_comp128_3[i],1));
+
+          dl_ch_mag128_0[i] = _mm_adds_epi16(_mm_srai_epi16(dl_ch_mag128_0[i],1),_mm_srai_epi16(dl_ch_mag128_1[i],1));
+          dl_ch_mag128_2[i] = _mm_adds_epi16(_mm_srai_epi16(dl_ch_mag128_2[i],1),_mm_srai_epi16(dl_ch_mag128_3[i],1));
+
+          dl_ch_mag128_0b[i] = _mm_adds_epi16(_mm_srai_epi16(dl_ch_mag128_0b[i],1),_mm_srai_epi16(dl_ch_mag128_1b[i],1));
+          dl_ch_mag128_2b[i] = _mm_adds_epi16(_mm_srai_epi16(dl_ch_mag128_2b[i],1),_mm_srai_epi16(dl_ch_mag128_3b[i],1));
+
+          rho128_0[i] = _mm_adds_epi16(_mm_srai_epi16(rho128_0[i],1),_mm_srai_epi16(rho128_1[i],1));
+
+          rho128_i0[i] = _mm_adds_epi16(_mm_srai_epi16(rho128_i0[i],1),_mm_srai_epi16(rho128_i1[i],1));
+        }
+    }
+  }
+
+  }
+
+  _mm_empty();
+  _m_empty();
+
+#elif defined(__arm__)
+
+  unsigned char aatx;
+  int i;
+  int16x8_t *rxdataF_comp128_0,*rxdataF_comp128_1,*dl_ch_mag128_0,*dl_ch_mag128_1,*dl_ch_mag128_0b,*dl_ch_mag128_1b,*rho128_0,*rho128_1,*rho128_i0,*rho128_i1;
+  int length_mod4 = 0;
+  int length2;
+  int ii=0;
+
+  if (n_rx>1) {
+
+    for (aatx=0; aatx<n_tx; aatx++) {
+
+      rxdataF_comp128_0   = (int16x8_t *)&rxdataF_comp[(aatx<<1)][start_point];
+      rxdataF_comp128_1   = (int16x8_t *)&rxdataF_comp[(aatx<<1)+1][start_point];
+      dl_ch_mag128_0      = (int16x8_t *)&dl_ch_mag[(aatx<<1)][start_point];
+      dl_ch_mag128_1      = (int16x8_t *)&dl_ch_mag[(aatx<<1)+1][start_point];
+      dl_ch_mag128_0b     = (int16x8_t *)&dl_ch_magb[(aatx<<1)][start_point];
+      dl_ch_mag128_1b     = (int16x8_t *)&dl_ch_magb[(aatx<<1)+1][start_point];
+
+      if (length_mod4 == 0){
+        length2 = length>>2;
+
+        for (i=0; i<length2; ++ii) {
+          rxdataF_comp128_0[i] = vhaddq_s16(rxdataF_comp128_0[i],rxdataF_comp128_1[i]);
+          dl_ch_mag128_0[i]    = vhaddq_s16(dl_ch_mag128_0[i],dl_ch_mag128_1[i]);
+          dl_ch_mag128_0b[i]   = vhaddq_s16(dl_ch_mag128_0b[i],dl_ch_mag128_1b[i]);
+        }
+      }
+
+    if (rho) {
+      rho128_0 = (int16x8_t *) &rho[0][start_point];
+      rho128_1 = (int16x8_t *) &rho[1][start_point];
+
+      if (length_mod4 == 0){
+        length2 = length>>2;
+
+        for (i=0; i<length2; ++i) {
+          rho128_0[i] = vhaddq_s16(rho128_0[i],rho128_1[i]);
+        }
+      }
+    }
+
+    if (rho_i){
+
+      rho128_i0 = (__m128i *) &rho_i[0][start_point];
+      rho128_i1 = (__m128i *) &rho_i[1][start_point];
+
+      if (length_mod4 == 0){
+        length2 = length>>2;
+
+        for (i=0; i<length2; ++i)
+          rho128_i0[i] = vhaddq_s16(rho128_i0[i],rho128_i1[i]);
+
+      }
+    }
+  }
+
+  }
+
+#endif
+}
+
 //==============================================================================================
 // Extraction functions
 //==============================================================================================
 
 unsigned short nr_dlsch_extract_rbs_single(int **rxdataF,
-                                        int **dl_ch_estimates,
-                                        int **rxdataF_ext,
-                                        int **dl_ch_estimates_ext,
-                                        unsigned short pmi,
-                                        unsigned char *pmi_ext,
-                                        unsigned int *rb_alloc,
-                                        unsigned char symbol,
-										unsigned short start_rb,
-										unsigned short nb_rb_pdsch,
-                                        unsigned char nr_tti_rx,
-                                        uint32_t high_speed_flag,
-                                        NR_DL_FRAME_PARMS *frame_parms) {
+					   int **dl_ch_estimates,
+					   int **rxdataF_ext,
+					   int **dl_ch_estimates_ext,
+					   unsigned short pmi,
+					   unsigned char *pmi_ext,
+					   unsigned char symbol,
+					   uint8_t pilots,
+					   unsigned short start_rb,
+					   unsigned short nb_rb_pdsch,
+					   unsigned char nr_tti_rx,
+					   uint32_t high_speed_flag,
+					   NR_DL_FRAME_PARMS *frame_parms) {
 
 
 
@@ -2006,22 +2377,9 @@ unsigned short nr_dlsch_extract_rbs_single(int **rxdataF,
 
 
 
-  unsigned char pilots=0,j=0;
-
-  //symbol_mod = (symbol>=(7-frame_parms->Ncp)) ? symbol-(7-frame_parms->Ncp) : symbol;
-  pilots = (symbol==2) ? 1 : 0; //to updated from config
-  //l=symbol;
-  //nsymb = (frame_parms->Ncp==NORMAL) ? 14:12;
-  k = frame_parms->first_carrier_offset + 516; //0
-
- /* if (frame_parms->frame_type == TDD) {  // TDD
-    sss_symb = nsymb-1;
-    pss_symb = 2;
-  } else {
-    sss_symb = (nsymb>>1)-2;
-    pss_symb = (nsymb>>1)-1;
-  }*/
+  unsigned char j=0;
 
+  k = frame_parms->first_carrier_offset + 12*start_rb; 
 
   for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
 
@@ -2097,6 +2455,128 @@ unsigned short nr_dlsch_extract_rbs_single(int **rxdataF,
   return(nb_rb_pdsch/frame_parms->nb_antennas_rx);
 }
 
+unsigned short nr_dlsch_extract_rbs_dual(int **rxdataF,
+                                      int **dl_ch_estimates,
+                                      int **rxdataF_ext,
+                                      int **dl_ch_estimates_ext,
+                                      unsigned short pmi,
+                                      unsigned char *pmi_ext,
+                                      unsigned char symbol,
+									  uint8_t pilots,
+									  unsigned short start_rb,
+									  unsigned short nb_rb_pdsch,
+                                      unsigned char nr_tti_rx,
+                                      uint32_t high_speed_flag,
+                                      NR_DL_FRAME_PARMS *frame_parms,
+                                      MIMO_mode_t mimo_mode) {
+
+  int prb,nb_rb=0;
+  unsigned short k;
+  int i,j,aarx;
+  int32_t *dl_ch0=NULL,*dl_ch0p=NULL,*dl_ch0_ext=NULL,*dl_ch1=NULL,*dl_ch1p=NULL,*dl_ch1_ext=NULL,*rxF=NULL,*rxF_ext=NULL;
+
+  k = frame_parms->first_carrier_offset + 516; //0
+
+  for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
+
+    if (high_speed_flag==1) {
+      dl_ch0     = &dl_ch_estimates[aarx][symbol*(frame_parms->ofdm_symbol_size)];
+      dl_ch1     = &dl_ch_estimates[2+aarx][symbol*(frame_parms->ofdm_symbol_size)];
+    } else {
+      dl_ch0     = &dl_ch_estimates[aarx][0];
+      dl_ch1     = &dl_ch_estimates[2+aarx][0];
+    }
+
+    //pmi_loc = pmi_ext;
+
+    // pointers to extracted RX signals and channel estimates
+    rxF_ext    = &rxdataF_ext[aarx][symbol*(nb_rb_pdsch*12)];
+    dl_ch0_ext = &dl_ch_estimates_ext[aarx][symbol*(nb_rb_pdsch*12)];
+    dl_ch1_ext = &dl_ch_estimates_ext[2+aarx][symbol*(nb_rb_pdsch*12)];
+
+    for (prb=0; prb<frame_parms->N_RB_DL; prb++) {
+      //skip_half=0;
+
+      if ((frame_parms->N_RB_DL&1) == 0) {  // even number of RBs
+
+        // For second half of RBs skip DC carrier
+        if (k>=frame_parms->ofdm_symbol_size) {
+          rxF = &rxdataF[aarx][(symbol*(frame_parms->ofdm_symbol_size))];
+          k=k-(frame_parms->ofdm_symbol_size);
+        }
+
+         /*
+         if (mimo_mode <= PUSCH_PRECODING1)
+          *pmi_loc = (pmi>>((prb>>2)<<1))&3;
+         else
+          *pmi_loc=(pmi>>prb)&1;*/
+
+        // *pmi_loc = get_pmi(frame_parms->N_RB_DL,mimo_mode,pmi,prb);
+        //  pmi_loc++;
+
+
+          if (pilots == 0) {
+
+            memcpy(dl_ch0_ext,dl_ch0,12*sizeof(int));
+            memcpy(dl_ch1_ext,dl_ch1,12*sizeof(int));
+            memcpy(rxF_ext,rxF,12*sizeof(int));
+            dl_ch0_ext +=12;
+            dl_ch1_ext +=12;
+            rxF_ext    +=12;
+          } else { // pilots==1
+            j=0;
+            for (i=0; i<12; i++) {
+              if ((i&1)!=frame_parms->nushift) {
+                rxF_ext[j]=rxF[i];
+                //        printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
+                dl_ch0_ext[j]=dl_ch0p[i];
+                dl_ch1_ext[j++]=dl_ch1p[i];
+              }
+            }
+            dl_ch0_ext+=6;
+            dl_ch1_ext+=6;
+            rxF_ext+=6;
+          } // pilots==1
+
+          dl_ch0+=12;
+          dl_ch1+=12;
+          rxF+=12;
+          k+=12;
+      }
+    } // for prb
+  } // for aarx
+  return(nb_rb/frame_parms->nb_antennas_rx);
+}
+
+
+static void nr_dlsch_layer_demapping(int16_t **llr_cw,
+				     uint8_t Nl,
+				     uint8_t mod_order,
+				     uint16_t length,
+				     int16_t **llr_layers) {
+
+  switch (Nl) {
+
+    case 1:
+      memcpy((void*)llr_layers[0], (void*)llr_cw[0], (length)*sizeof(int16_t));
+    break;
+
+    case 2:
+    case 3:
+    case 4:
+      for (int i=0; i<(length/Nl/mod_order); i++){
+        for (int l=0; l<Nl; l++) {
+        	for (int m=0; m<mod_order; m++){
+        		llr_cw[0][Nl*i+l*mod_order+m] = llr_layers[l][i*mod_order+m];
+        	}
+        }
+  	  }
+    break;
+
+  default:
+  AssertFatal(0, "Not supported number of layers %d\n", Nl);
+  }
+}
 //==============================================================================================
 
 #ifdef USER_MODE
diff --git a/openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_llr_computation.c b/openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_llr_computation.c
index 9527bf10e9..036316dbaa 100644
--- a/openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_llr_computation.c
+++ b/openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_llr_computation.c
@@ -632,6 +632,7 @@ int nr_dlsch_qpsk_llr(NR_DL_FRAME_PARMS *frame_parms,
                    int32_t **rxdataF_comp,
                    int16_t *dlsch_llr,
                    uint8_t symbol,
+				   uint32_t len,
 				   uint8_t first_symbol_flag,
                    uint16_t nb_rb,
                    uint8_t beamforming_mode)
@@ -639,7 +640,7 @@ int nr_dlsch_qpsk_llr(NR_DL_FRAME_PARMS *frame_parms,
 
   uint32_t *rxF = (uint32_t*)&rxdataF_comp[0][((int32_t)symbol*nb_rb*12)];
   uint32_t *llr32;
-  int i,len;
+  int i;
 
   llr32 = (uint32_t*)dlsch_llr;
   if (!llr32) {
@@ -647,10 +648,6 @@ int nr_dlsch_qpsk_llr(NR_DL_FRAME_PARMS *frame_parms,
     return(-1);
   }
 
-  if (symbol ==2)  //to update from config
-	  len = nb_rb*6;
-  else
-	  len = nb_rb*12;
   /*
   LOG_I(PHY,"dlsch_qpsk_llr: [symb %d / Length %d]: @LLR Buff %x, @LLR Buff(symb) %x \n",
              symbol,
@@ -677,6 +674,7 @@ void nr_dlsch_16qam_llr(NR_DL_FRAME_PARMS *frame_parms,
                      int16_t *dlsch_llr,
                      int32_t **dl_ch_mag,
                      uint8_t symbol,
+					 uint32_t len,
                      uint8_t first_symbol_flag,
                      uint16_t nb_rb,
                      int16_t **llr32p,
@@ -696,7 +694,7 @@ void nr_dlsch_16qam_llr(NR_DL_FRAME_PARMS *frame_parms,
 #endif
 
 
-  int i,len;
+  int i;
   unsigned char len_mod4=0;
 
 
@@ -720,11 +718,6 @@ void nr_dlsch_16qam_llr(NR_DL_FRAME_PARMS *frame_parms,
   ch_mag = (int16x8_t*)&dl_ch_mag[0][(symbol*nb_rb*12)];
 #endif
 
-  if (symbol ==2)  //to update from config
- 	  len = nb_rb*6;
-   else
- 	  len = nb_rb*12;
-
   // update output pointer according to number of REs in this symbol (<<2 because 4 bits per RE)
   if (first_symbol_flag == 1)
     *llr32p = dlsch_llr + (len<<2);
@@ -798,6 +791,7 @@ void nr_dlsch_64qam_llr(NR_DL_FRAME_PARMS *frame_parms,
                      int32_t **dl_ch_mag,
                      int32_t **dl_ch_magb,
                      uint8_t symbol,
+					 uint32_t len,
                      uint8_t first_symbol_flag,
                      uint16_t nb_rb,
                      uint32_t llr_offset,
@@ -810,7 +804,7 @@ void nr_dlsch_64qam_llr(NR_DL_FRAME_PARMS *frame_parms,
   int16x8_t *rxF = (int16x8_t*)&rxdataF_comp[0][(symbol*nb_rb*12)];
   int16x8_t *ch_mag,*ch_magb,xmm1,xmm2;
 #endif
-  int i,len,len2;
+  int i,len2;
   unsigned char len_mod4;
   short *llr;
   int16_t *llr2;
@@ -828,18 +822,13 @@ void nr_dlsch_64qam_llr(NR_DL_FRAME_PARMS *frame_parms,
   pllr_symbol += llr_offset;
 
 #if defined(__x86_64__) || defined(__i386__)
-  ch_mag = (__m128i*)&dl_ch_mag[0][(symbol*frame_parms->N_RB_DL*12)];
-  ch_magb = (__m128i*)&dl_ch_magb[0][(symbol*frame_parms->N_RB_DL*12)];
+  ch_mag = (__m128i*)&dl_ch_mag[0][(symbol*nb_rb*12)];
+  ch_magb = (__m128i*)&dl_ch_magb[0][(symbol*nb_rb*12)];
 #elif defined(__arm__)
-  ch_mag = (int16x8_t*)&dl_ch_mag[0][(symbol*frame_parms->N_RB_DL*12)];
-  ch_magb = (int16x8_t*)&dl_ch_magb[0][(symbol*frame_parms->N_RB_DL*12)];
+  ch_mag = (int16x8_t*)&dl_ch_mag[0][(symbol*nb_rb*12)];
+  ch_magb = (int16x8_t*)&dl_ch_magb[0][(symbol*nb_rb*12)];
 #endif
 
-    if (symbol ==2)  //to update from config
-  	  len = nb_rb*6;
-    else
-  	  len = nb_rb*12;
-
 //  printf("nr_dlsch_64qam_llr: symbol %d,nb_rb %d, len %d,pbch_pss_sss_adjust %d\n",symbol,nb_rb,len,pbch_pss_sss_adjust);
 
 /*  LOG_I(PHY,"nr_dlsch_64qam_llr [symb %d / FirstSym %d / Length %d]: @LLR Buff %x \n",
@@ -1131,18 +1120,17 @@ int nr_dlsch_qpsk_qpsk_llr(NR_DL_FRAME_PARMS *frame_parms,
                         int **rho_i,
                         short *dlsch_llr,
                         unsigned char symbol,
+						uint32_t len,
                         unsigned char first_symbol_flag,
                         unsigned short nb_rb,
                         uint16_t pbch_pss_sss_adjust,
                         short **llr16p)
 {
 
-  int16_t *rxF=(int16_t*)&rxdataF_comp[0][(symbol*frame_parms->N_RB_DL*12)];
-  int16_t *rxF_i=(int16_t*)&rxdataF_comp_i[0][(symbol*frame_parms->N_RB_DL*12)];
-  int16_t *rho=(int16_t*)&rho_i[0][(symbol*frame_parms->N_RB_DL*12)];
+  int16_t *rxF=(int16_t*)&rxdataF_comp[0][(symbol*nb_rb*12)];
+  int16_t *rxF_i=(int16_t*)&rxdataF_comp_i[0][(symbol*nb_rb*12)];
+  int16_t *rho=(int16_t*)&rho_i[0][(symbol*nb_rb*12)];
   int16_t *llr16;
-  int len;
-  uint8_t symbol_mod = (symbol >= (7-frame_parms->Ncp))? (symbol-(7-frame_parms->Ncp)) : symbol;
 
   if (first_symbol_flag == 1) {
     llr16 = (int16_t*)dlsch_llr;
@@ -1152,19 +1140,6 @@ int nr_dlsch_qpsk_qpsk_llr(NR_DL_FRAME_PARMS *frame_parms,
 
   AssertFatal(llr16!=NULL,"nr_dlsch_qpsk_qpsk_llr: llr is null, symbol %d\n",symbol);
 
-  if ((symbol_mod==0) || (symbol_mod==(4-frame_parms->Ncp))) {
-    // if symbol has pilots
-    if (frame_parms->nb_antenna_ports_eNB!=1)
-      // in 2 antenna ports we have 8 REs per symbol per RB
-      len = (nb_rb*8) - (2*pbch_pss_sss_adjust/3);
-    else
-      // for 1 antenna port we have 10 REs per symbol per RB
-      len = (nb_rb*10) - (5*pbch_pss_sss_adjust/6);
-  } else {
-    // symbol has no pilots
-    len = (nb_rb*12) - pbch_pss_sss_adjust;
-  }
-
   // printf("nr_dlsch_qpsk_qpsk_llr: symbol %d,nb_rb %d, len %d,pbch_pss_sss_adjust %d\n",symbol,nb_rb,len,pbch_pss_sss_adjust);
   //    printf("qpsk_qpsk: len %d, llr16 %p\n",len,llr16);
   qpsk_qpsk((short *)rxF,
@@ -2980,20 +2955,19 @@ int nr_dlsch_16qam_16qam_llr(NR_DL_FRAME_PARMS *frame_parms,
                           int32_t **rho_i,
                           int16_t *dlsch_llr,
                           uint8_t symbol,
+						  uint32_t len,
                           uint8_t first_symbol_flag,
                           uint16_t nb_rb,
                           uint16_t pbch_pss_sss_adjust,
                           int16_t **llr16p)
 {
 
-  int16_t *rxF      = (int16_t*)&rxdataF_comp[0][(symbol*frame_parms->N_RB_DL*12)];
-  int16_t *rxF_i    = (int16_t*)&rxdataF_comp_i[0][(symbol*frame_parms->N_RB_DL*12)];
-  int16_t *ch_mag   = (int16_t*)&dl_ch_mag[0][(symbol*frame_parms->N_RB_DL*12)];
-  int16_t *ch_mag_i = (int16_t*)&dl_ch_mag_i[0][(symbol*frame_parms->N_RB_DL*12)];
-  int16_t *rho      = (int16_t*)&rho_i[0][(symbol*frame_parms->N_RB_DL*12)];
+  int16_t *rxF      = (int16_t*)&rxdataF_comp[0][(symbol*nb_rb*12)];
+  int16_t *rxF_i    = (int16_t*)&rxdataF_comp_i[0][(symbol*nb_rb*12)];
+  int16_t *ch_mag   = (int16_t*)&dl_ch_mag[0][(symbol*nb_rb*12)];
+  int16_t *ch_mag_i = (int16_t*)&dl_ch_mag_i[0][(symbol*nb_rb*12)];
+  int16_t *rho      = (int16_t*)&rho_i[0][(symbol*nb_rb*12)];
   int16_t *llr16;
-  int len;
-  uint8_t symbol_mod = (symbol >= (7-frame_parms->Ncp))? (symbol-(7-frame_parms->Ncp)) : symbol;
 
   // first symbol has different structure due to more pilots
   if (first_symbol_flag == 1) {
@@ -3005,19 +2979,6 @@ int nr_dlsch_16qam_16qam_llr(NR_DL_FRAME_PARMS *frame_parms,
 
   AssertFatal(llr16!=NULL,"nr_dlsch_16qam_16qam_llr: llr is null, symbol %d\n",symbol);
 
-  if ((symbol_mod==0) || (symbol_mod==(4-frame_parms->Ncp))) {
-    // if symbol has pilots
-    if (frame_parms->nb_antenna_ports_eNB!=1)
-      // in 2 antenna ports we have 8 REs per symbol per RB
-      len = (nb_rb*8) - (2*pbch_pss_sss_adjust/3);
-    else
-      // for 1 antenna port we have 10 REs per symbol per RB
-      len = (nb_rb*10) - (5*pbch_pss_sss_adjust/6);
-  } else {
-    // symbol has no pilots
-    len = (nb_rb*12) - pbch_pss_sss_adjust;
-  }
-
   // printf("symbol %d: qam16_llr, len %d (llr16 %p)\n",symbol,len,llr16);
 
   qam16_qam16((short *)rxF,
@@ -8530,6 +8491,7 @@ int nr_dlsch_64qam_64qam_llr(NR_DL_FRAME_PARMS *frame_parms,
                           int32_t **rho_i,
                           int16_t *dlsch_llr,
                           uint8_t symbol,
+						  uint32_t len,
                           uint8_t first_symbol_flag,
                           uint16_t nb_rb,
                           uint16_t pbch_pss_sss_adjust,
@@ -8537,15 +8499,13 @@ int nr_dlsch_64qam_64qam_llr(NR_DL_FRAME_PARMS *frame_parms,
                           uint32_t llr_offset)
 {
 
-  int16_t *rxF      = (int16_t*)&rxdataF_comp[0][(symbol*frame_parms->N_RB_DL*12)];
-  int16_t *rxF_i    = (int16_t*)&rxdataF_comp_i[0][(symbol*frame_parms->N_RB_DL*12)];
-  int16_t *ch_mag   = (int16_t*)&dl_ch_mag[0][(symbol*frame_parms->N_RB_DL*12)];
-  int16_t *ch_mag_i = (int16_t*)&dl_ch_mag_i[0][(symbol*frame_parms->N_RB_DL*12)];
-  int16_t *rho      = (int16_t*)&rho_i[0][(symbol*frame_parms->N_RB_DL*12)];
+  int16_t *rxF      = (int16_t*)&rxdataF_comp[0][(symbol*nb_rb*12)];
+  int16_t *rxF_i    = (int16_t*)&rxdataF_comp_i[0][(symbol*nb_rb*12)];
+  int16_t *ch_mag   = (int16_t*)&dl_ch_mag[0][(symbol*nb_rb*12)];
+  int16_t *ch_mag_i = (int16_t*)&dl_ch_mag_i[0][(symbol*nb_rb*12)];
+  int16_t *rho      = (int16_t*)&rho_i[0][(symbol*nb_rb*12)];
   int16_t *llr16;
   int8_t  *pllr_symbol; // pointer where llrs should filled for this ofdm symbol
-  int len;
-  uint8_t symbol_mod = (symbol >= (7-frame_parms->Ncp))? (symbol-(7-frame_parms->Ncp)) : symbol;
 
   //first symbol has different structure due to more pilots
   /*if (first_symbol_flag == 1) {
@@ -8559,19 +8519,6 @@ int nr_dlsch_64qam_64qam_llr(NR_DL_FRAME_PARMS *frame_parms,
   AssertFatal(llr16!=NULL,"nr_dlsch_16qam_64qam_llr:llr is null, symbol %d\n",symbol);
 
 
-  if ((symbol_mod==0) || (symbol_mod==(4-frame_parms->Ncp))) {
-    // if symbol has pilots
-    if (frame_parms->nb_antenna_ports_eNB!=1)
-      // in 2 antenna ports we have 8 REs per symbol per RB
-      len = (nb_rb*8) - (2*pbch_pss_sss_adjust/3);
-    else
-      // for 1 antenna port we have 10 REs per symbol per RB
-      len = (nb_rb*10) - (5*pbch_pss_sss_adjust/6);
-  } else {
-    // symbol has no pilots
-    len = (nb_rb*12) - pbch_pss_sss_adjust;
-  }
-
   pllr_symbol = (int8_t*)dlsch_llr;
   pllr_symbol += llr_offset;
   //printf("nr_dlsch_64qam_64qam_llr: symbol %d,nb_rb %d, len %d,pbch_pss_sss_adjust %d\n",symbol,nb_rb,len,pbch_pss_sss_adjust);
diff --git a/openair1/PHY/NR_UE_TRANSPORT/nr_initial_sync.c b/openair1/PHY/NR_UE_TRANSPORT/nr_initial_sync.c
index e5f079ebc3..50c7bafbad 100644
--- a/openair1/PHY/NR_UE_TRANSPORT/nr_initial_sync.c
+++ b/openair1/PHY/NR_UE_TRANSPORT/nr_initial_sync.c
@@ -35,6 +35,7 @@
 #include "PHY/INIT/phy_init.h"
 #include "PHY/MODULATION/modulation_UE.h"
 #include "nr_transport_proto_ue.h"
+#include "PHY/NR_UE_ESTIMATION/nr_estimation.h"
 //#include "SCHED/defs.h"
 //#include "SCHED/extern.h"
 
@@ -52,61 +53,126 @@ int cnt=0;
 
 #define DEBUG_INITIAL_SYNCH
 
-int nr_pbch_detection(PHY_VARS_NR_UE *ue, runmode_t mode)
+
+// create a new node of SSB structure
+NR_UE_SSB* create_ssb_node(uint8_t  i, uint8_t  h) {
+
+  NR_UE_SSB *new_node = (NR_UE_SSB*)malloc(sizeof(NR_UE_SSB));
+  new_node->i_ssb = i;
+  new_node->n_hf = h;
+  new_node->c_re = 0;
+  new_node->c_im = 0;
+  new_node->metric = 0;
+  new_node->next_ssb = NULL;
+
+  return new_node;
+}
+
+
+// insertion of the structure in the ordered list (highest metric first)
+NR_UE_SSB* insert_into_list(NR_UE_SSB *head, NR_UE_SSB *node) {
+
+  if (node->metric > head->metric) {
+    node->next_ssb = head;
+    head = node;
+    return head;
+  }
+
+  NR_UE_SSB *current = head;
+  while (current->next_ssb !=NULL) {
+    NR_UE_SSB *temp=current->next_ssb;
+    if(node->metric > temp->metric) {
+      node->next_ssb = temp;
+      current->next_ssb = node;
+      return head;
+    }
+    else
+      current = temp;
+  }
+  current->next_ssb = node;
+
+  return head;
+}
+
+
+void free_list(NR_UE_SSB *node) {
+  if (node->next_ssb != NULL)
+    free_list(node->next_ssb);
+  free(node);
+}
+
+
+int nr_pbch_detection(UE_nr_rxtx_proc_t * proc, PHY_VARS_NR_UE *ue, int pbch_initial_symbol, runmode_t mode)
 {
   NR_DL_FRAME_PARMS *frame_parms=&ue->frame_parms;
   int ret =-1;
 
+  NR_UE_SSB *best_ssb = NULL;
+  NR_UE_SSB *current_ssb;
 
 #ifdef DEBUG_INITIAL_SYNCH
   LOG_I(PHY,"[UE%d] Initial sync: starting PBCH detection (rx_offset %d)\n",ue->Mod_id,
         ue->rx_offset);
 #endif
 
-  // save the nb_prefix_samples0 since we are not synchronized to subframes yet and the SSB has all symbols with nb_prefix_samples
-  int nb_prefix_samples0 = frame_parms->nb_prefix_samples0;
-  frame_parms->nb_prefix_samples0 = frame_parms->nb_prefix_samples;
+  uint8_t  N_L = (frame_parms->Lmax == 4)? 4:8;
+  uint8_t  N_hf = (frame_parms->Lmax == 4)? 2:1;
 
+  // loops over possible pbch dmrs cases to retrive best estimated i_ssb (and n_hf for Lmax=4) for multiple ssb detection
+  for (int hf = 0; hf < N_hf; hf++) {
+    for (int l = 0; l < N_L ; l++) {
 
-  //symbol 1
-  nr_slot_fep(ue,
-	      1,
-	      0,
-	      ue->ssb_offset,
-	      0,
-	      1,
-	      NR_PBCH_EST);
-  
-  //symbol 2
-  nr_slot_fep(ue,
-	      2,
-	      0,
-	      ue->ssb_offset,
-	      0,
-	      1,
-	      NR_PBCH_EST);
+      // initialization of structure
+      current_ssb = create_ssb_node(l,hf);
 
-  //symbol 3
-  nr_slot_fep(ue,
-	      3,
-	      0,
-	      ue->ssb_offset,
-	      0,
-	      1,
-	      NR_PBCH_EST);
+#if UE_TIMING_TRACE
+      start_meas(&ue->dlsch_channel_estimation_stats);
+#endif
+      // computing correlation between received DMRS symbols and transmitted sequence for current i_ssb and n_hf
+      for(int i=pbch_initial_symbol; i<pbch_initial_symbol+3;i++)
+          nr_pbch_dmrs_correlation(ue,0,0,i,i-pbch_initial_symbol,current_ssb);
+#if UE_TIMING_TRACE
+      stop_meas(&ue->dlsch_channel_estimation_stats);
+#endif
+      
+      current_ssb->metric = current_ssb->c_re*current_ssb->c_re + current_ssb->c_im+current_ssb->c_re;
+      
+      // generate a list of SSB structures
+      if (best_ssb == NULL)
+        best_ssb = current_ssb;
+      else
+        best_ssb = insert_into_list(best_ssb,current_ssb);
+
+    }
+  }
+
+  NR_UE_SSB *temp_ptr=best_ssb;
+  while (ret!=0 && temp_ptr != NULL) {
+
+#if UE_TIMING_TRACE
+    start_meas(&ue->dlsch_channel_estimation_stats);
+#endif
+  // computing channel estimation for selected best ssb
+    for(int i=pbch_initial_symbol; i<pbch_initial_symbol+3;i++)
+      nr_pbch_channel_estimation(ue,0,0,i,i-pbch_initial_symbol,temp_ptr->i_ssb,temp_ptr->n_hf);
+#if UE_TIMING_TRACE
+    stop_meas(&ue->dlsch_channel_estimation_stats);
+#endif
+
+    ret = nr_rx_pbch(ue,
+	             proc,
+		     ue->pbch_vars[0],
+		     frame_parms,
+		     0,
+		     temp_ptr->i_ssb,
+                     SISO,
+                     ue->high_speed_flag);
+
+    temp_ptr=temp_ptr->next_ssb;
+  }
+
+  free_list(best_ssb);
 
-  //put back nb_prefix_samples0
-  frame_parms->nb_prefix_samples0 = nb_prefix_samples0;
-  
-  
-  ret = nr_rx_pbch(ue,
-		   &ue->proc.proc_rxtx[0],
-		   ue->pbch_vars[0],
-		   frame_parms,
-		   0,
-		   SISO,
-		   ue->high_speed_flag);
-  
   
   if (ret==0) {
     
@@ -122,11 +188,6 @@ int nr_pbch_detection(PHY_VARS_NR_UE *ue, runmode_t mode)
     //    ue->pbch_vars[0]->decoded_output[0] = ue->pbch_vars[0]->decoded_output[2];
     //    ue->pbch_vars[0]->decoded_output[2] = dummy;
 
-    for(int i=0; i<RX_NB_TH;i++)
-    {
-
-        ue->proc.proc_rxtx[i].frame_tx = ue->proc.proc_rxtx[0].frame_rx;
-    }
 #ifdef DEBUG_INITIAL_SYNCH
     LOG_I(PHY,"[UE%d] Initial sync: pbch decoded sucessfully\n",ue->Mod_id);
 #endif
@@ -140,10 +201,10 @@ int nr_pbch_detection(PHY_VARS_NR_UE *ue, runmode_t mode)
 char duplex_string[2][4] = {"FDD","TDD"};
 char prefix_string[2][9] = {"NORMAL","EXTENDED"};
 
-int nr_initial_sync(PHY_VARS_NR_UE *ue, runmode_t mode)
+int nr_initial_sync(UE_nr_rxtx_proc_t *proc, PHY_VARS_NR_UE *ue, runmode_t mode)
 {
 
-  int32_t sync_pos, sync_pos_slot; // k_ssb, N_ssb_crb, sync_pos2,
+  int32_t sync_pos, sync_pos_frame; // k_ssb, N_ssb_crb, sync_pos2,
   int32_t metric_tdd_ncp=0;
   uint8_t phase_tdd_ncp;
   double im, re;
@@ -186,20 +247,17 @@ int nr_initial_sync(PHY_VARS_NR_UE *ue, runmode_t mode)
   /* process pss search on received buffer */
   sync_pos = pss_synchro_nr(ue, NO_RATE_CHANGE);
 
-  sync_pos_slot = (fp->samples_per_subframe/fp->slots_per_subframe) - 10*(fp->ofdm_symbol_size + fp->nb_prefix_samples);
+  if (sync_pos >= fp->nb_prefix_samples)
+    ue->ssb_offset = sync_pos - fp->nb_prefix_samples;
+  else
+    ue->ssb_offset = sync_pos + (fp->samples_per_subframe * 10) - fp->nb_prefix_samples;
 
-  if (sync_pos >= fp->nb_prefix_samples){
-    ue->ssb_offset = sync_pos - fp->nb_prefix_samples;}
-  else{
-    ue->ssb_offset = sync_pos + (fp->samples_per_subframe * 10) - fp->nb_prefix_samples;}
-    
-  ue->rx_offset = ue->ssb_offset - sync_pos_slot;
 
   //write_output("rxdata1.m","rxd1",ue->common_vars.rxdata[0],10*fp->samples_per_subframe,1,1);
 
 #ifdef DEBUG_INITIAL_SYNCH
   LOG_I(PHY,"[UE%d] Initial sync : Estimated PSS position %d, Nid2 %d\n", ue->Mod_id, sync_pos,ue->common_vars.eNb_id);
-  LOG_I(PHY,"sync_pos %d ssb_offset %d sync_pos_slot %d \n",sync_pos,ue->ssb_offset,sync_pos_slot);
+  LOG_I(PHY,"sync_pos %d ssb_offset %d \n",sync_pos,ue->ssb_offset);
 #endif
 
   // digital compensation of FFO for SSB symbols
@@ -224,6 +282,22 @@ int nr_initial_sync(PHY_VARS_NR_UE *ue, runmode_t mode)
   /* check that SSS/PBCH block is continuous inside the received buffer */
   if (sync_pos < (NR_NUMBER_OF_SUBFRAMES_PER_FRAME*fp->samples_per_subframe - (NB_SYMBOLS_PBCH * fp->ofdm_symbol_size))) {
 
+    /* slop_fep function works for lte and takes into account begining of frame with prefix for subframe 0 */
+    /* for NR this is not the case but slot_fep is still used for computing FFT of samples */
+    /* in order to achieve correct processing for NR prefix samples is forced to 0 and then restored after function call */
+    /* symbol number are from beginning of SS/PBCH blocks as below:  */
+    /*    Signal            PSS  PBCH  SSS  PBCH                     */
+    /*    symbol number      0     1    2    3                       */
+    /* time samples in buffer rxdata are used as input of FFT -> FFT results are stored in the frequency buffer rxdataF */
+    /* rxdataF stores SS/PBCH from beginning of buffers in the same symbol order as in time domain */
+
+    for(int i=0; i<4;i++)
+      nr_slot_fep(ue,
+	          i,
+	          0,
+	          ue->ssb_offset,
+	          0);
+
 #ifdef DEBUG_INITIAL_SYNCH
     LOG_I(PHY,"Calling sss detection (normal CP)\n");
 #endif
@@ -234,15 +308,22 @@ int nr_initial_sync(PHY_VARS_NR_UE *ue, runmode_t mode)
     //nr_init_frame_parms_ue(fp,NR_MU_1,NORMAL,n_ssb_crb,0);
 
     nr_gold_pbch(ue);
-    ret = nr_pbch_detection(ue,mode);
-    
+    ret = nr_pbch_detection(proc, ue,1,mode);  // start pbch detection at first symbol after pss
+
+    if (ret == 0) {
+      // sync at symbol ue->symbol_offset
+      // computing the offset wrt the beginning of the frame
+      sync_pos_frame = (fp->ofdm_symbol_size + fp->nb_prefix_samples0)+((ue->symbol_offset)-1)*(fp->ofdm_symbol_size + fp->nb_prefix_samples);
+      ue->rx_offset = ue->ssb_offset - sync_pos_frame;
+    }   
+
     nr_gold_pdcch(ue,0, 2);
     /*
     int nb_prefix_samples0 = fp->nb_prefix_samples0;
     fp->nb_prefix_samples0 = fp->nb_prefix_samples;
 	  
-    nr_slot_fep(ue,0, 0, ue->ssb_offset, 0, 1, NR_PDCCH_EST);
-    nr_slot_fep(ue,1, 0, ue->ssb_offset, 0, 1, NR_PDCCH_EST);
+    nr_slot_fep(ue,0, 0, ue->ssb_offset, 0, NR_PDCCH_EST);
+    nr_slot_fep(ue,1, 0, ue->ssb_offset, 0, NR_PDCCH_EST);
     fp->nb_prefix_samples0 = nb_prefix_samples0;	
 
     LOG_I(PHY,"[UE  %d] AUTOTEST Cell Sync : frame = %d, rx_offset %d, freq_offset %d \n",
@@ -259,7 +340,7 @@ int nr_initial_sync(PHY_VARS_NR_UE *ue, runmode_t mode)
   }
   else {
 #ifdef DEBUG_INITIAL_SYNCH
-    LOG_I(PHY,"TDD Normal prefix: SSS error condition: sync_pos %d, sync_pos_slot %d\n", sync_pos, sync_pos_slot);
+    LOG_I(PHY,"TDD Normal prefix: SSS error condition: sync_pos %d\n", sync_pos);
 #endif
   }
   }
@@ -292,9 +373,8 @@ int nr_initial_sync(PHY_VARS_NR_UE *ue, runmode_t mode)
     if (ue->UE_scan_carrier == 0) {
 
     #if UE_AUTOTEST_TRACE
-      LOG_I(PHY,"[UE  %d] AUTOTEST Cell Sync : frame = %d, rx_offset %d, freq_offset %d \n",
+      LOG_I(PHY,"[UE  %d] AUTOTEST Cell Sync : rx_offset %d, freq_offset %d \n",
               ue->Mod_id,
-              ue->proc.proc_rxtx[0].frame_rx,
               ue->rx_offset,
               ue->common_vars.freq_offset );
     #endif
@@ -305,30 +385,7 @@ int nr_initial_sync(PHY_VARS_NR_UE *ue, runmode_t mode)
 
     }
 
-#if DISABLE_LOG_X
-    printf("[UE %d] Frame %d RRC Measurements => rssi %3.1f dBm (dig %3.1f dB, gain %d), N0 %d dBm,  rsrp %3.1f dBm/RE, rsrq %3.1f dB\n",ue->Mod_id,
-	  ue->proc.proc_rxtx[0].frame_rx,
-	  10*log10(ue->measurements.rssi)-ue->rx_total_gain_dB,
-	  10*log10(ue->measurements.rssi),
-	  ue->rx_total_gain_dB,
-	  ue->measurements.n0_power_tot_dBm,
-	  10*log10(ue->measurements.rsrp[0])-ue->rx_total_gain_dB,
-	  (10*log10(ue->measurements.rsrq[0])));
-
-
-    printf("[UE %d] Frame %d MIB Information => %s, %s, NidCell %d, N_RB_DL %d, PHICH DURATION %d, PHICH RESOURCE %s, TX_ANT %d\n",
-	  ue->Mod_id,
-	  ue->proc.proc_rxtx[0].frame_rx,
-	  duplex_string[fp->frame_type],
-	  prefix_string[fp->Ncp],
-	  fp->Nid_cell,
-	  fp->N_RB_DL,
-	  fp->phich_config_common.phich_duration,
-	  phich_string[fp->phich_config_common.phich_resource],
-	  fp->nb_antenna_ports_eNB);
-#else
-    LOG_I(PHY, "[UE %d] Frame %d RRC Measurements => rssi %3.1f dBm (dig %3.1f dB, gain %d), N0 %d dBm,  rsrp %3.1f dBm/RE, rsrq %3.1f dB\n",ue->Mod_id,
-	  ue->proc.proc_rxtx[0].frame_rx,
+    LOG_I(PHY, "[UE %d] RRC Measurements => rssi %3.1f dBm (dig %3.1f dB, gain %d), N0 %d dBm,  rsrp %3.1f dBm/RE, rsrq %3.1f dB\n",ue->Mod_id,
 	  10*log10(ue->measurements.rssi)-ue->rx_total_gain_dB,
 	  10*log10(ue->measurements.rssi),
 	  ue->rx_total_gain_dB,
@@ -346,22 +403,12 @@ int nr_initial_sync(PHY_VARS_NR_UE *ue, runmode_t mode)
 	  fp->phich_config_common.phich_duration,
 	  phich_string[fp->phich_config_common.phich_resource],
 	  fp->nb_antenna_ports_eNB);*/
-#endif
 
 #if defined(OAI_USRP) || defined(EXMIMO) || defined(OAI_BLADERF) || defined(OAI_LMSSDR) || defined(OAI_ADRV9371_ZC706)
-#  if DISABLE_LOG_X
-    printf("[UE %d] Frame %d Measured Carrier Frequency %.0f Hz (offset %d Hz)\n",
+    LOG_I(PHY, "[UE %d] Measured Carrier Frequency %.0f Hz (offset %d Hz)\n",
 	  ue->Mod_id,
-	  ue->proc.proc_rxtx[0].frame_rx,
 	  openair0_cfg[0].rx_freq[0]+ue->common_vars.freq_offset,
 	  ue->common_vars.freq_offset);
-#  else
-    LOG_I(PHY, "[UE %d] Frame %d Measured Carrier Frequency %.0f Hz (offset %d Hz)\n",
-	  ue->Mod_id,
-	  ue->proc.proc_rxtx[0].frame_rx,
-	  openair0_cfg[0].rx_freq[0]+ue->common_vars.freq_offset,
-	  ue->common_vars.freq_offset);
-#  endif
 #endif
   } else {
 #ifdef DEBUG_INITIAL_SYNC
diff --git a/openair1/PHY/NR_UE_TRANSPORT/nr_pbch.c b/openair1/PHY/NR_UE_TRANSPORT/nr_pbch.c
index 1ce2f347ab..d23f164534 100644
--- a/openair1/PHY/NR_UE_TRANSPORT/nr_pbch.c
+++ b/openair1/PHY/NR_UE_TRANSPORT/nr_pbch.c
@@ -34,6 +34,7 @@
 #include "PHY/phy_extern_nr_ue.h"
 #include "PHY/sse_intrin.h"
 #include "PHY/LTE_REFSIG/lte_refsig.h"
+#include "PHY/INIT/phy_init.h"
 
 //#define DEBUG_PBCH 1
 //#define DEBUG_PBCH_ENCODING
@@ -413,6 +414,7 @@ int nr_rx_pbch( PHY_VARS_NR_UE *ue,
                 NR_UE_PBCH *nr_ue_pbch_vars,
                 NR_DL_FRAME_PARMS *frame_parms,
                 uint8_t eNB_id,
+                uint8_t i_ssb,
                 MIMO_mode_t mimo_mode,
                 uint32_t high_speed_flag) {
   NR_UE_COMMON *nr_ue_common_vars = &ue->common_vars;
@@ -423,10 +425,9 @@ int nr_rx_pbch( PHY_VARS_NR_UE *ue,
   //uint32_t pbch_a_prime;
   int16_t *pbch_e_rx;
   uint8_t *decoded_output = nr_ue_pbch_vars->decoded_output;
-  uint8_t nushift;
+  uint8_t nushift,n_hf,ssb_index;
   uint16_t M;
-  uint8_t Lmax=8; //to update
-  uint8_t ssb_index=0;
+  uint8_t Lmax=frame_parms->Lmax; 
   //uint16_t crc;
   //unsigned short idx_demod =0;
   uint32_t decoderState=0;
@@ -435,27 +436,27 @@ int nr_rx_pbch( PHY_VARS_NR_UE *ue,
   //time_stats_t path_metric,sorting,update_LLR;
   memset(&pbch_a[0], 0, sizeof(uint8_t) * NR_POLAR_PBCH_PAYLOAD_BITS);
   //printf("nr_pbch_ue nid_cell %d\n",frame_parms->Nid_cell);
-  int subframe_rx = proc->subframe_rx;
+
   pbch_e_rx = &nr_ue_pbch_vars->llr[0];
   // clear LLR buffer
   memset(nr_ue_pbch_vars->llr,0,NR_POLAR_PBCH_E);
   int symbol_offset=1;
 
   if (ue->is_synchronized > 0)
-    symbol_offset=4;
+    symbol_offset=ue->symbol_offset;
   else
     symbol_offset=0;
 
 #ifdef DEBUG_PBCH
-  //printf("address dataf %p",nr_ue_common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[subframe_rx]].rxdataF);
+  //printf("address dataf %p",nr_ue_common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[proc->subframe_rx]].rxdataF);
   write_output("rxdataF0_pbch.m","rxF0pbch",
-               &nr_ue_common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[subframe_rx]].rxdataF[0][(symbol_offset+1)*frame_parms->ofdm_symbol_size],frame_parms->ofdm_symbol_size*3,1,1);
+               &nr_ue_common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[proc->subframe_rx]].rxdataF[0][(symbol_offset+1)*frame_parms->ofdm_symbol_size],frame_parms->ofdm_symbol_size*3,1,1);
 #endif
 
   // symbol refers to symbol within SSB. symbol_offset is the offset of the SSB wrt start of slot
   for (symbol=1; symbol<4; symbol++) {
-    nr_pbch_extract(nr_ue_common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[subframe_rx]].rxdataF,
-                    nr_ue_common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[subframe_rx]].dl_ch_estimates[eNB_id],
+    nr_pbch_extract(nr_ue_common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[proc->subframe_rx]].rxdataF,
+                    nr_ue_pbch_vars->dl_ch_estimates,
                     nr_ue_pbch_vars->rxdataF_ext,
                     nr_ue_pbch_vars->dl_ch_estimates_ext,
                     symbol,
@@ -526,7 +527,7 @@ int nr_rx_pbch( PHY_VARS_NR_UE *ue,
 #endif
   //un-scrambling
   M =  NR_POLAR_PBCH_E;
-  nushift = (Lmax==4)? ssb_index&3 : ssb_index&7;
+  nushift = (Lmax==4)? i_ssb&3 : i_ssb&7;
   uint32_t unscrambling_mask = (Lmax==64)?0x100006D:0x1000041;
   nr_pbch_unscrambling(nr_ue_pbch_vars,frame_parms->Nid_cell,nushift,M,NR_POLAR_PBCH_E,0,0);
   //polar decoding de-rate matching
@@ -570,6 +571,16 @@ int nr_rx_pbch( PHY_VARS_NR_UE *ue,
   for (int i=0; i<3; i++)
     decoded_output[i] = (uint8_t)((payload>>((3-i)<<3))&0xff);
 
+  n_hf = ((xtra_byte>>4)&0x01); // computing the half frame index from the extra byte
+
+  ssb_index = i_ssb;  // ssb index corresponds to i_ssb for Lmax = 4,8
+  if (Lmax == 64) {   // for Lmax = 64 ssb index 4th,5th and 6th bits are in extra byte
+    for (int i=0; i<3; i++)
+      ssb_index += (((xtra_byte>>(7-i))&0x01)<<(3+i));
+  }
+
+  ue->symbol_offset = nr_get_ssb_start_symbol(frame_parms, ssb_index, n_hf);
+
 #ifdef DEBUG_PBCH
   printf("xtra_byte %x payload %x\n", xtra_byte, payload);
 
@@ -577,14 +588,15 @@ int nr_rx_pbch( PHY_VARS_NR_UE *ue,
     //     printf("unscrambling pbch_a[%d] = %x \n", i,pbch_a[i]);
     printf("[PBCH] decoder payload[%d] = %x\n",i,decoded_output[i]);
   }
-
 #endif
+
   ue->dl_indication.rx_ind = &ue->rx_ind; //  hang on rx_ind instance
+  ue->dl_indication.proc=proc;
   //ue->rx_ind.sfn_slot = 0;  //should be set by higher-1-layer, i.e. clean_and_set_if_instance()
   ue->rx_ind.rx_indication_body[0].pdu_type = FAPI_NR_RX_PDU_TYPE_MIB;
   ue->rx_ind.rx_indication_body[0].mib_pdu.pdu = &decoded_output[0];
   ue->rx_ind.rx_indication_body[0].mib_pdu.additional_bits = xtra_byte;
-  ue->rx_ind.rx_indication_body[0].mib_pdu.ssb_index = ssb_index;            //  confirm with TCL
+  ue->rx_ind.rx_indication_body[0].mib_pdu.ssb_index = i_ssb;                //  confirm with TCL
   ue->rx_ind.rx_indication_body[0].mib_pdu.ssb_length = Lmax;                //  confirm with TCL
   ue->rx_ind.rx_indication_body[0].mib_pdu.cell_id = frame_parms->Nid_cell;  //  confirm with TCL
   ue->rx_ind.number_pdus = 1;
diff --git a/openair1/PHY/NR_UE_TRANSPORT/nr_transport_proto_ue.h b/openair1/PHY/NR_UE_TRANSPORT/nr_transport_proto_ue.h
index 3c272b9c17..e7af632327 100644
--- a/openair1/PHY/NR_UE_TRANSPORT/nr_transport_proto_ue.h
+++ b/openair1/PHY/NR_UE_TRANSPORT/nr_transport_proto_ue.h
@@ -61,10 +61,10 @@ void free_nr_ue_dlsch(NR_UE_DLSCH_t *dlsch);
 NR_UE_DLSCH_t *new_nr_ue_dlsch(uint8_t Kmimo,uint8_t Mdlharq,uint32_t Nsoft,uint8_t max_turbo_iterations,uint8_t N_RB_DL, uint8_t abstraction_flag);
 
 
-void free_ue_ulsch(NR_UE_ULSCH_t *ulsch);
+void free_nr_ue_ulsch(NR_UE_ULSCH_t *ulsch);
 
 
-NR_UE_ULSCH_t *new_ue_ulsch(unsigned char N_RB_UL, uint8_t abstraction_flag);
+NR_UE_ULSCH_t *new_nr_ue_ulsch(unsigned char N_RB_UL, int number_of_harq_pids, uint8_t abstraction_flag);
 
 void fill_UE_dlsch_MCH(PHY_VARS_NR_UE *ue,int mcs,int ndi,int rvidx,int eNB_id);
 
@@ -113,6 +113,7 @@ int32_t nr_dlsch_qpsk_qpsk_llr(NR_DL_FRAME_PARMS *frame_parms,
                             int32_t **rho_i,
                             int16_t *dlsch_llr,
                             uint8_t symbol,
+							uint32_t len,
                             uint8_t first_symbol_flag,
                             uint16_t nb_rb,
                             uint16_t pbch_pss_sss_adj,
@@ -268,6 +269,7 @@ int nr_dlsch_16qam_16qam_llr(NR_DL_FRAME_PARMS *frame_parms,
                           int **rho_i,
                           short *dlsch_llr,
                           unsigned char symbol,
+						  uint32_t len,
                           unsigned char first_symbol_flag,
                           unsigned short nb_rb,
                           uint16_t pbch_pss_sss_adjust,
@@ -464,6 +466,7 @@ int nr_dlsch_64qam_64qam_llr(NR_DL_FRAME_PARMS *frame_parms,
                           int **rho_i,
                           short *dlsch_llr,
                           unsigned char symbol,
+						  uint32_t len,
                           unsigned char first_symbol_flag,
                           unsigned short nb_rb,
                           uint16_t pbch_pss_sss_adjust,
@@ -486,6 +489,7 @@ int32_t nr_dlsch_qpsk_llr(NR_DL_FRAME_PARMS *frame_parms,
                    int32_t **rxdataF_comp,
                    int16_t *dlsch_llr,
                    uint8_t symbol,
+				   uint32_t len,
 				   uint8_t first_symbol_flag,
                    uint16_t nb_rb,
                    uint8_t beamforming_mode);
@@ -520,6 +524,7 @@ void nr_dlsch_16qam_llr(NR_DL_FRAME_PARMS *frame_parms,
                      int16_t *dlsch_llr,
                      int32_t **dl_ch_mag,
                      uint8_t symbol,
+					 uint32_t len,
                      uint8_t first_symbol_flag,
                      uint16_t nb_rb,
                      int16_t **llr32p,
@@ -568,6 +573,7 @@ void nr_dlsch_64qam_llr(NR_DL_FRAME_PARMS *frame_parms,
                      int32_t **dl_ch_mag,
                      int32_t **dl_ch_magb,
                      uint8_t symbol,
+					 uint32_t len,
                      uint8_t first_symbol_flag,
                      uint16_t nb_rb,
                      uint32_t llr_offset,
@@ -722,8 +728,8 @@ unsigned short nr_dlsch_extract_rbs_single(int **rxdataF,
                                         int **dl_ch_estimates_ext,
                                         unsigned short pmi,
                                         unsigned char *pmi_ext,
-                                        unsigned int *rb_alloc,
                                         unsigned char symbol,
+										uint8_t pilots,
 										unsigned short start_rb,
 										unsigned short nb_pdsch_rb,
                                         unsigned char nr_tti_rx,
@@ -753,18 +759,20 @@ unsigned short nr_dlsch_extract_rbs_single(int **rxdataF,
     @param high_speed_flag
     @param frame_parms Pointer to frame descriptor
 */
-uint16_t dlsch_extract_rbs_dual(int32_t **rxdataF,
-                                int32_t **dl_ch_estimates,
-                                int32_t **rxdataF_ext,
-                                int32_t **dl_ch_estimates_ext,
-                                uint16_t pmi,
-                                uint8_t *pmi_ext,
-                                uint32_t *rb_alloc,
-                                uint8_t symbol,
-                                uint8_t subframe,
-                                uint32_t high_speed_flag,
-                                NR_DL_FRAME_PARMS *frame_parms,
-                                MIMO_mode_t mimo_mode);
+unsigned short nr_dlsch_extract_rbs_dual(int **rxdataF,
+                                      int **dl_ch_estimates,
+                                      int **rxdataF_ext,
+                                      int **dl_ch_estimates_ext,
+                                      unsigned short pmi,
+                                      unsigned char *pmi_ext,
+                                      unsigned char symbol,
+									  uint8_t pilots,
+									  unsigned short start_rb,
+									  unsigned short nb_rb_pdsch,
+                                      unsigned char nr_tti_rx,
+                                      uint32_t high_speed_flag,
+                                      NR_DL_FRAME_PARMS *frame_parms,
+                                      MIMO_mode_t mimo_mode);
 
 /** \fn dlsch_extract_rbs_TM7(int32_t **rxdataF,
     int32_t **dl_bf_ch_estimates,
@@ -820,13 +828,28 @@ void nr_dlsch_channel_compensation(int32_t **rxdataF_ext,
                                 int32_t **rho,
                                 NR_DL_FRAME_PARMS *frame_parms,
                                 uint8_t symbol,
+								uint8_t start_symbol,
                                 uint8_t first_symbol_flag,
                                 uint8_t mod_order,
                                 uint16_t nb_rb,
                                 uint8_t output_shift,
                                 PHY_NR_MEASUREMENTS *phy_measurements);
 
+void nr_dlsch_channel_compensation_core(int **rxdataF_ext,
+                                     int **dl_ch_estimates_ext,
+                                     int **dl_ch_mag,
+                                     int **dl_ch_magb,
+                                     int **rxdataF_comp,
+                                     int **rho,
+                                     unsigned char n_tx,
+                                     unsigned char n_rx,
+                                     unsigned char mod_order,
+                                     unsigned char output_shift,
+                                     int length,
+                                     int start_point);
+
 void nr_dlsch_deinterleaving(uint8_t symbol,
+							uint8_t start_symbol,
 							uint16_t L,
 							uint16_t *llr,
 							uint16_t *llr_deint,
@@ -881,6 +904,26 @@ void dlsch_channel_level_TM34_meas(int *ch00,
                                    int *avg_1,
                                    unsigned short nb_rb);
 
+void nr_dlsch_channel_level_median(int **dl_ch_estimates_ext,
+                                int32_t *median,
+                                int n_tx,
+                                int n_rx,
+                                int length,
+                                int start_point);
+
+void nr_dlsch_detection_mrc_core(int **rxdataF_comp,
+                              int **rxdataF_comp_i,
+                              int **rho,
+                              int **rho_i,
+                              int **dl_ch_mag,
+                              int **dl_ch_magb,
+                              int **dl_ch_mag_i,
+                              int **dl_ch_magb_i,
+                              unsigned char n_tx,
+                              unsigned char n_rx,
+                              int length,
+                              int start_point);
+
 void det_HhH(int32_t *after_mf_00,
              int32_t *after_mf_01,
              int32_t *after_mf_10,
@@ -939,11 +982,12 @@ void dlsch_channel_compensation_TM34(NR_DL_FRAME_PARMS *frame_parms,
     @param pilots_flag Flag to indicate pilots in symbol
     @param nb_rb Number of allocated RBs
 */
-void nr_dlsch_channel_level(int32_t **dl_ch_estimates_ext,
+void nr_dlsch_channel_level(int **dl_ch_estimates_ext,
                          NR_DL_FRAME_PARMS *frame_parms,
                          int32_t *avg,
-                         uint8_t pilots_flag,
-                         uint16_t nb_rb);
+                         uint8_t symbol,
+						 uint32_t len,
+                         unsigned short nb_rb);
 
 
 void dlsch_channel_level_TM34(int **dl_ch_estimates_ext,
@@ -972,7 +1016,8 @@ void dlsch_channel_level_TM7(int32_t **dl_bf_ch_estimates_ext,
 void nr_dlsch_scale_channel(int32_t **dl_ch_estimates_ext,
                          NR_DL_FRAME_PARMS *frame_parms,
                          NR_UE_DLSCH_t **dlsch_ue,
-                         uint8_t symbol_mod,
+                         uint8_t symbol,
+						 uint8_t start_symbol,
                          uint16_t nb_rb);
 
 /** \brief This is the top-level entry point for DLSCH decoding in UE.  It should be replicated on several
@@ -1006,6 +1051,25 @@ uint32_t  nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
                          uint8_t is_crnti,
                          uint8_t llr8_flag);
 
+int nr_ulsch_encoding(NR_UE_ULSCH_t *ulsch,
+                     NR_DL_FRAME_PARMS* frame_parms,
+                     uint8_t harq_pid);
+
+/*! \brief Perform PUSCH scrambling. TS 38.211 V15.4.0 subclause 6.3.1.1
+  @param[in] in Pointer to input bits
+  @param[in] size of input bits
+  @param[in] Nid cell id
+  @param[in] n_RNTI CRNTI
+  @param[out] out the scrambled bits
+*/
+
+void nr_pusch_codeword_scrambling(uint8_t *in,
+                         uint16_t size,
+                         uint32_t Nid,
+                         uint32_t n_RNTI,
+                         uint32_t* out);
+
+
 uint32_t  nr_dlsch_decoding_mthread(PHY_VARS_NR_UE *phy_vars_ue,
 						 UE_nr_rxtx_proc_t *proc,
                          int eNB_id,
@@ -1122,9 +1186,15 @@ int nr_rx_pbch( PHY_VARS_NR_UE *ue,
 		     NR_UE_PBCH *nr_ue_pbch_vars,
 		     NR_DL_FRAME_PARMS *frame_parms,
 		     uint8_t eNB_id,
+                     uint8_t i_ssb,
 		     MIMO_mode_t mimo_mode,
 		     uint32_t high_speed_flag);
 
+int nr_pbch_detection(UE_nr_rxtx_proc_t *proc,
+		      PHY_VARS_NR_UE *ue,
+		      int pbch_initial_symbol,
+		      runmode_t mode);
+
 uint16_t rx_pbch_emul(PHY_VARS_NR_UE *phy_vars_ue,
                       uint8_t eNB_id,
                       uint8_t pbch_phase);
@@ -1409,7 +1479,8 @@ void generate_RIV_tables(void);
   @param phy_vars_ue Pointer to UE variables
   @param mode current running mode
 */
-int nr_initial_sync(PHY_VARS_NR_UE *phy_vars_ue, runmode_t mode);
+int nr_initial_sync(UE_nr_rxtx_proc_t *proc,
+                    PHY_VARS_NR_UE *phy_vars_ue, runmode_t mode);
 
 
 /*!
@@ -1675,7 +1746,7 @@ int nr_generate_ue_ul_dlsch_params_from_dci(PHY_VARS_NR_UE *ue,
         uint8_t eNB_id,
         int frame,
         uint8_t nr_tti_rx,
-        uint32_t dci_pdu[4],
+        uint64_t dci_pdu[2],
         uint16_t rnti,
         uint8_t dci_length,
         NR_DCI_format_t dci_format,
@@ -1707,16 +1778,31 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
 uint32_t nr_get_G(uint16_t nb_rb, uint16_t nb_symb_sch,uint8_t nb_re_dmrs,uint16_t length_dmrs, uint8_t Qm, uint8_t Nl) ;
 
 uint32_t  nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
-                         short *dlsch_llr,
-                         NR_DL_FRAME_PARMS *frame_parms,
-                         NR_UE_DLSCH_t *dlsch,
-                         NR_DL_UE_HARQ_t *harq_process,
-                         uint32_t frame,
-						 uint16_t nb_symb_sch,
-                         uint8_t nr_tti_rx,
-                         uint8_t harq_pid,
-                         uint8_t is_crnti,
+			    short *dlsch_llr,
+			    NR_DL_FRAME_PARMS *frame_parms,
+			    NR_UE_DLSCH_t *dlsch,
+			    NR_DL_UE_HARQ_t *harq_process,
+			    uint32_t frame,
+			    uint16_t nb_symb_sch,
+			    uint8_t nr_tti_rx,
+			    uint8_t harq_pid,
+			    uint8_t is_crnti,
 			    uint8_t llr8_flag);
 
+int nr_extract_dci_info(PHY_VARS_NR_UE *ue,
+			uint8_t eNB_id,
+			lte_frame_type_t frame_type,
+			uint8_t dci_length,
+			uint16_t rnti,
+			uint64_t dci_pdu[2],
+			fapi_nr_dci_pdu_rel15_t *nr_pdci_info_extracted,
+			uint8_t dci_fields_sizes[NBR_NR_DCI_FIELDS][NBR_NR_FORMATS],
+			NR_DCI_format_t dci_format,
+			uint8_t nr_tti_rx,
+			uint16_t n_RB_ULBWP,
+			uint16_t n_RB_DLBWP,
+			uint16_t crc_scrambled_values[TOTAL_NBR_SCRAMBLED_VALUES]);
+
+
 /**@}*/
 #endif
diff --git a/openair1/PHY/NR_UE_TRANSPORT/nr_transport_ue.h b/openair1/PHY/NR_UE_TRANSPORT/nr_transport_ue.h
index 0760c44b53..fc303716e9 100644
--- a/openair1/PHY/NR_UE_TRANSPORT/nr_transport_ue.h
+++ b/openair1/PHY/NR_UE_TRANSPORT/nr_transport_ue.h
@@ -102,6 +102,8 @@ typedef struct {
   uint16_t first_rb;
   /// Current Number of RBs
   uint16_t nb_rb;
+  /// number of layers
+  uint8_t Nl;
   /// Last TPC command
   uint8_t TPC;
   /// Transport block size
@@ -110,20 +112,24 @@ typedef struct {
   uint32_t B;
   /// Length of ACK information (bits)
   uint8_t O_ACK;
-  /// Pointer to the payload
-  uint8_t *b;
-  /// Pointers to transport block segments
-  uint8_t *c[MAX_NUM_ULSCH_SEGMENTS];
   /// Index of current HARQ round for this ULSCH
   uint8_t round;
   /// MCS format of this ULSCH
   uint8_t mcs;
   /// Redundancy-version of the current sub-frame
   uint8_t rvidx;
+  /// pointer to pdu from MAC interface (TS 36.212 V15.4.0, Sec 5.1 p. 8)
+  unsigned char *a;
+  /// Pointer to the payload + CRC 
+  uint8_t *b;
+  /// Pointers to transport block segments
+  uint8_t *c[MAX_NUM_NR_ULSCH_SEGMENTS];
   /// LDPC-code outputs
-  uint8_t d[MAX_NUM_ULSCH_SEGMENTS][3*8448];
-  /// Interleaver outputs
-  uint8_t w[MAX_NUM_ULSCH_SEGMENTS][3*8448];
+  uint8_t *d[MAX_NUM_NR_ULSCH_SEGMENTS];
+  /// LDPC-code outputs (TS 36.212 V15.4.0, Sec 5.3.2 p. 17)
+  uint8_t e[MAX_NUM_NR_CHANNEL_BITS] __attribute__((aligned(32))); 
+  /// Rate matching (Interleaving) outputs (TS 36.212 V15.4.0, Sec 5.4.2.2 p. 30)
+  uint8_t f[MAX_NUM_NR_CHANNEL_BITS] __attribute__((aligned(32))); 
   /// Number of code segments
   uint32_t C;
   /// Number of bits in code segments
@@ -158,6 +164,8 @@ typedef struct {
 typedef struct {
   /// Current Number of Symbols
   uint8_t Nsymb_pusch;
+  /// number of DMRS resource elements
+  uint8_t nb_re_dmrs;
   /// SRS active flag
   uint8_t srs_active; 
 //#if defined(UPGRADE_RAT_NR)
@@ -168,6 +176,7 @@ typedef struct {
   // UL number of harq processes
   uint8_t number_harq_processes_for_pusch;
 #endif 
+  /*
   /// Pointer to CQI data (+1 for 8 bits crc)
   uint8_t o[1+MAX_CQI_BYTES];
   /// Length of CQI data (bits)
@@ -180,22 +189,25 @@ typedef struct {
   uint8_t O_RI;
   /// Pointer to ACK
   uint8_t o_ACK[4];
+  */
   /// Minimum number of CQI bits for PUSCH (36-212 r8.6, Sec 5.2.4.1 p. 37)
   uint8_t O_CQI_MIN;
   /// ACK/NAK Bundling flag
   uint8_t bundling;
-  /// Concatenated "e"-sequences (for definition see 36-212 V8.6 2009-03, p.17-18)
-  uint8_t e[MAX_NUM_CHANNEL_BITS];
+  /// Concatenated "g"-sequences (for definition see 36-212 V15.4.0 2018-12, p.31)
+  uint8_t g[MAX_NUM_NR_CHANNEL_BITS];
   /// Interleaved "h"-sequences (for definition see 36-212 V8.6 2009-03, p.17-18)
-  uint8_t h[MAX_NUM_CHANNEL_BITS];
+  uint8_t h[MAX_NUM_NR_CHANNEL_BITS];
   /// Scrambled "b"-sequences (for definition see 36-211 V8.6 2009-03, p.14)
-  uint8_t b_tilde[MAX_NUM_CHANNEL_BITS];
+  uint8_t b_tilde[MAX_NUM_NR_CHANNEL_BITS];
   /// Modulated "d"-sequences (for definition see 36-211 V8.6 2009-03, p.14)
-  int32_t d[MAX_NUM_RE];
+  int32_t d[MAX_NUM_NR_RE];
   /// Transform-coded "z"-sequences (for definition see 36-211 V8.6 2009-03, p.14-15)
-  int32_t z[MAX_NUM_RE];
+  int32_t z[MAX_NUM_NR_RE];
+  /*
   /// "q" sequences for CQI/PMI (for definition see 36-212 V8.6 2009-03, p.27)
   uint8_t q[MAX_CQI_PAYLOAD];
+  
   /// coded and interleaved CQI bits
   uint8_t o_w[(MAX_CQI_BITS+8)*3];
   /// coded CQI bits
@@ -204,6 +216,7 @@ typedef struct {
   uint8_t q_ACK[MAX_ACK_PAYLOAD];
   /// coded RI bits
   uint8_t q_RI[MAX_RI_PAYLOAD];
+  */
   /// beta_offset_cqi times 8
   uint16_t beta_offset_cqi_times8;
   /// beta_offset_ri times 8
@@ -229,11 +242,11 @@ typedef struct {
   /// num active cba group
   uint8_t num_active_cba_groups;
   /// num dci found for cba
-  uint8_t num_cba_dci[10];
+  //uint8_t num_cba_dci[10];
   /// allocated CBA RNTI
-  uint16_t cba_rnti[4];//NUM_MAX_CBA_GROUP];
+  //uint16_t cba_rnti[4];//NUM_MAX_CBA_GROUP];
   /// UL max-harq-retransmission
-  uint8_t Mlimit;
+  uint16_t Mlimit;
 } NR_UE_ULSCH_t;
 
 typedef struct {
@@ -260,11 +273,11 @@ typedef struct {
   /// Redundancy-version of the current sub-frame
   uint8_t rvidx;
   /// MIMO mode for this DLSCH
-  MIMO_mode_t mimo_mode;
+  MIMO_nrmode_t mimo_mode;
   /// soft bits for each received segment ("w"-sequence)(for definition see 36-212 V8.6 2009-03, p.15)
   int16_t w[MAX_NUM_NR_DLSCH_SEGMENTS][3*8448];
   /// for abstraction soft bits for each received segment ("w"-sequence)(for definition see 36-212 V8.6 2009-03, p.15)
-  double w_abs[MAX_NUM_NR_DLSCH_SEGMENTS][3*8448];
+  //double w_abs[MAX_NUM_NR_DLSCH_SEGMENTS][3*8448];
   /// soft bits for each received segment ("d"-sequence)(for definition see 36-212 V8.6 2009-03, p.15)
   int16_t *d[MAX_NUM_NR_DLSCH_SEGMENTS];
   /// LDPC processing buffers
diff --git a/openair1/PHY/NR_UE_TRANSPORT/nr_ulsch_coding.c b/openair1/PHY/NR_UE_TRANSPORT/nr_ulsch_coding.c
new file mode 100644
index 0000000000..95ca86959f
--- /dev/null
+++ b/openair1/PHY/NR_UE_TRANSPORT/nr_ulsch_coding.c
@@ -0,0 +1,454 @@
+/*
+ * 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
+ */
+
+/*! \file PHY/NR_UE_TRANSPORT/nr_ulsch_coding.c
+* \brief Top-level routines for coding the ULSCH transport channel as described in 38.212 V15.4 2018-12
+* \author Khalid Ahmed
+* \date 2019
+* \version 0.1
+* \company Fraunhofer IIS
+* \email: khalid.ahmed@iis.fraunhofer.de
+* \note
+* \warning
+*/
+
+#include "PHY/defs_UE.h"
+#include "PHY/phy_extern_ue.h"
+#include "PHY/NR_UE_TRANSPORT/nr_transport_proto_ue.h"
+#include "PHY/CODING/coding_defs.h"
+#include "PHY/CODING/coding_extern.h"
+#include "PHY/CODING/lte_interleaver_inline.h"
+#include "PHY/CODING/nrLDPC_encoder/defs.h"
+#include "PHY/NR_UE_TRANSPORT/nr_transport_ue.h"
+#include "common/utils/LOG/vcd_signal_dumper.h"
+#include "PHY/NR_TRANSPORT/nr_dlsch.h"
+
+
+
+void free_nr_ue_ulsch(NR_UE_ULSCH_t *ulsch)
+{
+  int i;
+  int r;
+
+  if (ulsch) {
+#ifdef DEBUG_ULSCH_FREE
+    printf("Freeing ulsch %p\n",ulsch);
+#endif
+
+    for (i=0; i<NR_MAX_ULSCH_HARQ_PROCESSES; i++) {
+      if (ulsch->harq_processes[i]) {
+
+        if (ulsch->harq_processes[i]->a) {
+          free16(ulsch->harq_processes[i]->a,MAX_NR_ULSCH_PAYLOAD_BYTES);
+          ulsch->harq_processes[i]->a = NULL;
+        }
+        if (ulsch->harq_processes[i]->b) {
+          free16(ulsch->harq_processes[i]->b,MAX_NR_ULSCH_PAYLOAD_BYTES);
+          ulsch->harq_processes[i]->b = NULL;
+        }
+        for (r=0; r<MAX_NUM_NR_ULSCH_SEGMENTS; r++) {
+          if (ulsch->harq_processes[i]->c[r]) {
+            free16(ulsch->harq_processes[i]->c[r],((r==0)?8:0) + 3+768);
+            ulsch->harq_processes[i]->c[r] = NULL;
+          }
+
+          if (ulsch->harq_processes[i]->d[r]) {
+            free16(ulsch->harq_processes[i]->d[r],68*384);
+            ulsch->harq_processes[i]->d[r] = NULL;
+          }
+
+        }
+
+        free16(ulsch->harq_processes[i],sizeof(NR_UL_UE_HARQ_t));
+        ulsch->harq_processes[i] = NULL;
+      }
+    }
+    free16(ulsch,sizeof(NR_UE_ULSCH_t));
+    ulsch = NULL;
+  }
+
+}
+
+
+
+NR_UE_ULSCH_t *new_nr_ue_ulsch(unsigned char N_RB_UL, int number_of_harq_pids, uint8_t abstraction_flag)
+{
+
+  NR_UE_ULSCH_t *ulsch;
+  unsigned char exit_flag = 0,i,r;
+  unsigned char bw_scaling =1;
+
+  switch (N_RB_UL) {
+
+  case 106:
+    bw_scaling =2;
+    break;
+
+  default:
+    bw_scaling =1;
+    break;
+  }
+
+  ulsch = (NR_UE_ULSCH_t *)malloc16(sizeof(NR_UE_ULSCH_t));
+
+  if (ulsch) {
+    memset(ulsch,0,sizeof(NR_UE_ULSCH_t));
+
+    ulsch->number_harq_processes_for_pusch = NR_MAX_ULSCH_HARQ_PROCESSES;
+    ulsch->Mlimit = 4; // maximum harq retransmissions
+
+    //for (i=0; i<10; i++)
+      //ulsch->harq_ids[i] = 0;
+
+    for (i=0; i<number_of_harq_pids; i++) {
+
+      ulsch->harq_processes[i] = (NR_UL_UE_HARQ_t *)malloc16(sizeof(NR_UL_UE_HARQ_t));
+
+      //      printf("ulsch->harq_processes[%d] %p\n",i,ulsch->harq_processes[i]);
+      if (ulsch->harq_processes[i]) {
+        memset(ulsch->harq_processes[i], 0, sizeof(NR_UL_UE_HARQ_t));
+        ulsch->harq_processes[i]->b = (uint8_t*)malloc16(MAX_NR_ULSCH_PAYLOAD_BYTES/bw_scaling);
+        ulsch->harq_processes[i]->a = (unsigned char*)malloc16(MAX_NR_ULSCH_PAYLOAD_BYTES/bw_scaling);
+
+        if (ulsch->harq_processes[i]->a) {
+          bzero(ulsch->harq_processes[i]->a,MAX_NR_ULSCH_PAYLOAD_BYTES/bw_scaling);
+        } else {
+          printf("Can't allocate PDU\n");
+          exit_flag=1;
+        }
+
+        if (ulsch->harq_processes[i]->b)
+          bzero(ulsch->harq_processes[i]->b,MAX_NR_ULSCH_PAYLOAD_BYTES/bw_scaling);
+        else {
+          LOG_E(PHY,"Can't get b\n");
+          exit_flag=1;
+        }
+
+        if (abstraction_flag==0) {
+          for (r=0; r<MAX_NUM_NR_ULSCH_SEGMENTS/bw_scaling; r++) {
+            // account for filler in first segment and CRCs for multiple segment case
+            ulsch->harq_processes[i]->c[r] = (uint8_t*)malloc16(8448);
+            ulsch->harq_processes[i]->d[r] = (uint8_t*)malloc16(68*384); //max size for coded output
+
+            if (ulsch->harq_processes[i]->c[r]) {
+              bzero(ulsch->harq_processes[i]->c[r],8448);
+            } else {
+              printf("Can't get c\n");
+              exit_flag=2;
+            }
+            if (ulsch->harq_processes[i]->d[r]) {
+              bzero(ulsch->harq_processes[i]->d[r],(68*384));
+            } else {
+              printf("Can't get d\n");
+              exit_flag=2;
+            }
+          }
+        }
+
+        ulsch->harq_processes[i]->subframe_scheduling_flag = 0;
+        ulsch->harq_processes[i]->first_tx = 1;
+      } else {
+        LOG_E(PHY,"Can't get harq_p %d\n",i);
+        exit_flag=3;
+      }
+    }
+
+    if (exit_flag==0) {
+      for (i=0; i<number_of_harq_pids; i++) {
+        ulsch->harq_processes[i]->round=0;
+      }
+
+      return(ulsch);
+    }
+  }
+
+  LOG_E(PHY,"new_ue_ulsch exit flag, size of  %d ,   %zu\n",exit_flag, sizeof(LTE_UE_ULSCH_t));
+  free_nr_ue_ulsch(ulsch);
+  return(NULL);
+
+
+}
+
+
+
+int nr_ulsch_encoding(NR_UE_ULSCH_t *ulsch,
+                     NR_DL_FRAME_PARMS* frame_parms,
+                     uint8_t harq_pid)
+{
+
+/////////////////////////parameters and variables declaration/////////////////////////
+///////////
+
+  unsigned int G,crc;
+  NR_UL_UE_HARQ_t *harq_process; 
+  uint16_t nb_rb ;
+  uint8_t nb_symb_sch ;
+  uint32_t A, Z, F;
+  uint32_t *pz; 
+  uint8_t mod_order; 
+  uint16_t Kr,r,r_offset;
+  //uint8_t *d_tmp[MAX_NUM_DLSCH_SEGMENTS];
+  uint8_t BG;
+  uint32_t E;
+  uint8_t Ilbrm; 
+  uint32_t Tbslbrm; 
+  uint8_t nb_re_dmrs; 
+  uint16_t length_dmrs;
+  float Coderate;
+
+///////////
+///////////////////////////////////////////////////////////////////////////////////////
+
+
+/////////////////////////parameters and variables initialization/////////////////////////
+///////////
+
+  crc = 1;
+  harq_process = ulsch->harq_processes[harq_pid];
+  nb_rb = harq_process->nb_rb;
+  nb_symb_sch = harq_process->nb_symbols;
+  A = harq_process->TBS;
+  pz = &Z;
+  mod_order = nr_get_Qm(harq_process->mcs,1);
+  Kr=0;
+  r_offset=0;
+  BG = 1;
+  F=0;
+  Ilbrm = 0;
+  Tbslbrm = 950984; //max tbs
+  nb_re_dmrs = ulsch->nb_re_dmrs;
+  length_dmrs = 1;
+  Coderate = 0.0;
+
+///////////
+/////////////////////////////////////////////////////////////////////////////////////////  
+
+  /*
+  uint8_t *channel_input[MAX_NUM_DLSCH_SEGMENTS]; //unsigned char
+  for(j=0;j<MAX_NUM_DLSCH_SEGMENTS;j++) {
+    channel_input[j] = (unsigned char *)malloc16(sizeof(unsigned char) * 68*384);
+  }
+  */
+  
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_DLSCH_ENCODING, VCD_FUNCTION_IN);
+
+  printf("ulsch coding nb_rb %d nb_symb_sch %d nb_re_dmrs %d, length_dmrs %d\n", nb_rb,nb_symb_sch, nb_re_dmrs,length_dmrs);
+
+
+  G = nr_get_G(nb_rb, nb_symb_sch, nb_re_dmrs, length_dmrs,mod_order,harq_process->Nl);
+  LOG_D(PHY,"ulsch coding A %d G %d mod_order %d\n", A,G, mod_order);
+  printf("ulsch coding A %d G %d mod_order %d\n", A,G, mod_order);
+
+  Tbslbrm = nr_compute_tbs(28,nb_rb,frame_parms->symbols_per_slot,0,0, harq_process->Nl);
+
+  //  if (harq_process->Ndi == 1) {  // this is a new packet
+  if (harq_process->round == 0) {  // this is a new packet
+#ifdef DEBUG_DLSCH_CODING
+  printf("encoding thinks this is a new packet \n");
+#endif
+
+///////////////////////// a---->| add CRC |---->b /////////////////////////
+///////////
+    /*
+    int i;
+    printf("ulsch (tx): \n");
+    for (i=0;i<(A>>3);i++)
+      printf("%02x.",a[i]);
+    printf("\n");
+    */
+    // Add 24-bit crc (polynomial A) to payload
+    crc = crc24a(harq_process->a,A)>>8;
+    harq_process->a[A>>3] = ((uint8_t*)&crc)[2];
+    harq_process->a[1+(A>>3)] = ((uint8_t*)&crc)[1];
+    harq_process->a[2+(A>>3)] = ((uint8_t*)&crc)[0];
+    //printf("CRC %x (A %d)\n",crc,A);
+    //printf("a0 %d a1 %d a2 %d\n", a[A>>3], a[1+(A>>3)], a[2+(A>>3)]);
+
+    harq_process->B = A+24;
+
+    memcpy(harq_process->b,harq_process->a,(A/8)+4);
+
+///////////
+///////////////////////////////////////////////////////////////////////////
+
+///////////////////////// b---->| block segmentation |---->c /////////////////////////
+///////////
+
+    nr_segmentation(harq_process->b,
+        harq_process->c,
+        harq_process->B,
+        &harq_process->C,
+        &harq_process->K,
+        pz,
+        &harq_process->F);
+
+    F = harq_process->F;
+    Coderate = (float) A /(float) G;
+
+    if ((A <=292) || ((A<=3824) && (Coderate <= 0.6667)) || Coderate <= 0.25){
+      BG = 2;
+    }
+    else{
+      BG = 1;
+    }
+
+    Kr = harq_process->K;
+#ifdef DEBUG_DLSCH_CODING
+    uint16_t Kr_bytes;
+    Kr_bytes = Kr>>3;
+#endif
+
+///////////
+/////////////////////////////////////////////////////////////////////////////////////
+
+
+///////////////////////// c---->| LDCP coding |---->d /////////////////////////
+///////////
+
+    //printf("segment Z %d k %d Kr %d BG %d\n", *pz,harq_process->K,Kr,BG);
+
+    //start_meas(te_stats);
+    for (r=0; r<harq_process->C; r++) {
+      //d_tmp[r] = &harq_process->d[r][0];
+      //channel_input[r] = &harq_process->d[r][0];
+#ifdef DEBUG_DLSCH_CODING
+      printf("Encoder: B %d F %d \n",harq_process->B, harq_process->F);
+      printf("start ldpc encoder segment %d/%d\n",r,harq_process->C);
+      printf("input %d %d %d %d %d \n", harq_process->c[r][0], harq_process->c[r][1], harq_process->c[r][2],harq_process->c[r][3], harq_process->c[r][4]);
+      for (int cnt =0 ; cnt < 22*(*pz)/8; cnt ++){
+      printf("%d ", harq_process->c[r][cnt]);
+      }
+      printf("\n");
+
+#endif
+      //ldpc_encoder_orig((unsigned char*)harq_process->c[r],harq_process->d[r],Kr,BG,0);
+      //ldpc_encoder_optim((unsigned char*)harq_process->c[r],(unsigned char*)&harq_process->d[r][0],Kr,BG,NULL,NULL,NULL,NULL);
+    }
+
+    //for (int i=0;i<68*384;i++)
+      //        printf("channel_input[%d]=%d\n",i,channel_input[i]);
+
+
+
+    /*printf("output %d %d %d %d %d \n", harq_process->d[0][0], harq_process->d[0][1], harq_process->d[r][2],harq_process->d[0][3], harq_process->d[0][4]);
+      for (int cnt =0 ; cnt < 66*(*pz); cnt ++){
+      printf("%d \n",  harq_process->d[0][cnt]);
+      }
+      printf("\n");*/
+
+    //ldpc_encoder_optim_8seg(harq_process->c,d_tmp,Kr,BG,harq_process->C,NULL,NULL,NULL,NULL);
+    ldpc_encoder_optim_8seg(harq_process->c,harq_process->d,Kr,BG,harq_process->C,NULL,NULL,NULL,NULL);
+
+    //stop_meas(te_stats);
+    //printf("end ldpc encoder -- output\n");
+#ifdef DEBUG_DLSCH_CODING
+      write_output("ulsch_enc_input0.m","enc_in0",&harq_process->c[0][0],Kr_bytes,1,4);
+      write_output("ulsch_enc_output0.m","enc0",&harq_process->d[0][0],(3*8*Kr_bytes)+12,1,4);
+#endif
+
+///////////
+///////////////////////////////////////////////////////////////////////////////
+
+  }
+
+  for (r=0; r<harq_process->C; r++) { // looping over C segments
+
+    if (harq_process->F>0) {
+            for (int k=(Kr-F-2*(*pz)); k<Kr-2*(*pz); k++) {
+              harq_process->d[r][k] = NR_NULL;
+              //if (k<(Kr-F+8))
+              //printf("r %d filler bits [%d] = %d \n", r,k, harq_process->d[r][k]);
+            }
+    }
+
+#ifdef DEBUG_DLSCH_CODING
+    printf("Rate Matching, Code segment %d (coded bits (G) %d,unpunctured/repeated bits per code segment %d,mod_order %d, nb_rb %d)...\n",
+        r,
+        G,
+        Kr*3,
+        mod_order,nb_rb);
+#endif
+
+    //start_meas(rm_stats);
+#ifdef DEBUG_DLSCH_CODING
+  printf("rvidx in encoding = %d\n", harq_process->rvidx);
+#endif
+
+///////////////////////// d---->| Rate matching bit selection |---->e /////////////////////////
+///////////
+
+    E = nr_get_E(G, harq_process->C, mod_order, harq_process->Nl, r);
+
+    nr_rate_matching_ldpc(Ilbrm,
+                          Tbslbrm,
+                          BG,
+                          *pz,
+                          harq_process->d[r],
+                          harq_process->e+r_offset,
+                          harq_process->C,
+                          harq_process->rvidx,
+                          E);
+
+
+
+#ifdef DEBUG_DLSCH_CODING
+    for (int i =0; i<16; i++)
+      printf("output ratematching e[%d]= %d r_offset %d\n", i,harq_process->e[i+r_offset], r_offset);
+#endif
+
+///////////
+///////////////////////////////////////////////////////////////////////////////////////////////
+
+    
+///////////////////////// e---->| Rate matching bit interleaving |---->f /////////////////////////
+///////////
+
+    //stop_meas(rm_stats);
+
+    //start_meas(i_stats);
+  nr_interleaving_ldpc(E,
+            mod_order,
+            harq_process->e+r_offset,
+            harq_process->f+r_offset);
+    //stop_meas(i_stats);
+
+
+#ifdef DEBUG_DLSCH_CODING
+    for (int i =0; i<16; i++)
+      printf("output interleaving f[%d]= %d r_offset %d\n", i,harq_process->f[i+r_offset], r_offset);
+
+    if (r==harq_process->C-1)
+      write_output("enc_output.m","enc",harq_process->f,G,1,4);
+#endif
+
+    r_offset += E;
+
+///////////
+///////////////////////////////////////////////////////////////////////////////////////////////
+
+  }
+
+  memcpy(ulsch->g,harq_process->f,G>>3); // g is the concatenated code block
+
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_DLSCH_ENCODING, VCD_FUNCTION_OUT);
+
+  return(0);
+}
diff --git a/openair1/PHY/NR_UE_TRANSPORT/pss_nr.c b/openair1/PHY/NR_UE_TRANSPORT/pss_nr.c
index 9b09a846bb..40945bebef 100644
--- a/openair1/PHY/NR_UE_TRANSPORT/pss_nr.c
+++ b/openair1/PHY/NR_UE_TRANSPORT/pss_nr.c
@@ -898,7 +898,8 @@ int pss_search_time_nr(int **rxdata, ///rx data in time domain
   }
 
   if (fo_flag){
-	  // fractional frequency offser computation according to Cross-correlation Synchronization Algorithm Using PSS
+
+	  // fractional frequency offset computation according to Cross-correlation Synchronization Algorithm Using PSS
 	  // Shoujun Huang, Yongtao Su, Ying He and Shan Tang, "Joint time and frequency offset estimation in LTE downlink," 7th International Conference on Communications and Networking in China, 2012.
 
 	  int64_t result1,result2;
@@ -922,7 +923,7 @@ int pss_search_time_nr(int **rxdata, ///rx data in time domain
 
  	  // estimation of fractional frequency offset: angle[(result1)'*(result2)]/pi
 	  ffo_est=atan2(re1*im2-re2*im1,re1*re2+im1*im2)/M_PI;
-  
+
 #ifdef DBG_PSS_NR
 	  printf("ffo %lf\n",ffo_est);
 #endif
diff --git a/openair1/PHY/NR_UE_TRANSPORT/pucch_nr.c b/openair1/PHY/NR_UE_TRANSPORT/pucch_nr.c
index f876c8f6c2..accf663e9d 100644
--- a/openair1/PHY/NR_UE_TRANSPORT/pucch_nr.c
+++ b/openair1/PHY/NR_UE_TRANSPORT/pucch_nr.c
@@ -990,7 +990,7 @@ void nr_uci_encoding(uint64_t payload,
   // A is the payload size, to be provided in function call
   uint8_t A = nr_bit;
   // L is the CRC size
-  uint8_t L;
+  //uint8_t L;
   // E is the rate matching output sequence length as given in TS 38.212 subclause 6.3.1.4.1
   uint16_t E=0,E_init;
 
@@ -1047,7 +1047,7 @@ void nr_uci_encoding(uint64_t payload,
   }
 
   *M_bit = E;
-  int I_seg;
+  //int I_seg;
 #ifdef DEBUG_NR_PUCCH_TX
   printf("\t\t [nr_uci_encoding] start function with fmt=%d, encoding A=%d bits into M_bit=%d (where nrofSymbols=%d,nrofPRB=%d)\n",fmt,A,*M_bit,nrofSymbols,nrofPRB);
 #endif
@@ -1057,19 +1057,19 @@ void nr_uci_encoding(uint64_t payload,
     // CRC bits are not attached, and coding small block lengths (subclause 5.3.3)
   } else if (A>=12) {
     // procedure in subclause 6.3.1.2.1 (UCI encoded by Polar code -> subclause 6.3.1.3.1)
-    if ((A>=360 && E>=1088)||(A>=1013)) {
+    /*if ((A>=360 && E>=1088)||(A>=1013)) {
       I_seg = 1;
     } else {
       I_seg = 0;
-    }
+    }*/
 
-    if (A>=20) {
+    /*if (A>=20) {
       // parity bits (subclause 5.2.1) computed by setting L=11 and using generator polynomial gCRC11(D) (subclause 5.1)
       L=11;
     } else if (A<=19) {
       // parity bits (subclause 5.2.1) computed by setting L=6  and using generator polynomial gCRC6(D)  (subclause 5.1)
       L=6;
-    }
+    }*/
 
     // code block segmentation and CRC attachment is performed according to subclause 5.2.1
     // polar coding subclause 5.3.1
diff --git a/openair1/PHY/NR_UE_TRANSPORT/sss_nr.c b/openair1/PHY/NR_UE_TRANSPORT/sss_nr.c
index 26639a5134..3d36822956 100644
--- a/openair1/PHY/NR_UE_TRANSPORT/sss_nr.c
+++ b/openair1/PHY/NR_UE_TRANSPORT/sss_nr.c
@@ -430,39 +430,6 @@ int rx_sss_nr(PHY_VARS_NR_UE *ue, int32_t *tot_metric,uint8_t *phase_max)
   int32_t metric, metric_re;
   int16_t *d;
 
-  /* slop_fep function works for lte and takes into account begining of frame with prefix for subframe 0 */
-  /* for NR this is not the case but slot_fep is still used for computing FFT of samples */
-  /* in order to achieve correct processing for NR prefix samples is forced to 0 and then restored after function call */
-  /* symbol number are from beginning of SS/PBCH blocks as below:  */
-  /*    Signal            PSS  PBCH  SSS  PBCH                     */
-  /*    symbol number      0     1    2    3                       */
-  /* time samples in buffer rxdata are used as input of FFT -> FFT results are stored in the frequency buffer rxdataF */
-  /* rxdataF stores SS/PBCH from beginning of buffers in the same symbol order as in time domain */
-
-  int nb_prefix_samples0 = frame_parms->nb_prefix_samples0;
-  // For now, symbol 0 = PSS/PBCH and it is never in symbol 0 or 7*2^mu (i.e. always shorter prefix)
-  frame_parms->nb_prefix_samples0 = frame_parms->nb_prefix_samples;
-
-  // Do FFTs for SSS/PSS
-  // SSS
-  nr_slot_fep(ue,
-	      SSS_SYMBOL_NB-PSS_SYMBOL_NB,      // symbol number w.r.t. PSS
-	      0,                  // Ns slot number
-	      ue->ssb_offset,      // sample_offset of int16_t
-	      0,                  // no_prefix
-	      1,                  // reset frequency estimation
-	      NR_SSS_EST);
-
-  // PSS
-  nr_slot_fep(ue,
-	      0,
-	      0,
-	      ue->ssb_offset,
-	      0,
-	      1,
-	      NR_SSS_EST);
-
-  frame_parms->nb_prefix_samples0 = nb_prefix_samples0;
 
   // pss sss extraction
   pss_sss_extract_nr(ue,
diff --git a/openair1/PHY/TOOLS/cdot_prod.c b/openair1/PHY/TOOLS/cdot_prod.c
index 843a9605f1..d3e73ec28a 100644
--- a/openair1/PHY/TOOLS/cdot_prod.c
+++ b/openair1/PHY/TOOLS/cdot_prod.c
@@ -158,122 +158,6 @@ int32_t dot_product(int16_t *x,
 #endif
 }
 
-int64_t dot_product64(int16_t *x,
-		      int16_t *y,
-		      uint32_t N, //must be a multiple of 8
-		      uint8_t output_shift)
-{
-
-  uint32_t n;
-
-#if defined(__x86_64__) || defined(__i386__)
-  __m128i *x128,*y128,mmtmp1,mmtmp2,mmtmp3,mmcumul,mmcumul_re,mmcumul_im;
-  __m128i minus_i = _mm_set_epi16(-1,1,-1,1,-1,1,-1,1);
-  int64_t result;
-
-  x128 = (__m128i*) x;
-  y128 = (__m128i*) y;
-
-  mmcumul_re = _mm_setzero_si128();
-  mmcumul_im = _mm_setzero_si128();
-
-  for (n=0; n<(N>>2); n++) {
-
-//    printf("n=%d, x128=%p, y128=%p\n",n,x128,y128);
-       // print_shorts("x",&x128[0]);
-       // print_shorts("y",&y128[0]);
-
-    // this computes Re(z) = Re(x)*Re(y) + Im(x)*Im(y)
-    mmtmp1 = _mm_madd_epi16(x128[0],y128[0]);
-      //  print_ints("retmp",&mmtmp1);
-    // mmtmp1 contains real part of 4 consecutive outputs (32-bit)
-    // shift and accumulate results
-    mmtmp1 = _mm_srai_epi32(mmtmp1,output_shift);
-    mmcumul_re = _mm_add_epi32(mmcumul_re,mmtmp1);
-        //print_ints("re",&mmcumul_re);
-
-
-    // this computes Im(z) = Re(x)*Im(y) - Re(y)*Im(x)
-    mmtmp2 = _mm_shufflelo_epi16(y128[0],_MM_SHUFFLE(2,3,0,1));
-        //print_shorts("y",&mmtmp2);
-    mmtmp2 = _mm_shufflehi_epi16(mmtmp2,_MM_SHUFFLE(2,3,0,1));
-        //print_shorts("y",&mmtmp2);
-    mmtmp2 = _mm_sign_epi16(mmtmp2,minus_i);
-          //  print_shorts("y",&mmtmp2);
-
-    mmtmp3 = _mm_madd_epi16(x128[0],mmtmp2);
-            //print_ints("imtmp",&mmtmp3);
-    // mmtmp3 contains imag part of 4 consecutive outputs (32-bit)
-    // shift and accumulate results
-    mmtmp3 = _mm_srai_epi32(mmtmp3,output_shift);
-    mmcumul_im = _mm_add_epi32(mmcumul_im,mmtmp3);
-        //print_ints("im",&mmcumul_im);
-
-    x128++;
-    y128++;
-  }
-
-  // this gives Re Re Im Im
-  mmcumul = _mm_hadd_epi32(mmcumul_re,mmcumul_im);
-    //print_ints("cumul1",&mmcumul);
-  // this gives Re Im Re Im
-  mmcumul = _mm_hadd_epi32(mmcumul,mmcumul);
-    //print_ints("cumul2",&mmcumul);
-
-  //mmcumul = _mm_srai_epi32(mmcumul,output_shift);
-  // extract the lower half
-  result = _mm_extract_epi64(mmcumul,0);
-  //printf("result: (%d,%d)\n",((int32_t*)&result)[0],((int32_t*)&result)[1]); 
-  _mm_empty();
-  _m_empty();
- 
-  return(result);
-
-#elif defined(__arm__)
-  int16x4_t *x_128=(int16x4_t*)x;
-  int16x4_t *y_128=(int16x4_t*)y;
-  int32x4_t tmp_re,tmp_im;
-  int32x4_t tmp_re1,tmp_im1;
-  int32x4_t re_cumul,im_cumul;
-  int32x2_t re_cumul2,im_cumul2;
-  int32x4_t shift = vdupq_n_s32(-output_shift); 
-  int32x2x2_t result2;
-  int16_t conjug[4]__attribute__((aligned(16))) = {-1,1,-1,1} ;
-
-  re_cumul = vdupq_n_s32(0);
-  im_cumul = vdupq_n_s32(0); 
-
-  for (n=0; n<(N>>2); n++) {
-
-    tmp_re  = vmull_s16(*x_128++, *y_128++);
-    //tmp_re = [Re(x[0])Re(y[0]) Im(x[0])Im(y[0]) Re(x[1])Re(y[1]) Im(x[1])Im(y[1])] 
-    tmp_re1 = vmull_s16(*x_128++, *y_128++);
-    //tmp_re1 = [Re(x1[1])Re(x2[1]) Im(x1[1])Im(x2[1]) Re(x1[1])Re(x2[2]) Im(x1[1])Im(x2[2])] 
-    tmp_re  = vcombine_s32(vpadd_s32(vget_low_s32(tmp_re),vget_high_s32(tmp_re)),
-                           vpadd_s32(vget_low_s32(tmp_re1),vget_high_s32(tmp_re1)));
-    //tmp_re = [Re(ch[0])Re(rx[0])+Im(ch[0])Im(ch[0]) Re(ch[1])Re(rx[1])+Im(ch[1])Im(ch[1]) Re(ch[2])Re(rx[2])+Im(ch[2]) Im(ch[2]) Re(ch[3])Re(rx[3])+Im(ch[3])Im(ch[3])] 
-
-    tmp_im  = vmull_s16(vrev32_s16(vmul_s16(*x_128++,*(int16x4_t*)conjug)),*y_128++);
-    //tmp_im = [-Im(ch[0])Re(rx[0]) Re(ch[0])Im(rx[0]) -Im(ch[1])Re(rx[1]) Re(ch[1])Im(rx[1])]
-    tmp_im1 = vmull_s16(vrev32_s16(vmul_s16(*x_128++,*(int16x4_t*)conjug)),*y_128++);
-    //tmp_im1 = [-Im(ch[2])Re(rx[2]) Re(ch[2])Im(rx[2]) -Im(ch[3])Re(rx[3]) Re(ch[3])Im(rx[3])]
-    tmp_im  = vcombine_s32(vpadd_s32(vget_low_s32(tmp_im),vget_high_s32(tmp_im)),
-                           vpadd_s32(vget_low_s32(tmp_im1),vget_high_s32(tmp_im1)));
-    //tmp_im = [-Im(ch[0])Re(rx[0])+Re(ch[0])Im(rx[0]) -Im(ch[1])Re(rx[1])+Re(ch[1])Im(rx[1]) -Im(ch[2])Re(rx[2])+Re(ch[2])Im(rx[2]) -Im(ch[3])Re(rx[3])+Re(ch[3])Im(rx[3])]
-
-    re_cumul = vqaddq_s32(re_cumul,vqshlq_s32(tmp_re,shift));
-    im_cumul = vqaddq_s32(im_cumul,vqshlq_s32(tmp_im,shift));
-  }
-  
-  re_cumul2 = vpadd_s32(vget_low_s32(re_cumul),vget_high_s32(re_cumul));
-  im_cumul2 = vpadd_s32(vget_low_s32(im_cumul),vget_high_s32(im_cumul));
-  re_cumul2 = vpadd_s32(re_cumul2,re_cumul2);
-  im_cumul2 = vpadd_s32(im_cumul2,im_cumul2);
-  result2   = vzip_s32(re_cumul2,im_cumul2);
-  return(vget_lane_s32(result2.val[0],0));
-#endif
-}
-
 
 
 #ifdef MAIN
diff --git a/openair1/PHY/TOOLS/nr_phy_scope.c b/openair1/PHY/TOOLS/nr_phy_scope.c
index 3dd16ff0da..f8c0aad3f2 100644
--- a/openair1/PHY/TOOLS/nr_phy_scope.c
+++ b/openair1/PHY/TOOLS/nr_phy_scope.c
@@ -35,8 +35,6 @@ float tput_time_ue[NUMBER_OF_UE_MAX][TPUT_WINDOW_LENGTH] = {{0}};
 float tput_ue[NUMBER_OF_UE_MAX][TPUT_WINDOW_LENGTH] = {{0}};
 float tput_ue_max[NUMBER_OF_UE_MAX] = {0};
 
-extern int64_t *pss_corr_ue[3];
-
 
 static void ia_receiver_on_off( FL_OBJECT *button, long arg)
 {
@@ -66,14 +64,14 @@ static void dl_traffic_on_off( FL_OBJECT *button, long arg)
   }
 }
 
-FD_lte_phy_scope_enb *create_lte_phy_scope_enb( void )
+FD_phy_scope_gnb *create_phy_scope_gnb( void )
 {
 
   FL_OBJECT *obj;
-  FD_lte_phy_scope_enb *fdui = fl_malloc( sizeof *fdui );
+  FD_phy_scope_gnb *fdui = fl_malloc( sizeof *fdui );
 
   // Define form
-  fdui->lte_phy_scope_enb = fl_bgn_form( FL_NO_BOX, 800, 800 );
+  fdui->phy_scope_gnb = fl_bgn_form( FL_NO_BOX, 800, 800 );
 
   // This the whole UI box
   obj = fl_add_box( FL_BORDER_BOX, 0, 0, 800, 800, "" );
@@ -146,19 +144,17 @@ FD_lte_phy_scope_enb *create_lte_phy_scope_enb( void )
   fl_set_object_callback(fdui->button_0, dl_traffic_on_off, 0 );
 
   fl_end_form( );
-  fdui->lte_phy_scope_enb->fdui = fdui;
+  fdui->phy_scope_gnb->fdui = fdui;
 
   return fdui;
 }
 
-/*
-void phy_scope_eNB(FD_lte_phy_scope_enb *form,
-                   PHY_VARS_eNB *phy_vars_enb,
+void phy_scope_gNB(FD_phy_scope_gnb *form,
+                   PHY_VARS_gNB *phy_vars_gnb,
                    int UE_id)
 {
-  int eNB_id = 0;
   int i,i2,arx,atx,ind,k;
-  LTE_DL_FRAME_PARMS *frame_parms = &phy_vars_enb->frame_parms;
+  NR_DL_FRAME_PARMS *frame_parms = &phy_vars_gnb->frame_parms;
   int nsymb_ce = 12*frame_parms->N_RB_UL*frame_parms->symbols_per_tti;
   uint8_t nb_antennas_rx = frame_parms->nb_antennas_rx;
   uint8_t nb_antennas_tx = 1; // frame_parms->nb_antennas_tx; // in LTE Rel. 8 and 9 only a single transmit antenna is assumed at the UE
@@ -180,16 +176,18 @@ void phy_scope_eNB(FD_lte_phy_scope_enb *form,
   float time[FRAME_LENGTH_COMPLEX_SAMPLES];
   float time2[2048];
   float freq[nsymb_ce*nb_antennas_rx*nb_antennas_tx];
-  int frame = phy_vars_enb->proc.proc_rxtx[0].frame_tx;
-  uint32_t total_dlsch_bitrate = phy_vars_enb->total_dlsch_bitrate;
+  uint32_t total_dlsch_bitrate = phy_vars_gnb->total_dlsch_bitrate;
   int coded_bits_per_codeword = 0;
   uint8_t harq_pid; // in TDD config 3 it is sf-2, i.e., can be 0,1,2
   int Qm = 2;
 
+  if (!RC.nrmac[0]->UE_list.active[UE_id])
+    return;
+  
   // choose max MCS to compute coded_bits_per_codeword
-  if (phy_vars_enb->ulsch[UE_id]!=NULL) {
+  if (phy_vars_gnb->ulsch[UE_id][0]!=NULL) {
     for (harq_pid=0; harq_pid<3; harq_pid++) {
-      Qm = cmax(phy_vars_enb->ulsch[UE_id]->harq_processes[harq_pid]->Qm,Qm);
+      //Qm = cmax(phy_vars_gnb->ulsch[UE_id][0]->harq_processes->Qm,Qm);
     }
   }
 
@@ -199,15 +197,15 @@ void phy_scope_eNB(FD_lte_phy_scope_enb *form,
   llr = (float*) calloc(coded_bits_per_codeword,sizeof(float)); // init to zero
   bit = malloc(coded_bits_per_codeword*sizeof(float));
 
-  rxsig_t = (int16_t**) phy_vars_enb->common_vars.rxdata[eNB_id];
-  //chest_t = (int16_t**) phy_vars_enb->pusch_vars[UE_id]->drs_ch_estimates_time[eNB_id];
-  chest_t = (int16_t**) phy_vars_enb->srs_vars[UE_id].srs_ch_estimates[eNB_id];
-  chest_f = (int16_t**) phy_vars_enb->pusch_vars[UE_id]->drs_ch_estimates[eNB_id];
-  pusch_llr = (int16_t*) phy_vars_enb->pusch_vars[UE_id]->llr;
-  pusch_comp = (int32_t*) phy_vars_enb->pusch_vars[UE_id]->rxdataF_comp[0];
-  pucch1_comp = (int32_t*) phy_vars_enb->pucch1_stats[UE_id];
-  pucch1_thres = (int32_t*) phy_vars_enb->pucch1_stats_thres[UE_id];
-  pucch1ab_comp = (int32_t*) phy_vars_enb->pucch1ab_stats[UE_id];
+  rxsig_t = (int16_t**) phy_vars_gnb->common_vars.rxdata;
+  //chest_t = (int16_t**) phy_vars_gnb->pusch_vars[UE_id]->drs_ch_estimates_time[eNB_id];
+  chest_t = (int16_t**) phy_vars_gnb->srs_vars[UE_id].srs_ch_estimates;
+  chest_f = (int16_t**) phy_vars_gnb->pusch_vars[UE_id]->drs_ch_estimates;
+  pusch_llr = (int16_t*) phy_vars_gnb->pusch_vars[UE_id]->llr;
+  pusch_comp = (int32_t*) phy_vars_gnb->pusch_vars[UE_id]->rxdataF_comp;
+  pucch1_comp = (int32_t*) phy_vars_gnb->pucch1_stats[UE_id];
+  pucch1_thres = (int32_t*) phy_vars_gnb->pucch1_stats_thres[UE_id];
+  pucch1ab_comp = (int32_t*) phy_vars_gnb->pucch1ab_stats[UE_id];
 
   // Received signal in time domain of receive antenna 0
   if (rxsig_t != NULL) {
@@ -363,7 +361,7 @@ void phy_scope_eNB(FD_lte_phy_scope_enb *form,
   memmove( tput_time_enb[UE_id], &tput_time_enb[UE_id][1], (TPUT_WINDOW_LENGTH-1)*sizeof(float) );
   memmove( tput_enb[UE_id], &tput_enb[UE_id][1], (TPUT_WINDOW_LENGTH-1)*sizeof(float) );
 
-  tput_time_enb[UE_id][TPUT_WINDOW_LENGTH-1]  = (float) frame;
+  tput_time_enb[UE_id][TPUT_WINDOW_LENGTH-1]  = (float) 0;
   tput_enb[UE_id][TPUT_WINDOW_LENGTH-1] = ((float) total_dlsch_bitrate)/1000.0;
 
   fl_set_xyplot_data(form->pusch_tput,tput_time_enb[UE_id],tput_enb[UE_id],TPUT_WINDOW_LENGTH,"","","");
@@ -377,16 +375,15 @@ void phy_scope_eNB(FD_lte_phy_scope_enb *form,
   free(bit);
   free(chest_f_abs);
 }
-*/
 
-FD_lte_phy_scope_ue *create_lte_phy_scope_ue( void )
+FD_phy_scope_nrue *create_phy_scope_nrue( void )
 {
 
   FL_OBJECT *obj;
-  FD_lte_phy_scope_ue *fdui = fl_malloc( sizeof *fdui );
+  FD_phy_scope_nrue *fdui = fl_malloc( sizeof *fdui );
 
   // Define form
-  fdui->lte_phy_scope_ue = fl_bgn_form( FL_NO_BOX, 800, 900 );
+  fdui->phy_scope_nrue = fl_bgn_form( FL_NO_BOX, 800, 900 );
 
   // This the whole UI box
   obj = fl_add_box( FL_BORDER_BOX, 0, 0, 800, 900, "" );
@@ -477,12 +474,12 @@ FD_lte_phy_scope_ue *create_lte_phy_scope_ue( void )
   fl_hide_object(fdui->button_0);
 
   fl_end_form( );
-  fdui->lte_phy_scope_ue->fdui = fdui;
+  fdui->phy_scope_nrue->fdui = fdui;
 
   return fdui;
 }
 
-void phy_scope_UE(FD_lte_phy_scope_ue *form,
+void phy_scope_nrUE(FD_phy_scope_nrue *form,
                   PHY_VARS_NR_UE *phy_vars_ue,
                   int eNB_id,
                   int UE_id,
@@ -590,8 +587,8 @@ void phy_scope_UE(FD_lte_phy_scope_ue *form,
   time = calloc(samples_per_frame,sizeof(float));
   corr = calloc(samples_per_frame,sizeof(float));
 
-  chest_t = (int16_t**) phy_vars_ue->common_vars.common_vars_rx_data_per_thread[phy_vars_ue->current_thread_id[subframe]].dl_ch_estimates_time[eNB_id];
-  chest_f = (int16_t**) phy_vars_ue->common_vars.common_vars_rx_data_per_thread[phy_vars_ue->current_thread_id[subframe]].dl_ch_estimates[eNB_id];
+  chest_t = (int16_t**) phy_vars_ue->pdcch_vars[phy_vars_ue->current_thread_id[subframe]][eNB_id]->dl_ch_estimates_time;
+  chest_f = (int16_t**) phy_vars_ue->pdcch_vars[phy_vars_ue->current_thread_id[subframe]][eNB_id]->dl_ch_estimates;
 
   pbch_llr = (int16_t*) phy_vars_ue->pbch_vars[eNB_id]->llr;
   pbch_comp = (int16_t*) phy_vars_ue->pbch_vars[eNB_id]->rxdataF_comp[0];
@@ -629,6 +626,7 @@ void phy_scope_UE(FD_lte_phy_scope_ue *form,
 
   if (phy_vars_ue->is_synchronized==0) {
     for (ind=0;ind<3;ind++) {
+      /*
       if (pss_corr_ue[ind]) {
 	for (i=0; i<samples_per_frame; i++) {
 	  corr[i] = (float) pss_corr_ue[ind][i];
@@ -642,6 +640,7 @@ void phy_scope_UE(FD_lte_phy_scope_ue *form,
 
 	overlay = 1;
       }
+      */
     }
   } 
   else {
@@ -843,3 +842,91 @@ void phy_scope_UE(FD_lte_phy_scope_ue *form,
   free(chest_t_abs);
   */
 }
+
+typedef struct {
+  FL_FORM    *stats_form;
+  void       *vdata;
+  char       *cdata;
+  long        ldata;
+  FL_OBJECT *stats_text;
+  FL_OBJECT *stats_button;
+} FD_stats_form;
+
+void reset_stats_gNB(FL_OBJECT *button, long arg) {
+  PHY_VARS_gNB *phy_vars_gNB = RC.gNB[0][0];
+
+  for (int i=0; i<NUMBER_OF_UE_MAX; i++) {
+    for (int k=0; k<8; k++) { //harq_processes
+      /*      for (j=0; j<phy_vars_gNB->dlsch[i][0]->Mlimit; j++) {
+        phy_vars_gNB->UE_stats[i].dlsch_NAK[k][j]=0;
+        phy_vars_gNB->UE_stats[i].dlsch_ACK[k][j]=0;
+        phy_vars_gNB->UE_stats[i].dlsch_trials[k][j]=0;
+            }*/
+      phy_vars_gNB->UE_stats[i].dlsch_l2_errors[k]=0;
+      phy_vars_gNB->UE_stats[i].ulsch_errors[k]=0;
+      phy_vars_gNB->UE_stats[i].ulsch_consecutive_errors=0;
+      phy_vars_gNB->UE_stats[i].dlsch_sliding_cnt=0;
+      phy_vars_gNB->UE_stats[i].dlsch_NAK_round0=0;
+      phy_vars_gNB->UE_stats[i].dlsch_mcs_offset=0;
+    }
+  }
+}
+
+static FD_phy_scope_gnb *form_gnb[MAX_NUM_CCs][NUMBER_OF_UE_MAX];
+static void *scope_thread(void *arg) {
+  int ue_cnt=0;
+  while (!oai_exit) {
+    ue_cnt=0;
+    
+    for(int UE_id=0; UE_id<NUMBER_OF_UE_MAX; UE_id++) {
+      for(int CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
+        if ((ue_cnt<scope_enb_num_ue)) 
+          //this function needs to be written
+          phy_scope_gNB(form_gnb[CC_id][ue_cnt], RC.gNB[0][CC_id], UE_id);
+	ue_cnt++;
+      }
+    }
+    sleep(1);
+  }
+  return NULL;
+}
+
+FD_stats_form * create_form_stats_form( void ) {
+  FL_OBJECT *obj;
+  FD_stats_form *fdui = fl_malloc( sizeof *fdui );
+  fdui->vdata = fdui->cdata = NULL;
+  fdui->ldata = 0;
+  fdui->stats_form = fl_bgn_form( FL_NO_BOX, 1115, 900 );
+  obj = fl_add_box( FL_UP_BOX, 0, 0, 1115, 900, "" );
+  //fdui->stats_text = obj = fl_add_text( FL_NORMAL_TEXT, 60, 50, 1000, 810, "test" );
+  //fl_set_object_lsize( obj, FL_TINY_SIZE );
+  fdui->stats_text = obj = fl_add_browser( FL_NORMAL_BROWSER, 60, 50, 1000, 810, "test" );
+  fl_set_browser_fontsize(obj,FL_TINY_SIZE);
+  fdui->stats_button = obj = fl_add_button( FL_PUSH_BUTTON, 60, 10, 130, 30, "Reset Stats" );
+  fl_set_object_lalign( obj, FL_ALIGN_CENTER );
+  fl_set_object_color( obj, FL_GREEN, FL_GREEN);
+  fl_end_form( );
+  fdui->stats_form->fdui = fdui;
+  return fdui;
+}
+
+void startScope(scopeParms_t * p) {
+  FD_stats_form                  *form_stats=NULL,*form_stats_l2=NULL;
+  char title[255];
+  fl_initialize (p->argc, p->argv, NULL, 0, 0);
+  form_stats_l2 = create_form_stats_form();
+  fl_show_form (form_stats_l2->stats_form, FL_PLACE_HOTSPOT, FL_FULLBORDER, "l2 stats");
+  form_stats = create_form_stats_form();
+  fl_show_form (form_stats->stats_form, FL_PLACE_HOTSPOT, FL_FULLBORDER, "stats");
+
+  for(int UE_id=0; UE_id<scope_enb_num_ue; UE_id++) {
+    for(int CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
+      form_gnb[CC_id][UE_id] = create_phy_scope_gnb();
+      sprintf (title, "LTE UL SCOPE eNB for CC_id %d, UE %d",CC_id,UE_id);
+      fl_show_form (form_gnb[CC_id][UE_id]->phy_scope_gnb, FL_PLACE_HOTSPOT, FL_FULLBORDER, title);
+    } // CC_id
+  } // UE_id
+
+  pthread_t forms_thread;
+  threadCreate(&forms_thread, scope_thread, NULL, "scope", -1, OAI_PRIORITY_RT_LOW);
+}
diff --git a/openair1/PHY/TOOLS/nr_phy_scope.h b/openair1/PHY/TOOLS/nr_phy_scope.h
index eaf42bafab..9c161988a1 100644
--- a/openair1/PHY/TOOLS/nr_phy_scope.h
+++ b/openair1/PHY/TOOLS/nr_phy_scope.h
@@ -21,19 +21,24 @@
 
 /* Header file generated by fdesign on Tue Nov 13 09:42:50 2012 */
 
-#ifndef FD_lte_scope_h_
-#define FD_lte_scope_h_
-
+#ifndef FD_nr_scope_h_
+#define FD_nr_scope_h_
+#include <simple_executable.h>
+#include <common/utils/system.h>
+#include <openairinterface5g_limits.h>
+#include <openair2/LAYER2/NR_MAC_gNB/nr_mac_gNB.h>
+#include "common/ran_context.h"
+#include <openair1/PHY/defs_gNB.h>
+#include <nr-softmodem.h>
 #include <forms.h>
-//#include "PHY/defs_eNB.h"
-//#include "PHY/defs_UE.h"
+#include "PHY/defs_gNB.h"
+//#include "PHY/defs_nrUE.h"
 //#include "PHY/impl_defs_top.h"
 #include "PHY/defs_nr_UE.h"
 
-
 /* Forms and Objects */
 typedef struct {
-  FL_FORM   * lte_phy_scope_enb;
+  FL_FORM   * phy_scope_gnb;
   FL_OBJECT * rxsig_t;
   FL_OBJECT * chest_f;
   FL_OBJECT * chest_t;
@@ -43,10 +48,10 @@ typedef struct {
   FL_OBJECT * pusch_llr;
   FL_OBJECT * pusch_tput;
   FL_OBJECT * button_0;
-} FD_lte_phy_scope_enb;
+} FD_phy_scope_gnb;
 
 typedef struct {
-    FL_FORM   * lte_phy_scope_ue;
+    FL_FORM   * phy_scope_nrue;
     FL_OBJECT * rxsig_t;
     FL_OBJECT * chest_f;
     FL_OBJECT * chest_t;
@@ -61,24 +66,22 @@ typedef struct {
     FL_OBJECT * pdsch_tput;
     FL_OBJECT * button_0;
 
-} FD_lte_phy_scope_ue;
+} FD_phy_scope_nrue;
 
-FD_lte_phy_scope_enb * create_lte_phy_scope_enb( void );
-FD_lte_phy_scope_ue * create_lte_phy_scope_ue( void );
+extern unsigned char scope_enb_num_ue;
+FD_phy_scope_gnb * create_phy_scope_gnb( void );
+FD_phy_scope_nrue * create_phy_scope_nrue( void );
 
-/*
-void phy_scope_eNB(FD_lte_phy_scope_enb *form,
-                   PHY_VARS_gNB *phy_vars_enb,
+
+void phy_scope_gNB(FD_phy_scope_gnb *form,
+                   PHY_VARS_gNB *phy_vars_gnb,
                    int UE_id);
-*/
 
-void phy_scope_UE(FD_lte_phy_scope_ue *form,
+
+void phy_scope_nrUE(FD_phy_scope_nrue *form,
                   PHY_VARS_NR_UE *phy_vars_ue,
                   int eNB_id,
                   int UE_id,
                   uint8_t subframe);
-
-
-
-
-#endif /* FD_lte_scope_h_ */
+extern RAN_CONTEXT_t RC;
+#endif
diff --git a/openair1/PHY/TOOLS/tools_defs.h b/openair1/PHY/TOOLS/tools_defs.h
index b57fc7e9de..8ba2ac0d40 100644
--- a/openair1/PHY/TOOLS/tools_defs.h
+++ b/openair1/PHY/TOOLS/tools_defs.h
@@ -354,10 +354,116 @@ int32_t dot_product(int16_t *x,
                     uint32_t N, //must be a multiple of 8
                     uint8_t output_shift);
 
-int64_t dot_product64(int16_t *x,
+static inline int64_t dot_product64(int16_t *x,
 		      int16_t *y,
 		      uint32_t N, //must be a multiple of 8
-		      uint8_t output_shift);
+		      uint8_t output_shift)
+{
+
+#if defined(__x86_64__) || defined(__i386__)
+  __m128i *x128,*y128,mmtmp1,mmtmp2,mmtmp3,mmcumul,mmcumul_re,mmcumul_im;
+  __m128i minus_i = _mm_set_epi16(-1,1,-1,1,-1,1,-1,1);
+  int64_t result;
+
+  x128 = (__m128i*) x;
+  y128 = (__m128i*) y;
+
+  mmcumul_re = _mm_setzero_si128();
+  mmcumul_im = _mm_setzero_si128();
+
+  __m128i*end=x128+(N>>2);
+  for (__m128i* inPtr=x128; inPtr < end ; inPtr++) {
+
+//    printf("n=%d, x128=%p, y128=%p\n",n,x128,y128);
+       // print_shorts("x",&x128[0]);
+       // print_shorts("y",&y128[0]);
+
+    // this computes Re(z) = Re(x)*Re(y) + Im(x)*Im(y)
+    mmtmp1 = _mm_madd_epi16(*inPtr,*y128);
+      //  print_ints("retmp",&mmtmp1);
+    // mmtmp1 contains real part of 4 consecutive outputs (32-bit)
+    // shift and accumulate results
+    mmtmp1 = _mm_srai_epi32(mmtmp1,output_shift);
+    mmcumul_re = _mm_add_epi32(mmcumul_re,mmtmp1);
+        //print_ints("re",&mmcumul_re);
+
+
+    // this computes Im(z) = Re(x)*Im(y) - Re(y)*Im(x)
+    mmtmp2 = _mm_shufflelo_epi16(*y128,_MM_SHUFFLE(2,3,0,1));
+        //print_shorts("y",&mmtmp2);
+    mmtmp2 = _mm_shufflehi_epi16(mmtmp2,_MM_SHUFFLE(2,3,0,1));
+        //print_shorts("y",&mmtmp2);
+    mmtmp2 = _mm_sign_epi16(mmtmp2,minus_i);
+          //  print_shorts("y",&mmtmp2);
+
+    mmtmp3 = _mm_madd_epi16(*inPtr,mmtmp2);
+            //print_ints("imtmp",&mmtmp3);
+    // mmtmp3 contains imag part of 4 consecutive outputs (32-bit)
+    // shift and accumulate results
+    mmtmp3 = _mm_srai_epi32(mmtmp3,output_shift);
+    mmcumul_im = _mm_add_epi32(mmcumul_im,mmtmp3);
+        //print_ints("im",&mmcumul_im);
+    y128++;
+  }
+
+  // this gives Re Re Im Im
+  mmcumul = _mm_hadd_epi32(mmcumul_re,mmcumul_im);
+    //print_ints("cumul1",&mmcumul);
+  // this gives Re Im Re Im
+  mmcumul = _mm_hadd_epi32(mmcumul,mmcumul);
+    //print_ints("cumul2",&mmcumul);
+
+  //mmcumul = _mm_srai_epi32(mmcumul,output_shift);
+  // extract the lower half
+  result = _mm_extract_epi64(mmcumul,0);
+  //printf("result: (%d,%d)\n",((int32_t*)&result)[0],((int32_t*)&result)[1]); 
+ 
+  return(result);
+
+#elif defined(__arm__)
+  int16x4_t *x_128=(int16x4_t*)x;
+  int16x4_t *y_128=(int16x4_t*)y;
+  int32x4_t tmp_re,tmp_im;
+  int32x4_t tmp_re1,tmp_im1;
+  int32x4_t re_cumul,im_cumul;
+  int32x2_t re_cumul2,im_cumul2;
+  int32x4_t shift = vdupq_n_s32(-output_shift); 
+  int32x2x2_t result2;
+  int16_t conjug[4]__attribute__((aligned(16))) = {-1,1,-1,1} ;
+
+  re_cumul = vdupq_n_s32(0);
+  im_cumul = vdupq_n_s32(0); 
+
+  for (n=0; n<(N>>2); n++) {
+
+    tmp_re  = vmull_s16(*x_128++, *y_128++);
+    //tmp_re = [Re(x[0])Re(y[0]) Im(x[0])Im(y[0]) Re(x[1])Re(y[1]) Im(x[1])Im(y[1])] 
+    tmp_re1 = vmull_s16(*x_128++, *y_128++);
+    //tmp_re1 = [Re(x1[1])Re(x2[1]) Im(x1[1])Im(x2[1]) Re(x1[1])Re(x2[2]) Im(x1[1])Im(x2[2])] 
+    tmp_re  = vcombine_s32(vpadd_s32(vget_low_s32(tmp_re),vget_high_s32(tmp_re)),
+                           vpadd_s32(vget_low_s32(tmp_re1),vget_high_s32(tmp_re1)));
+    //tmp_re = [Re(ch[0])Re(rx[0])+Im(ch[0])Im(ch[0]) Re(ch[1])Re(rx[1])+Im(ch[1])Im(ch[1]) Re(ch[2])Re(rx[2])+Im(ch[2]) Im(ch[2]) Re(ch[3])Re(rx[3])+Im(ch[3])Im(ch[3])] 
+
+    tmp_im  = vmull_s16(vrev32_s16(vmul_s16(*x_128++,*(int16x4_t*)conjug)),*y_128++);
+    //tmp_im = [-Im(ch[0])Re(rx[0]) Re(ch[0])Im(rx[0]) -Im(ch[1])Re(rx[1]) Re(ch[1])Im(rx[1])]
+    tmp_im1 = vmull_s16(vrev32_s16(vmul_s16(*x_128++,*(int16x4_t*)conjug)),*y_128++);
+    //tmp_im1 = [-Im(ch[2])Re(rx[2]) Re(ch[2])Im(rx[2]) -Im(ch[3])Re(rx[3]) Re(ch[3])Im(rx[3])]
+    tmp_im  = vcombine_s32(vpadd_s32(vget_low_s32(tmp_im),vget_high_s32(tmp_im)),
+                           vpadd_s32(vget_low_s32(tmp_im1),vget_high_s32(tmp_im1)));
+    //tmp_im = [-Im(ch[0])Re(rx[0])+Re(ch[0])Im(rx[0]) -Im(ch[1])Re(rx[1])+Re(ch[1])Im(rx[1]) -Im(ch[2])Re(rx[2])+Re(ch[2])Im(rx[2]) -Im(ch[3])Re(rx[3])+Re(ch[3])Im(rx[3])]
+
+    re_cumul = vqaddq_s32(re_cumul,vqshlq_s32(tmp_re,shift));
+    im_cumul = vqaddq_s32(im_cumul,vqshlq_s32(tmp_im,shift));
+  }
+  
+  re_cumul2 = vpadd_s32(vget_low_s32(re_cumul),vget_high_s32(re_cumul));
+  im_cumul2 = vpadd_s32(vget_low_s32(im_cumul),vget_high_s32(im_cumul));
+  re_cumul2 = vpadd_s32(re_cumul2,re_cumul2);
+  im_cumul2 = vpadd_s32(im_cumul2,im_cumul2);
+  result2   = vzip_s32(re_cumul2,im_cumul2);
+  return(vget_lane_s32(result2.val[0],0));
+#endif
+}
 
 void dft12(int16_t *x,int16_t *y);
 void dft24(int16_t *x,int16_t *y,uint8_t scale_flag);
diff --git a/openair1/PHY/defs_L1_NB_IoT.h b/openair1/PHY/defs_L1_NB_IoT.h
index 8a7c853df5..bd583ee574 100644
--- a/openair1/PHY/defs_L1_NB_IoT.h
+++ b/openair1/PHY/defs_L1_NB_IoT.h
@@ -141,7 +141,7 @@ static inline void* malloc16_clear( size_t size )
 #include <pthread.h>
 
 #include "targets/ARCH/COMMON/common_lib.h"
-#include "targets/COMMON/openairinterface5g_limits.h"
+#include "openairinterface5g_limits.h"
 
 #define NUM_DCI_MAX_NB_IoT 32
 
diff --git a/openair1/PHY/defs_common.h b/openair1/PHY/defs_common.h
index f479c30b8c..503e8cdc03 100644
--- a/openair1/PHY/defs_common.h
+++ b/openair1/PHY/defs_common.h
@@ -69,7 +69,7 @@
 
 #include "TOOLS/tools_defs.h"
 
-#include "targets/COMMON/openairinterface5g_limits.h"
+#include "openairinterface5g_limits.h"
 #include "common/utils/LOG/log.h"
 
 #include "types.h"
@@ -704,6 +704,11 @@ typedef enum {
   TM9_10=14
 } MIMO_mode_t;
 
+typedef enum {
+  NR_SISO=0,
+  NR_DUALSTREAM=1
+} MIMO_nrmode_t;
+
 
 typedef enum {
   /// MRT
diff --git a/openair1/PHY/defs_eNB.h b/openair1/PHY/defs_eNB.h
index d23586c634..8fc8fb4fa9 100644
--- a/openair1/PHY/defs_eNB.h
+++ b/openair1/PHY/defs_eNB.h
@@ -76,8 +76,8 @@
 
 #include <pthread.h>
 
-#include "targets/ARCH/COMMON/common_lib.h"
-#include "targets/COMMON/openairinterface5g_limits.h"
+#include "common_lib.h"
+#include "openairinterface5g_limits.h"
 
 
 #define NUMBER_OF_SUBBANDS_MAX 13
diff --git a/openair1/PHY/defs_gNB.h b/openair1/PHY/defs_gNB.h
index 10b99eb113..24be9688dc 100644
--- a/openair1/PHY/defs_gNB.h
+++ b/openair1/PHY/defs_gNB.h
@@ -38,6 +38,10 @@
 #include "CODING/nrPolar_tools/nr_polar_pbch_defs.h"
 #include "openair2/NR_PHY_INTERFACE/NR_IF_Module.h"
 #include "PHY/NR_TRANSPORT/nr_transport_common_proto.h"
+#include "PHY/impl_defs_top.h"
+#include "PHY/defs_common.h"
+#include "PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.h"
+#include "PHY/CODING/nrLDPC_decoder/nrLDPC_types.h"
 
 #define MAX_NUM_RU_PER_gNB MAX_NUM_RU_PER_eNB
 
@@ -72,6 +76,7 @@ typedef struct {
   uint64_t dci_pdu[2];
 } NR_gNB_DCI_ALLOC_t;
 
+
 typedef struct {
   uint8_t     num_dci;
   uint8_t     num_pdsch_rnti;
@@ -79,6 +84,14 @@ typedef struct {
 } NR_gNB_PDCCH;
 
 
+typedef enum {
+  NR_SCH_IDLE,
+  NR_ACTIVE,
+  NR_CBA_ACTIVE,
+  NR_DISABLED
+} NR_SCH_status_t;
+
+
 typedef struct {
   /// Nfapi DLSCH PDU
   nfapi_nr_dl_config_dlsch_pdu dlsch_pdu;
@@ -114,7 +127,6 @@ typedef struct {
 
 
 typedef struct {
-
   /// Pointers to 16 HARQ processes for the DLSCH
   NR_DL_gNB_HARQ_t *harq_processes[NR_MAX_NB_HARQ_PROCESSES];
   /// TX buffers for UE-spec transmission (antenna ports 5 or 7..14, prior to precoding)
@@ -160,6 +172,170 @@ typedef struct {
 } NR_gNB_DLSCH_t;
 
 
+typedef struct {
+  /// Nfapi ULSCH PDU
+  nfapi_nr_ul_config_ulsch_pdu ulsch_pdu;
+  /// Frame where current HARQ round was sent
+  uint32_t frame;
+  /// Subframe where current HARQ round was sent
+  uint32_t subframe;
+  /// Index of current HARQ round for this DLSCH
+  uint8_t round;
+  /// Last TPC command
+  uint8_t TPC;
+  /// MIMO mode for this DLSCH
+  MIMO_mode_t mimo_mode;
+  /// Flag indicating that this ULSCH has been allocated by a DCI (otherwise it is a retransmission based on PHICH NAK)
+  uint8_t dci_alloc;
+  /// Flag indicating that this ULSCH has been allocated by a RAR (otherwise it is a retransmission based on PHICH NAK or DCI)
+  uint8_t rar_alloc;
+  /// Status Flag indicating for this ULSCH (idle,active,disabled)
+  NR_SCH_status_t status;
+  /// Subframe scheduling indicator (i.e. Transmission opportunity indicator)
+  uint8_t subframe_scheduling_flag;
+  /// Subframe cba scheduling indicator (i.e. CBA Transmission opportunity indicator)
+  uint8_t subframe_cba_scheduling_flag;
+  /// PHICH active flag
+  uint8_t phich_active;
+  /// PHICH ACK
+  uint8_t phich_ACK;
+  /// First Allocated RB - previous scheduling. This is needed for PHICH generation which is done after a new scheduling
+  uint16_t previous_first_rb;
+  /// Flag to indicate that the UL configuration has been handled. Used to remove a stale ULSCH when frame wraps around
+  uint8_t handled;
+  /// Flag to indicate that this ULSCH is for calibration information sent from UE (i.e. no MAC SDU to pass up)
+  //  int calibration_flag;
+  /// delta_TF for power control
+  int32_t delta_TF;
+
+  
+  /////////////////////// ulsch decoding ///////////////////////
+  /// Transport block size (This is A from 38.212 V15.4.0 section 5.1)
+  uint32_t TBS;
+  /// Pointer to the payload (38.212 V15.4.0 section 5.1)
+  uint8_t *b;
+  /// The payload + CRC (24 bits) in bits (38.212 V15.4.0 section 5.1)
+  uint32_t B;
+  /// Pointers to code blocks after code block segmentation and CRC attachment (38.212 V15.4.0 section 5.2.2)
+  uint8_t *c[MAX_NUM_NR_ULSCH_SEGMENTS];
+  /// Number of bits in each code block (38.212 V15.4.0 section 5.2.2)
+  uint32_t K;
+  /// Number of "Filler" bits added in the code block segmentation (38.212 V15.4.0 section 5.2.2)
+  uint32_t F;
+  /// Number of code blocks after code block segmentation (38.212 V15.4.0 section 5.2.2)
+  uint32_t C;
+  /// Pointers to code blocks after LDPC coding (38.212 V15.4.0 section 5.3.2)
+  int16_t *d[MAX_NUM_NR_ULSCH_SEGMENTS];
+  /// LDPC processing buffer
+  t_nrLDPC_procBuf* p_nrLDPC_procBuf[MAX_NUM_NR_ULSCH_SEGMENTS];
+  /// LDPC lifting size (38.212 V15.4.0 table 5.3.2-1)
+  uint32_t Z;
+  /// code blocks after bit selection in rate matching for LDPC code (38.212 V15.4.0 section 5.4.2.1)
+  int16_t e[MAX_NUM_NR_DLSCH_SEGMENTS][3*8448];
+  /// Number of bits in each code block after rate matching for LDPC code (38.212 V15.4.0 section 5.4.2.1)
+  uint32_t E;
+  /// Number of soft channel bits after code block concatenation (38.212 V15.4.0 section 5.5)
+  uint32_t G;
+  //////////////////////////////////////////////////////////////
+
+
+  /////////////////////////// DMRS /////////////////////////////
+  /// n_DMRS  for cyclic shift of DMRS (36.213 Table 9.1.2-2)
+  uint8_t n_DMRS;
+  /// n_DMRS 2 for cyclic shift of DMRS (36.211 Table 5.5.1.1.-1)
+  uint8_t n_DMRS2;
+  /// n_DMRS  for cyclic shift of DMRS (36.213 Table 9.1.2-2) - previous scheduling
+  /// This is needed for PHICH generation which
+  /// is done after a new scheduling
+  uint8_t previous_n_DMRS;
+  //////////////////////////////////////////////////////////////
+
+
+  ///////////////////// UCI multiplexing ///////////////////////
+  /// CQI CRC status
+  uint8_t cqi_crc_status;
+  /// Pointer to CQI data
+  uint8_t o[MAX_CQI_BYTES];
+  /// Format of CQI data
+  UCI_format_t uci_format;
+  /// Length of CQI data under RI=1 assumption(bits)
+  uint8_t Or1;
+  /// Length of CQI data under RI=2 assumption(bits)
+  uint8_t Or2;
+  /// Rank information
+  uint8_t o_RI[2];
+  /// Length of rank information (bits)
+  uint8_t O_RI;
+  /// Pointer to ACK
+  uint8_t o_ACK[4];
+  /// Length of ACK information (bits)
+  uint8_t O_ACK;
+  /// The value of DAI in DCI format 0
+  uint8_t V_UL_DAI;
+  /// "q" sequences for CQI/PMI (for definition see 36-212 V8.6 2009-03, p.27)
+  int8_t q[MAX_CQI_PAYLOAD];
+  /// number of coded CQI bits after interleaving
+  uint8_t o_RCC;
+  /// coded and interleaved CQI bits
+  int8_t o_w[(MAX_CQI_BITS+8)*3];
+  /// coded CQI bits
+  int8_t o_d[96+((MAX_CQI_BITS+8)*3)];
+  /// coded ACK bits
+  int16_t q_ACK[MAX_ACK_PAYLOAD];
+  /// coded RI bits
+  int16_t q_RI[MAX_RI_PAYLOAD];
+  /// Temporary h sequence to flag PUSCH_x/PUSCH_y symbols which are not scrambled
+  uint8_t h[MAX_NUM_CHANNEL_BITS];
+  /// soft bits for each received segment ("w"-sequence)(for definition see 36-212 V8.6 2009-03, p.15)
+  int16_t w[MAX_NUM_ULSCH_SEGMENTS][3*(6144+64)];
+  //////////////////////////////////////////////////////////////
+} NR_UL_gNB_HARQ_t;
+
+
+typedef struct {
+  /// Pointers to 16 HARQ processes for the ULSCH
+  NR_UL_gNB_HARQ_t *harq_processes[NR_MAX_ULSCH_HARQ_PROCESSES];
+  /// Current HARQ process id
+  int harq_process_id[NR_MAX_SLOTS_PER_FRAME];
+  /// HARQ process mask, indicates which processes are currently active
+  uint16_t harq_mask;
+  /// ACK/NAK Bundling flag
+  uint8_t bundling;
+  /// beta_offset_cqi times 8
+  uint16_t beta_offset_cqi_times8;
+  /// beta_offset_ri times 8
+  uint16_t beta_offset_ri_times8;
+  /// beta_offset_harqack times 8
+  uint16_t beta_offset_harqack_times8;
+  /// Flag to indicate that gNB awaits UE Msg3
+  uint8_t Msg3_active;
+  /// Flag to indicate that gNB should decode UE Msg3
+  uint8_t Msg3_flag;
+  /// Subframe for Msg3
+  uint8_t Msg3_subframe;
+  /// Frame for Msg3
+  uint32_t Msg3_frame;
+  /// Allocated RNTI for this ULSCH
+  uint16_t rnti;
+  /// RNTI type
+  uint8_t rnti_type;
+  /// cyclic shift for DM RS
+  uint8_t cyclicShift;
+  /// for cooperative communication
+  uint8_t cooperation_flag;
+  /// Maximum number of HARQ rounds
+  uint8_t Mlimit;
+  /// Maximum number of LDPC iterations
+  uint8_t max_ldpc_iterations;
+  /// number of iterations used in last LDPC decoding
+  uint8_t last_iteration_cnt;  
+  /// num active cba group
+  uint8_t num_active_cba_groups;
+  /// num active cba group
+  uint16_t cba_rnti[NUM_MAX_CBA_GROUP];
+} NR_gNB_ULSCH_t;
+
+
 typedef struct {
   /// \brief Pointers (dynamic) to the received data in the time domain.
   /// - first index: rx antenna [0..nb_antennas_rx[
@@ -394,17 +570,18 @@ typedef struct PHY_VARS_gNB_s {
   LTE_eNB_PHICH       phich_vars[2];
 
   NR_gNB_COMMON       common_vars;
-  LTE_eNB_UCI          uci_vars[NUMBER_OF_UE_MAX];
-  LTE_eNB_SRS          srs_vars[NUMBER_OF_UE_MAX];
-  LTE_eNB_PUSCH       *pusch_vars[NUMBER_OF_UE_MAX];
-  LTE_eNB_PRACH        prach_vars;
-  NR_gNB_DLSCH_t     *dlsch[NUMBER_OF_UE_MAX][2];   // Nusers times two spatial streams
-  LTE_eNB_ULSCH_t     *ulsch[NUMBER_OF_UE_MAX+1];      // Nusers + number of RA
+  LTE_eNB_UCI         uci_vars[NUMBER_OF_UE_MAX];
+  LTE_eNB_SRS         srs_vars[NUMBER_OF_UE_MAX];
+  LTE_eNB_PUSCH      *pusch_vars[NUMBER_OF_UE_MAX];
+  LTE_eNB_PRACH       prach_vars;
+  NR_gNB_DLSCH_t     *dlsch[NUMBER_OF_UE_MAX][2];    // Nusers times two spatial streams
+  NR_gNB_ULSCH_t     *ulsch[NUMBER_OF_UE_MAX+1][2];  // [Nusers times + number of RA][2 codewords], index 0 in [NUMBER_OF_UE_MAX+1] is for RA
+  // LTE_eNB_ULSCH_t     *ulsch[NUMBER_OF_UE_MAX+1];     // Nusers + number of RA
   NR_gNB_DLSCH_t     *dlsch_SI,*dlsch_ra,*dlsch_p;
   NR_gNB_DLSCH_t     *dlsch_MCH;
   NR_gNB_DLSCH_t     *dlsch_PCH;
-  LTE_eNB_UE_stats     UE_stats[NUMBER_OF_UE_MAX];
-  LTE_eNB_UE_stats    *UE_stats_ptr[NUMBER_OF_UE_MAX];
+  LTE_eNB_UE_stats    UE_stats[NUMBER_OF_UE_MAX];
+  LTE_eNB_UE_stats   *UE_stats_ptr[NUMBER_OF_UE_MAX];
 
   uint8_t pbch_configured;
   uint8_t pbch_pdu[4]; //PBCH_PDU_SIZE
diff --git a/openair1/PHY/defs_nr_UE.h b/openair1/PHY/defs_nr_UE.h
index a3c404ba61..8f463b59b5 100644
--- a/openair1/PHY/defs_nr_UE.h
+++ b/openair1/PHY/defs_nr_UE.h
@@ -157,109 +157,6 @@
 
 #include "targets/ARCH/COMMON/common_lib.h"
 
-#include "NR_IF_Module.h"
-
-/// Context data structure for RX/TX portion of subframe processing
-typedef struct {
-  /// index of the current UE RX/TX proc
-  int                  proc_id;
-  /// Component Carrier index
-  uint8_t              CC_id;
-  /// timestamp transmitted to HW
-  openair0_timestamp timestamp_tx;
-  //#ifdef UE_NR_PHY_DEMO
-  /// NR TTI index within subframe_tx [0 .. ttis_per_subframe - 1] to act upon for transmission
-  int nr_tti_tx;
-  /// NR TTI index within subframe_rx [0 .. ttis_per_subframe - 1] to act upon for reception
-  int nr_tti_rx;
-  //#endif
-  /// subframe to act upon for transmission
-  int subframe_tx;
-  /// subframe to act upon for reception
-  int subframe_rx;
-  /// frame to act upon for transmission
-  int frame_tx;
-  /// frame to act upon for reception
-  int frame_rx;
-  /// \brief Instance count for RXn-TXnp4 processing thread.
-  /// \internal This variable is protected by \ref mutex_rxtx.
-  int instance_cnt_rxtx;
-  /// pthread structure for RXn-TXnp4 processing thread
-  pthread_t pthread_rxtx;
-  /// pthread attributes for RXn-TXnp4 processing thread
-  pthread_attr_t attr_rxtx;
-  /// condition variable for tx processing thread
-  pthread_cond_t cond_rxtx;
-  /// mutex for RXn-TXnp4 processing thread
-  pthread_mutex_t mutex_rxtx;
-  /// scheduling parameters for RXn-TXnp4 thread
-  struct sched_param sched_param_rxtx;
-
-  /// internal This variable is protected by ref mutex_fep_slot1.
-  //int instance_cnt_slot0_dl_processing;
-  int instance_cnt_slot1_dl_processing;
-  /// pthread descriptor fep_slot1 thread
-  //pthread_t pthread_slot0_dl_processing;
-  pthread_t pthread_slot1_dl_processing;
-  /// pthread attributes for fep_slot1 processing thread
-  // pthread_attr_t attr_slot0_dl_processing;
-  pthread_attr_t attr_slot1_dl_processing;
-  /// condition variable for UE fep_slot1 thread;
-  //pthread_cond_t cond_slot0_dl_processing;
-  pthread_cond_t cond_slot1_dl_processing;
-  /// mutex for UE synch thread
-  //pthread_mutex_t mutex_slot0_dl_processing;
-  pthread_mutex_t mutex_slot1_dl_processing;
-  //int instance_cnt_slot0_dl_processing;
-  int instance_cnt_dlsch_td;
-  /// pthread descriptor fep_slot1 thread
-  //pthread_t pthread_slot0_dl_processing;
-  pthread_t pthread_dlsch_td;
-  /// pthread attributes for fep_slot1 processing thread
-  // pthread_attr_t attr_slot0_dl_processing;
-  pthread_attr_t attr_dlsch_td;
-  /// condition variable for UE fep_slot1 thread;
-  //pthread_cond_t cond_slot0_dl_processing;
-  pthread_cond_t cond_dlsch_td;
-  /// mutex for UE synch thread
-  //pthread_mutex_t mutex_slot0_dl_processing;
-  pthread_mutex_t mutex_dlsch_td;
-  //
-  uint8_t chan_est_pilot0_slot1_available;
-  uint8_t chan_est_slot1_available;
-  uint8_t llr_slot1_available;
-  uint8_t dci_slot0_available;
-  uint8_t first_symbol_available;
-  uint8_t decoder_thread_available;
-  uint8_t decoder_main_available;
-  uint8_t decoder_switch;
-  int counter_decoder;
-  uint8_t channel_level;
-  int eNB_id;
-  int harq_pid;
-  int llr8_flag;
-  /// scheduling parameters for fep_slot1 thread
-  struct sched_param sched_param_fep_slot1;
-
-  int sub_frame_start;
-  int sub_frame_step;
-  unsigned long long gotIQs;
-  uint8_t decoder_thread_available1;
-  int instance_cnt_dlsch_td1;
-  /// pthread descriptor fep_slot1 thread
-  //pthread_t pthread_slot0_dl_processing;
-  pthread_t pthread_dlsch_td1;
-  /// pthread attributes for fep_slot1 processing thread
-  // pthread_attr_t attr_slot0_dl_processing;
-  pthread_attr_t attr_dlsch_td1;
-  /// condition variable for UE fep_slot1 thread;
-  //pthread_cond_t cond_slot0_dl_processing;
-  pthread_cond_t cond_dlsch_td1;
-  /// mutex for UE synch thread
-  //pthread_mutex_t mutex_slot0_dl_processing;
-  pthread_mutex_t mutex_dlsch_td1;
-  int dci_err_cnt;
-} UE_nr_rxtx_proc_t;
 
 /// Context data structure for eNB subframe processing
 typedef struct {
@@ -267,27 +164,6 @@ typedef struct {
   uint8_t              CC_id;
   /// Last RX timestamp
   openair0_timestamp timestamp_rx;
-  /// pthread attributes for main UE thread
-  pthread_attr_t attr_ue;
-  /// scheduling parameters for main UE thread
-  struct sched_param sched_param_ue;
-  /// pthread descriptor main UE thread
-  pthread_t pthread_ue;
-  /// \brief Instance count for synch thread.
-  /// \internal This variable is protected by \ref mutex_synch.
-  int instance_cnt_synch;
-  /// pthread attributes for synch processing thread
-  pthread_attr_t attr_synch;
-  /// scheduling parameters for synch thread
-  struct sched_param sched_param_synch;
-  /// pthread descriptor synch thread
-  pthread_t pthread_synch;
-  /// condition variable for UE synch thread;
-  pthread_cond_t cond_synch;
-  /// mutex for UE synch thread
-  pthread_mutex_t mutex_synch;
-  /// set of scheduling variables RXn-TXnp4 threads
-  UE_nr_rxtx_proc_t proc_rxtx[RX_NB_TH];
 } UE_nr_proc_t;
 
 typedef enum {
@@ -399,17 +275,6 @@ typedef struct {
   /// - second index: symbol [0..28*ofdm_symbol_size[
   int32_t **rxdataF;
 
-  /// \brief Hold the channel estimates in frequency domain.
-  /// - first index: eNB id [0..6] (hard coded)
-  /// - second index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx
-  /// - third index: samples? [0..symbols_per_tti*(ofdm_symbol_size+LTE_CE_FILTER_LENGTH)[
-  int32_t **dl_ch_estimates[7];
-
-  /// \brief Hold the channel estimates in time domain (used for tracking).
-  /// - first index: eNB id [0..6] (hard coded)
-  /// - second index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx
-  /// - third index: samples? [0..2*ofdm_symbol_size[
-  int32_t **dl_ch_estimates_time[7];
 } NR_UE_COMMON_PER_THREAD;
 
 typedef struct {
@@ -459,6 +324,10 @@ typedef struct {
   /// - third index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx
   /// - fourth index: ? [0..168*N_RB_DL[
   int32_t **rxdataF_comp1[8][8];
+  /// \brief Hold the channel estimates in frequency domain.
+  /// - first index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx
+  /// - second index: samples? [0..symbols_per_tti*(ofdm_symbol_size+LTE_CE_FILTER_LENGTH)[
+  int32_t **dl_ch_estimates;
   /// \brief Downlink channel estimates extracted in PRBS.
   /// - first index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx
   /// - second index: ? [0..168*N_RB_DL[
@@ -510,6 +379,8 @@ typedef struct {
   /// - first index: ? [0..1] (hard coded)
   /// - second index: ? [0..1179743] (hard coded)
   int16_t *llr[2];
+  /// Pointers to layer llr vectors (4 layers).
+  int16_t *layer_llr[4];
   /// \f$\log_2(\max|H_i|^2)\f$
   int16_t log2_maxh;
   /// \f$\log_2(\max|H_i|^2)\f$ //this is for TM3-4 layer1 channel compensation
@@ -851,6 +722,14 @@ typedef struct {
   /// - first index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx
   /// - second index: ? [0..168*N_RB_DL[
   int32_t **rxdataF_comp;
+  /// \brief Hold the channel estimates in frequency domain.
+  /// - first index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx
+  /// - second index: samples? [0..symbols_per_tti*(ofdm_symbol_size+LTE_CE_FILTER_LENGTH)[
+  int32_t **dl_ch_estimates;
+  /// \brief Hold the channel estimates in time domain (used for tracking).
+  /// - first index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx
+  /// - second index: samples? [0..2*ofdm_symbol_size[
+  int32_t **dl_ch_estimates_time;
   /// \brief Pointers to extracted channel estimates of PDCCH symbols.
   /// - first index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx
   /// - second index: ? [0..168*N_RB_DL[
@@ -918,6 +797,10 @@ typedef struct {
   /// - first index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx
   /// - second index: ? [0..287] (hard coded)
   int32_t **rxdataF_comp;
+  /// \brief Hold the channel estimates in frequency domain.
+  /// - first index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx
+  /// - second index: samples? [0..symbols_per_tti*(ofdm_symbol_size+LTE_CE_FILTER_LENGTH)[
+  int32_t **dl_ch_estimates;
   /// \brief Pointers to downlink channel estimates in frequency-domain extracted in PRBS.
   /// - first index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx
   /// - second index: ? [0..287] (hard coded)
@@ -950,6 +833,16 @@ typedef struct {
   int16_t *prach;
 } NR_UE_PRACH;
 
+// structure used for multiple SSB detection
+typedef struct NR_UE_SSB {
+  uint8_t i_ssb;   // i_ssb between 0 and 7 (it corresponds to ssb_index only for Lmax=4,8)
+  uint8_t n_hf;    // n_hf = 0,1 for Lmax =4 or n_hf = 0 for Lmax =8,64
+  uint32_t metric; // metric to order SSB hypothesis
+  uint32_t c_re;
+  uint32_t c_im;
+  struct NR_UE_SSB *next_ssb;
+} NR_UE_SSB;
+
 /*typedef enum {
   /// do not detect any DCIs in the current subframe
   NO_DCI = 0x0,
@@ -967,6 +860,9 @@ typedef struct UE_NR_SCAN_INFO_s {
   int32_t freq_offset_Hz[3][10];
 } UE_NR_SCAN_INFO_t;
 
+
+#include "NR_IF_Module.h"
+
 /// Top-level PHY Data Structure for UE
 typedef struct {
   /// \brief Module ID indicator for this instance
@@ -1020,13 +916,14 @@ typedef struct {
   NR_UE_COMMON    common_vars;
 
   nr_ue_if_module_t *if_inst;
+  nfapi_nr_config_request_t  nrUE_config;
 
   nr_downlink_indication_t dl_indication;
   nr_uplink_indication_t ul_indication;
   /// UE FAPI DCI request
   nr_dcireq_t dcireq;
 
-  // CHECK if we need those as they are also included in dl_indictation
+  // pointers to the next 2 strcutres are also included in dl_indictation
   /// UE FAPI indication for DLSCH reception
   fapi_nr_rx_indication_t rx_ind;
   /// UE FAPI indication for DCI reception
@@ -1044,8 +941,8 @@ typedef struct {
   NR_UE_PBCH      *pbch_vars[NUMBER_OF_CONNECTED_eNB_MAX];
   NR_UE_PDCCH     *pdcch_vars[RX_NB_TH_MAX][NUMBER_OF_CONNECTED_eNB_MAX];
   NR_UE_PRACH     *prach_vars[NUMBER_OF_CONNECTED_eNB_MAX];
-  NR_UE_DLSCH_t   *dlsch[RX_NB_TH_MAX][NUMBER_OF_CONNECTED_eNB_MAX][2]; // two RxTx Threads
-  NR_UE_ULSCH_t   *ulsch[NUMBER_OF_CONNECTED_eNB_MAX];
+  NR_UE_DLSCH_t   *dlsch[RX_NB_TH_MAX][NUMBER_OF_CONNECTED_eNB_MAX][NR_MAX_NB_CODEWORDS]; // two RxTx Threads
+  NR_UE_ULSCH_t   *ulsch[RX_NB_TH_MAX][NUMBER_OF_CONNECTED_eNB_MAX][NR_MAX_NB_CODEWORDS]; // two code words
   NR_UE_DLSCH_t   *dlsch_SI[NUMBER_OF_CONNECTED_eNB_MAX];
   NR_UE_DLSCH_t   *dlsch_ra[NUMBER_OF_CONNECTED_eNB_MAX];
   NR_UE_DLSCH_t   *dlsch_p[NUMBER_OF_CONNECTED_eNB_MAX];
@@ -1079,7 +976,7 @@ typedef struct {
   uint32_t nr_gold_pbch[2][64][NR_PBCH_DMRS_LENGTH_DWORD];
 
   /// PDSCH DMRS
-  uint32_t nr_gold_pdsch[2][20][2][21];
+  uint32_t nr_gold_pdsch[2][20][2][52];
 
   /// PDCCH DMRS
   uint32_t nr_gold_pdcch[7][20][3][52];
@@ -1143,6 +1040,7 @@ typedef struct {
   uint8_t               decode_MIB;
   /// temporary offset during cell search prior to MIB decoding
   int              ssb_offset;
+  uint16_t	   symbol_offset; // offset in terms of symbols for detected ssb in sync
   int              rx_offset; /// Timing offset
   int              rx_offset_diff; /// Timing adjustment for ofdm symbol0 on HW USRP
   int              time_sync_cell;
@@ -1307,6 +1205,7 @@ typedef struct {
 
 } PHY_VARS_NR_UE;
 
+
 /* this structure is used to pass both UE phy vars and
  * proc to the function UE_thread_rxn_txnp4
  */
diff --git a/openair1/PHY/defs_nr_common.h b/openair1/PHY/defs_nr_common.h
index 58a8833b18..591d609454 100644
--- a/openair1/PHY/defs_nr_common.h
+++ b/openair1/PHY/defs_nr_common.h
@@ -87,10 +87,10 @@
 #define NR_MAX_CSET_DURATION 3
 
 #define NR_MAX_NB_RBG 18
-#define NR_MAX_NB_LAYERS 8
+#define NR_MAX_NB_LAYERS 8 // SU-MIMO (3GPP TS 38.211 V15.4.0 section 7.3.1.3)
 #define NR_MAX_NB_CODEWORDS 2
 #define NR_MAX_NB_HARQ_PROCESSES 16
-#define NR_MAX_PDSCH_ENCODED_LENGTH 950984
+#define NR_MAX_PDSCH_ENCODED_LENGTH NR_MAX_NB_RB*NR_SYMBOLS_PER_SLOT*NR_NB_SC_PER_RB*8*NR_MAX_NB_LAYERS // 8 is the maximum modulation order (it was 950984 before !!) 
 #define NR_MAX_PDSCH_TBS 3824
 
 typedef enum {
@@ -161,8 +161,6 @@ typedef struct NR_BWP_PARMS {
   uint8_t location;
   /// Bandwidth in PRB
   uint16_t N_RB;
-  /// Size of FFT/IFFT
-  uint16_t ofdm_symbol_size;
   /// Cyclic prefix
   uint8_t cyclic_prefix;
   /// RBG params
@@ -303,19 +301,36 @@ typedef struct NR_DL_FRAME_PARMS {
   /// TDD configuration
   uint16_t tdd_uplink_nr[2*NR_MAX_SLOTS_PER_FRAME]; /* this is a bitmap of symbol of each slot given for 2 frames */
 
-   //SSB related params
+  //SSB related params
   /// Start in Subcarrier index of the SSB block
   uint16_t ssb_start_subcarrier;
   /// SSB type
   nr_ssb_type_e ssb_type;
+  /// Max number of SSB in frame
+  uint8_t Lmax;
+  /// SS block pattern (max 64 ssb, each bit is on/off ssb)
+  uint64_t L_ssb;
   /// PBCH polar encoder params
   t_nrPolar_params pbch_polar_params;
 
-   //BWP params
-  NR_BWP_PARMS initial_bwp_dl;
-  NR_BWP_PARMS initial_bwp_ul;
-
 } NR_DL_FRAME_PARMS;
 
+#define KHz (1000UL)
+#define MHz (1000*KHz)
+
+typedef struct nr_bandentry_s {
+  int16_t band;
+  uint64_t ul_min;
+  uint64_t ul_max;
+  uint64_t dl_min;
+  uint64_t dl_max;
+  uint64_t N_OFFs_DL;
+  uint64_t step_size;
+} nr_bandentry_t;
+
+typedef struct nr_band_info_s {
+  int nbands;
+  nr_bandentry_t band_info[100];
+} nr_band_info_t;
 
 #endif
diff --git a/openair1/PHY/phy_extern.h b/openair1/PHY/phy_extern.h
index 623a4bb0c6..9baf8bf21d 100644
--- a/openair1/PHY/phy_extern.h
+++ b/openair1/PHY/phy_extern.h
@@ -40,16 +40,9 @@ extern int number_of_cards;
 
 extern short conjugate[8],conjugate2[8];
 
-#ifndef OCP_FRAMEWORK
-//extern PHY_VARS_eNB ***PHY_vars_eNB_g;
-extern RAN_CONTEXT_t RC;
-extern LTE_DL_FRAME_PARMS *lte_frame_parms_g;
-#else
-#define MAX_UE 10
-#define MAX_eNB 20
 
-extern PHY_VARS_eNB * PHY_vars_eNB_g[MAX_eNB][MAX_NUM_CCs];
-#endif
+
+extern RAN_CONTEXT_t RC;
 
 extern short primary_synch0[144];
 extern short primary_synch1[144];
diff --git a/openair1/PHY/phy_extern_nr_ue.h b/openair1/PHY/phy_extern_nr_ue.h
index 66dbd82fc4..70fbd21ffa 100644
--- a/openair1/PHY/phy_extern_nr_ue.h
+++ b/openair1/PHY/phy_extern_nr_ue.h
@@ -38,15 +38,7 @@ extern short conjugate[8],conjugate2[8];
 extern int number_of_cards;
 
 
-#ifndef OCP_FRAMEWORK
 extern PHY_VARS_NR_UE ***PHY_vars_UE_g;
-extern NR_DL_FRAME_PARMS *lte_frame_parms_g;
-#else
-#define MAX_UE 10
-#define MAX_eNB 20
-
-extern PHY_VARS_NR_UE * PHY_vars_UE_g[MAX_UE][MAX_NUM_CCs];
-#endif
 
 extern short primary_synch0[144];
 extern short primary_synch1[144];
diff --git a/openair1/PHY/phy_extern_ue.h b/openair1/PHY/phy_extern_ue.h
index 596686f261..6fd53ac15c 100644
--- a/openair1/PHY/phy_extern_ue.h
+++ b/openair1/PHY/phy_extern_ue.h
@@ -38,15 +38,8 @@ extern int number_of_cards;
 
 extern short conjugate[8],conjugate2[8];
 
-#ifndef OCP_FRAMEWORK
-extern PHY_VARS_UE ***PHY_vars_UE_g;
-extern LTE_DL_FRAME_PARMS *lte_frame_parms_g;
-#else
-#define MAX_UE 10
-#define MAX_eNB 20
 
-extern PHY_VARS_UE * PHY_vars_UE_g[MAX_UE][MAX_NUM_CCs];
-#endif
+extern PHY_VARS_UE ***PHY_vars_UE_g;
 
 extern short primary_synch0[144];
 extern short primary_synch1[144];
diff --git a/openair1/PHY/phy_vars.h b/openair1/PHY/phy_vars.h
index 897d826ae2..4cf029e968 100644
--- a/openair1/PHY/phy_vars.h
+++ b/openair1/PHY/phy_vars.h
@@ -41,20 +41,11 @@ int16_t *primary_synch2_time;
 #include "PHY/LTE_TRANSPORT/transport_vars.h"
 #include "PHY/MODULATION/modulation_vars.h"
 
-//PHY_VARS *PHY_vars;
-#ifndef OCP_FRAMEWORK
+
+
 PHY_VARS_UE ***PHY_vars_UE_g;
 RAN_CONTEXT_t RC;
 
-//PHY_VARS_eNB ***PHY_vars_eNB_g;
-//PHY_VARS_RN **PHY_vars_RN_g;
-LTE_DL_FRAME_PARMS *lte_frame_parms_g;
-#else
-PHY_VARS_UE * PHY_vars_UE_g[MAX_UE][MAX_NUM_CCs]={NULL};
-PHY_VARS_eNB * PHY_vars_eNB_g[MAX_eNB][MAX_NUM_CCs]={NULL};
-#endif
-
-
 unsigned short rev[2048],rev_times4[8192],rev_half[1024];
 unsigned short rev256[256],rev512[512],rev1024[1024],rev4096[4096],rev2048[2048],rev8192[8192];
 
diff --git a/openair1/PHY/phy_vars_nr_ue.h b/openair1/PHY/phy_vars_nr_ue.h
index 0e7e4f79d1..77163c0bc0 100644
--- a/openair1/PHY/phy_vars_nr_ue.h
+++ b/openair1/PHY/phy_vars_nr_ue.h
@@ -40,16 +40,10 @@ int16_t *primary_synch2_time;
 
 //#include "PHY/CODING/coding_vars.h"
 
-//PHY_VARS *PHY_vars;
-#ifndef OCP_FRAMEWORK
+
+
 PHY_VARS_NR_UE ***PHY_vars_UE_g;
 PHY_VARS_eNB ***PHY_vars_eNB_g;
-NR_DL_FRAME_PARMS *lte_frame_parms_g;
-#else
-PHY_VARS_NR_UE * PHY_vars_UE_g[MAX_UE][MAX_NUM_CCs]={NULL};
-
-#endif
-
 
 unsigned short rev[2048],rev_times4[8192],rev_half[1024];
 unsigned short rev256[256],rev512[512],rev1024[1024],rev4096[4096],rev2048[2048],rev8192[8192];
diff --git a/openair1/PHY/phy_vars_ue.h b/openair1/PHY/phy_vars_ue.h
index af3657ce2c..3e868d14cc 100644
--- a/openair1/PHY/phy_vars_ue.h
+++ b/openair1/PHY/phy_vars_ue.h
@@ -37,17 +37,7 @@ int16_t *primary_synch0_time;
 int16_t *primary_synch1_time;
 int16_t *primary_synch2_time;
 
-
-
-//PHY_VARS *PHY_vars;
-#ifndef OCP_FRAMEWORK
 PHY_VARS_UE ***PHY_vars_UE_g;
-LTE_DL_FRAME_PARMS *lte_frame_parms_g;
-#else
-PHY_VARS_UE * PHY_vars_UE_g[MAX_UE][MAX_NUM_CCs]={NULL};
-
-#endif
-
 
 unsigned short rev[2048],rev_times4[8192],rev_half[1024];
 unsigned short rev256[256],rev512[512],rev1024[1024],rev4096[4096],rev2048[2048],rev8192[8192];
diff --git a/openair1/PHY/thread_NR_UE.h b/openair1/PHY/thread_NR_UE.h
new file mode 100644
index 0000000000..c5db3e14d7
--- /dev/null
+++ b/openair1/PHY/thread_NR_UE.h
@@ -0,0 +1,74 @@
+#ifndef __thread_NR_UE__
+#define __thread_NR_UE__
+#include <pthread.h>
+#include <targets/ARCH/COMMON/common_lib.h>
+/// Context data structure for RX/TX portion of subframe processing
+typedef struct {
+  /// index of the current UE RX/TX proc
+  int                  proc_id;
+  /// Component Carrier index
+  uint8_t              CC_id;
+  /// timestamp transmitted to HW
+  openair0_timestamp timestamp_tx;
+  //#ifdef UE_NR_PHY_DEMO
+  /// NR TTI index within subframe_tx [0 .. ttis_per_subframe - 1] to act upon for transmission
+  int nr_tti_tx;
+  /// NR TTI index within subframe_rx [0 .. ttis_per_subframe - 1] to act upon for reception
+  int nr_tti_rx;
+  //#endif
+  /// subframe to act upon for transmission
+  int subframe_tx;
+  /// subframe to act upon for reception
+  int subframe_rx;
+  /// frame to act upon for transmission
+  int frame_tx;
+  /// frame to act upon for reception
+  int frame_rx;
+  int decoded_frame_rx;
+  /// internal This variable is protected by ref mutex_fep_slot1.
+  //int instance_cnt_slot0_dl_processing;
+  int instance_cnt_slot1_dl_processing;
+  /// pthread descriptor fep_slot1 thread
+  //pthread_t pthread_slot0_dl_processing;
+  pthread_t pthread_slot1_dl_processing;
+  /// pthread attributes for fep_slot1 processing thread
+  /// condition variable for UE fep_slot1 thread;
+  //pthread_cond_t cond_slot0_dl_processing;
+  pthread_cond_t cond_slot1_dl_processing;
+  /// mutex for UE synch thread
+  //pthread_mutex_t mutex_slot0_dl_processing;
+  pthread_mutex_t mutex_slot1_dl_processing;
+  //int instance_cnt_slot0_dl_processing;
+  int instance_cnt_dlsch_td;
+  /// pthread descriptor fep_slot1 thread
+  //pthread_t pthread_slot0_dl_processing;
+  pthread_t pthread_dlsch_td;
+  /// pthread attributes for fep_slot1 processing thread
+  /// condition variable for UE fep_slot1 thread;
+  //pthread_cond_t cond_slot0_dl_processing;
+  pthread_cond_t cond_dlsch_td;
+  /// mutex for UE synch thread
+  uint8_t chan_est_pilot0_slot1_available;
+  uint8_t chan_est_slot1_available;
+  uint8_t llr_slot1_available;
+  uint8_t dci_slot0_available;
+  uint8_t first_symbol_available;
+  uint8_t decoder_thread_available;
+  uint8_t decoder_main_available;
+  uint8_t decoder_switch;
+  int counter_decoder;
+  uint8_t channel_level;
+  int eNB_id;
+  int harq_pid;
+  int llr8_flag;
+  /// scheduling parameters for fep_slot1 thread
+  struct sched_param sched_param_fep_slot1;
+
+  int sub_frame_start;
+  int sub_frame_step;
+  unsigned long long gotIQs;
+  uint8_t decoder_thread_available1;
+  int dci_err_cnt;
+} UE_nr_rxtx_proc_t;
+
+#endif
diff --git a/openair1/SCHED/phy_procedures_lte_eNb.c b/openair1/SCHED/phy_procedures_lte_eNb.c
index 276006ec3b..9409e650a8 100644
--- a/openair1/SCHED/phy_procedures_lte_eNb.c
+++ b/openair1/SCHED/phy_procedures_lte_eNb.c
@@ -38,6 +38,7 @@
 #include "nfapi_interface.h"
 #include "fapi_l1.h"
 #include "common/utils/LOG/log.h"
+#include <common/utils/system.h>
 #include "common/utils/LOG/vcd_signal_dumper.h"
 
 #include "assertions.h"
@@ -1473,11 +1474,7 @@ void init_td_thread(PHY_VARS_eNB *eNB) {
   proc->tdp.eNB = eNB;
   proc->instance_cnt_td         = -1;
   
-  pthread_attr_init( &proc->attr_td);  
-  pthread_mutex_init( &proc->mutex_td, NULL);
-  pthread_cond_init( &proc->cond_td, NULL);
-  
-  pthread_create(&proc->pthread_td, &proc->attr_td, td_thread, (void*)&proc->tdp);
+  threadCreate(&proc->pthread_td, td_thread, (void*)&proc->tdp, "TD", -1, OAI_PRIORITY_RT);
 
 }
 void kill_td_thread(PHY_VARS_eNB *eNB) {
@@ -1501,12 +1498,10 @@ void init_te_thread(PHY_VARS_eNB *eNB) {
     proc->tep[i].eNB = eNB;
     proc->tep[i].instance_cnt_te         = -1;
       
-    pthread_mutex_init( &proc->tep[i].mutex_te, NULL);
-    pthread_cond_init( &proc->tep[i].cond_te, NULL);
-    pthread_attr_init( &proc->tep[i].attr_te);
-    
     LOG_I(PHY,"Creating te_thread %d\n",i);
-    pthread_create(&proc->tep[i].pthread_te, &proc->tep[i].attr_te, te_thread, (void*)&proc->tep[i]);
+    char txt[128];
+    sprintf(txt,"TE_%d", i); 
+    threadCreate(&proc->tep[i].pthread_te, te_thread, (void*)&proc->tep[i], txt, -1, OAI_PRIORITY_RT);
   }
 }
 void kill_te_thread(PHY_VARS_eNB *eNB) {
diff --git a/openair1/SCHED/ru_procedures.c b/openair1/SCHED/ru_procedures.c
index f30f09859c..2724567f4b 100644
--- a/openair1/SCHED/ru_procedures.c
+++ b/openair1/SCHED/ru_procedures.c
@@ -44,12 +44,11 @@
 
 
 #include "assertions.h"
+#include "common/utils/system.h"
 #include "msc.h"
 
 #include <time.h>
 
-#include "targets/RT/USER/rt_wrapper.h"
-
 extern int oai_exit;
 
 
@@ -131,17 +130,8 @@ static void *feptx_thread(void *param) {
 
   RU_t *ru = (RU_t *)param;
   RU_proc_t *proc  = &ru->proc;
-  cpu_set_t cpuset;
-  CPU_ZERO(&cpuset);
-  
-  thread_top_init("feptx_thread",1,85000,120000,500000);
-  pthread_setname_np( pthread_self(),"feptx processing");
-  LOG_I(PHY,"thread feptx created id=%ld\n", syscall(__NR_gettid));
-  //CPU_SET(6, &cpuset);
-  //pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
-  //wait_sync("feptx_thread");
-
   
+  LOG_I(PHY,"thread feptx created \n");
 
   while (!oai_exit) {
 
@@ -162,8 +152,6 @@ static void *feptx_thread(void *param) {
     }*/
   }
 
-
-
   return(NULL);
 }
 
@@ -438,16 +426,6 @@ static void *fep_thread(void *param) {
   RU_t *ru = (RU_t *)param;
   RU_proc_t *proc  = &ru->proc;
 
-  thread_top_init("fep_thread",1,100000,120000,5000000);
-  pthread_setname_np( pthread_self(),"fep processing");
-  LOG_I(PHY,"thread fep created id=%ld\n", syscall(__NR_gettid));
-
-  cpu_set_t cpuset;
-  CPU_ZERO(&cpuset);
-  //CPU_SET(2, &cpuset);
-  //pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
-  //wait_sync("fep_thread");
-
   while (!oai_exit) {
 
     if (wait_on_condition(&proc->mutex_fep,&proc->cond_fep,&proc->instance_cnt_fep,"fep thread")<0) break; 
@@ -483,7 +461,7 @@ void init_feptx_thread(RU_t *ru,pthread_attr_t *attr_feptx) {
   pthread_mutex_init( &proc->mutex_feptx, NULL);
   pthread_cond_init( &proc->cond_feptx, NULL);
 
-  pthread_create(&proc->pthread_feptx, attr_feptx, feptx_thread, (void*)ru);
+  threadCreate(&proc->pthread_feptx, feptx_thread, (void*)ru, "feptx", -1, OAI_PRIORITY_RT);
 
 
 }
@@ -497,7 +475,7 @@ void init_fep_thread(RU_t *ru,pthread_attr_t *attr_fep) {
   pthread_mutex_init( &proc->mutex_fep, NULL);
   pthread_cond_init( &proc->cond_fep, NULL);
 
-  pthread_create(&proc->pthread_fep, attr_fep, fep_thread, (void*)ru);
+  threadCreate(&proc->pthread_fep, fep_thread, (void*)ru, "fep", -1, OAI_PRIORITY_RT);
 
 
 }
diff --git a/openair1/SCHED_NR/fapi_nr_l1.h b/openair1/SCHED_NR/fapi_nr_l1.h
index 66eb0fada7..71ef6039f3 100644
--- a/openair1/SCHED_NR/fapi_nr_l1.h
+++ b/openair1/SCHED_NR/fapi_nr_l1.h
@@ -32,9 +32,6 @@
 
 #include "PHY/defs_gNB.h"
 #include "PHY/phy_extern.h"
-#include "PHY/LTE_TRANSPORT/transport_proto.h"
-#include "SCHED/sched_eNB.h"
-#include "SCHED/sched_common.h"
 #include "SCHED_NR/sched_nr.h"
 #include "nfapi_nr_interface.h"
 
diff --git a/openair1/SCHED_NR/nr_ru_procedures.c b/openair1/SCHED_NR/nr_ru_procedures.c
index 65dfb64734..653e9632b5 100644
--- a/openair1/SCHED_NR/nr_ru_procedures.c
+++ b/openair1/SCHED_NR/nr_ru_procedures.c
@@ -41,6 +41,7 @@
 #include "LAYER2/MAC/mac_extern.h"
 #include "LAYER2/MAC/mac.h"
 #include "common/utils/LOG/log.h"
+#include "common/utils/system.h"
 #include "common/utils/LOG/vcd_signal_dumper.h"
 
 #include "T.h"
@@ -49,9 +50,6 @@
 #include "msc.h"
 
 #include <time.h>
-
-#include "targets/RT/USER/rt_wrapper.h"
-
 // RU OFDM Modulator gNodeB
 
 extern openair0_config_t openair0_cfg[MAX_CARDS];
@@ -179,7 +177,6 @@ static void *nr_feptx_thread(void *param) {
   RU_t *ru = (RU_t *)param;
   RU_proc_t *proc  = &ru->proc;
 
-  thread_top_init("nr_feptx_thread",0,870000,1000000,1000000);
 
   while (!oai_exit) {
 
@@ -196,7 +193,7 @@ static void *nr_feptx_thread(void *param) {
   return(NULL);
 }
 
-void nr_init_feptx_thread(RU_t *ru,pthread_attr_t *attr_feptx) {
+void nr_init_feptx_thread(RU_t *ru) {
 
   RU_proc_t *proc = &ru->proc;
 
@@ -205,7 +202,7 @@ void nr_init_feptx_thread(RU_t *ru,pthread_attr_t *attr_feptx) {
   pthread_mutex_init( &proc->mutex_feptx, NULL);
   pthread_cond_init( &proc->cond_feptx, NULL);
 
-  pthread_create(&proc->pthread_feptx, attr_feptx, nr_feptx_thread, (void*)ru);
+  threadCreate(&proc->pthread_feptx, nr_feptx_thread, (void*)ru, "feptx", -1, OAI_PRIORITY_RT);
 
 
 }
diff --git a/openair1/SCHED_NR/phy_procedures_nr_gNB.c b/openair1/SCHED_NR/phy_procedures_nr_gNB.c
index eadd294fd3..aeda4b3549 100644
--- a/openair1/SCHED_NR/phy_procedures_nr_gNB.c
+++ b/openair1/SCHED_NR/phy_procedures_nr_gNB.c
@@ -30,6 +30,7 @@
 #include "SCHED/fapi_l1.h"
 #include "common/utils/LOG/log.h"
 #include "common/utils/LOG/vcd_signal_dumper.h"
+#include "PHY/INIT/phy_init.h"
 
 #include "T.h"
 
@@ -76,37 +77,7 @@ int return_ssb_type(nfapi_config_request_t *cfg)
 
 }*/
 
-// First SSB starting symbol candidate is used and type B is chosen for 30kHz SCS
-int nr_get_ssb_start_symbol(nfapi_nr_config_request_t *cfg, NR_DL_FRAME_PARMS *fp) {
-  int mu = cfg->subframe_config.numerology_index_mu.value;
-  int symbol = 0;
 
-  switch(mu) {
-    case NR_MU_0:
-      symbol = 2;
-      break;
-
-    case NR_MU_1: // case B
-      symbol = 4;
-      break;
-
-    case NR_MU_3:
-      symbol = 4;
-      break;
-
-    case NR_MU_4:
-      symbol = 8;
-      break;
-
-    default:
-      AssertFatal(0==1, "Invalid numerology index %d for the synchronization block\n", mu);
-  }
-
-  if (cfg->sch_config.half_frame_index.value)
-    symbol += (5 * fp->symbols_per_slot * fp->slots_per_subframe);
-
-  return symbol;
-}
 
 void nr_set_ssb_first_subcarrier(nfapi_nr_config_request_t *cfg, NR_DL_FRAME_PARMS *fp) {
   fp->ssb_start_subcarrier = (12 * cfg->sch_config.n_ssb_crb.value + cfg->sch_config.ssb_subcarrier_offset.value)/(1<<cfg->subframe_config.numerology_index_mu.value);
@@ -118,36 +89,43 @@ void nr_common_signal_procedures (PHY_VARS_gNB *gNB,int frame, int slot) {
   nfapi_nr_config_request_t *cfg = &gNB->gNB_config;
   int **txdataF = gNB->common_vars.txdataF;
   uint8_t *pbch_pdu=&gNB->pbch_pdu[0];
-  int ss_slot = (cfg->sch_config.half_frame_index.value)? 10 : 0;
-  uint8_t Lmax, ssb_index=0, n_hf=0;
+  uint8_t ssb_index, n_hf;
+  int ssb_start_symbol, rel_slot;
+
+  n_hf = cfg->sch_config.half_frame_index.value;
+  // to set a effective slot number between 0 to 9 in the half frame where the SSB is supposed to be
+  rel_slot = (n_hf)? (slot-10) : slot; 
+
+  
   LOG_D(PHY,"common_signal_procedures: frame %d, slot %d\n",frame,slot);
-  int ssb_start_symbol = nr_get_ssb_start_symbol(cfg, fp);
-  nr_set_ssb_first_subcarrier(cfg, fp);
-  Lmax = (fp->dl_CarrierFreq < 3e9)? 4:8;
 
-  if (slot == ss_slot) {
-    // Current implementation is based on SSB in first half frame, first candidate
-    LOG_D(PHY,"SS TX: frame %d, slot %d, start_symbol %d\n",frame,slot, ssb_start_symbol);
-    nr_generate_pss(gNB->d_pss, txdataF[0], AMP, ssb_start_symbol, cfg, fp);
-    nr_generate_sss(gNB->d_sss, txdataF[0], AMP, ssb_start_symbol, cfg, fp);
+  if(rel_slot<10 && rel_slot>=0)  {
+     for (int i=0; i<2; i++)  {  // max two SSB per frame
+     
+	ssb_index = i + 2*rel_slot; // computing the ssb_index
+	if ((fp->L_ssb >> ssb_index) & 0x01)  { // generating the ssb only if the bit of L_ssb at current ssb index is 1
+	
+	  int ssb_start_symbol_abs = nr_get_ssb_start_symbol(fp, ssb_index, n_hf); // computing the starting symbol for current ssb
+	  ssb_start_symbol = ssb_start_symbol_abs % 14;  // start symbol wrt slot
 
-    if (!(frame&7)) {
-      LOG_D(PHY,"%d.%d : pbch_configured %d\n",frame,slot,gNB->pbch_configured);
+	  nr_set_ssb_first_subcarrier(cfg, fp);  // setting the first subcarrier
+	  
+    	  LOG_D(PHY,"SS TX: frame %d, slot %d, start_symbol %d\n",frame,slot, ssb_start_symbol);
+    	  nr_generate_pss(gNB->d_pss, txdataF[0], AMP, ssb_start_symbol, cfg, fp);
+    	  nr_generate_sss(gNB->d_sss, txdataF[0], AMP, ssb_start_symbol, cfg, fp);
 
-      if (gNB->pbch_configured != 1)return;
+	  nr_generate_pbch_dmrs(gNB->nr_gold_pbch_dmrs[n_hf][ssb_index],txdataF[0], AMP, ssb_start_symbol, cfg, fp);
 
-      gNB->pbch_configured = 0;
-    }
-
-    nr_generate_pbch_dmrs(gNB->nr_gold_pbch_dmrs[n_hf][ssb_index],txdataF[0], AMP, ssb_start_symbol, cfg, fp);
-    nr_generate_pbch(&gNB->pbch,
-                     pbch_pdu,
-                     gNB->nr_pbch_interleaver,
-                     txdataF[0],
-                     AMP,
-                     ssb_start_symbol,
-                     n_hf,Lmax,ssb_index,
-                     frame, cfg, fp);
+    	  nr_generate_pbch(&gNB->pbch,
+                      pbch_pdu,
+                      gNB->nr_pbch_interleaver,
+                      txdataF[0],
+                      AMP,
+                      ssb_start_symbol,
+                      n_hf,fp->Lmax,ssb_index,
+                      frame, cfg, fp);
+	}
+     }
   }
 }
 
diff --git a/openair1/SCHED_NR/sched_nr.h b/openair1/SCHED_NR/sched_nr.h
index a120b8c140..7c5a5d0146 100644
--- a/openair1/SCHED_NR/sched_nr.h
+++ b/openair1/SCHED_NR/sched_nr.h
@@ -38,10 +38,13 @@ nr_slot_t nr_slot_select (nfapi_nr_config_request_t *cfg, unsigned char slot);
 void nr_set_ssb_first_subcarrier(nfapi_nr_config_request_t *cfg, NR_DL_FRAME_PARMS *fp);
 void phy_procedures_gNB_TX(PHY_VARS_gNB *gNB, gNB_L1_rxtx_proc_t *proc, int do_meas);
 void nr_common_signal_procedures (PHY_VARS_gNB *gNB,int frame, int slot);
-void nr_init_feptx_thread(RU_t *ru,pthread_attr_t *attr_feptx);
+void nr_init_feptx_thread(RU_t *ru);
 void nr_feptx_ofdm(RU_t *ru);
 void nr_feptx_ofdm_2thread(RU_t *ru);
 void nr_feptx0(RU_t *ru,int first_symbol, int num_symbols);
+void fep_full(RU_t *ru);
+void feptx_prec(RU_t *ru);
+int nr_phy_init_RU(RU_t *ru);
 
 void nr_configure_css_dci_initial(nfapi_nr_dl_config_pdcch_parameters_rel15_t* pdcch_params,
 				  nr_scs_e scs_common,
diff --git a/openair1/SCHED_NR_UE/fapi_nr_ue_l1.c b/openair1/SCHED_NR_UE/fapi_nr_ue_l1.c
index ca30ab1cec..0432ded427 100644
--- a/openair1/SCHED_NR_UE/fapi_nr_ue_l1.c
+++ b/openair1/SCHED_NR_UE/fapi_nr_ue_l1.c
@@ -55,8 +55,8 @@ int8_t nr_ue_scheduled_response(nr_scheduled_response_t *scheduled_response){
     // Note: we have to handle the thread IDs for this. To be revisited completely.
     NR_UE_PDCCH *pdcch_vars2 = PHY_vars_UE_g[module_id][cc_id]->pdcch_vars[thread_id][0];
     NR_UE_DLSCH_t *dlsch0 = PHY_vars_UE_g[module_id][cc_id]->dlsch[thread_id][0][0];
-    NR_UE_ULSCH_t *ulsch0 = PHY_vars_UE_g[module_id][cc_id]->ulsch[0];
-    NR_DL_FRAME_PARMS frame_parms = PHY_vars_UE_g[module_id][cc_id]->frame_parms;
+    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];
         
     //        PUCCH_ConfigCommon_nr_t    *pucch_config_common = PHY_vars_UE_g[module_id][cc_id]->pucch_config_common_nr[0];
@@ -106,32 +106,27 @@ int8_t nr_ue_scheduled_response(nr_scheduled_response_t *scheduled_response){
 	  uint8_t current_harq_pid = dlsch_config_pdu->harq_process_nbr;
 	  dlsch0->current_harq_pid = current_harq_pid;
 	  dlsch0->active = 1;
+	  dlsch0->rnti = dl_config->dl_config_list[i].dlsch_config_pdu.rnti;
                     
 	  //dlsch0->harq_processes[0]->mcs = &dlsch_config_pdu->mcs;
                     
-	  NR_DL_UE_HARQ_t dlsch0_harq = *(dlsch0->harq_processes[current_harq_pid]);
+	  NR_DL_UE_HARQ_t *dlsch0_harq = dlsch0->harq_processes[current_harq_pid];
 
                     
-	  //dlsch0->harq_processes[current_harq_pid]->nb_rb = dlsch_config_pdu->number_rbs;
-                    
-	  dlsch0_harq.nb_rb = dlsch_config_pdu->number_rbs;
-	  dlsch0_harq.start_rb = dlsch_config_pdu->start_rb;
-	  dlsch0_harq.nb_symbols = dlsch_config_pdu->number_symbols;
-	  dlsch0_harq.start_symbol = dlsch_config_pdu->start_symbol;
-	  dlsch0_harq.mcs = dlsch_config_pdu->mcs;
-	  dlsch0_harq.DCINdi = dlsch_config_pdu->ndi;
-	  dlsch0_harq.rvidx = dlsch_config_pdu->rv;
+	  dlsch0_harq->nb_rb = dlsch_config_pdu->number_rbs;
+	  dlsch0_harq->start_rb = dlsch_config_pdu->start_rb;
+	  dlsch0_harq->nb_symbols = dlsch_config_pdu->number_symbols;
+	  dlsch0_harq->start_symbol = dlsch_config_pdu->start_symbol;
+	  dlsch0_harq->mcs = dlsch_config_pdu->mcs;
+	  dlsch0_harq->DCINdi = dlsch_config_pdu->ndi;
+	  dlsch0_harq->rvidx = dlsch_config_pdu->rv;
 	  dlsch0->g_pucch = dlsch_config_pdu->accumulated_delta_PUCCH;
-	  dlsch0_harq.harq_ack.pucch_resource_indicator = dlsch_config_pdu->pucch_resource_id;
-	  dlsch0_harq.harq_ack.slot_for_feedback_ack = dlsch_config_pdu->pdsch_to_harq_feedback_time_ind;
-	  printf(">>>> \tdlsch0->g_pucch=%d\tdlsch0_harq.mcs=%d\n",dlsch0->g_pucch,dlsch0_harq.mcs);
-	  //for (int j = 0 ; j<1000; j++) printf("\nk = %d",j);
+	  dlsch0_harq->harq_ack.pucch_resource_indicator = dlsch_config_pdu->pucch_resource_id;
+	  dlsch0_harq->harq_ack.slot_for_feedback_ack = dlsch_config_pdu->pdsch_to_harq_feedback_time_ind;
+	  dlsch0_harq->Nl=1;
+	  dlsch0_harq->status = ACTIVE;
+	  LOG_D(MAC,">>>> \tdlsch0->g_pucch=%d\tdlsch0_harq.mcs=%d\n",dlsch0->g_pucch,dlsch0_harq->mcs);
 
-#if 0
-	  dlsch0->harq_processes[current_harq_pid]->mcs = dlsch_config_pdu->mcs;
-	  dlsch0->g_pucch = dlsch_config_pdu->accumulated_delta_PUCCH;
-	  //pdlsch0->rnti             = rnti;
-#endif
 	}
       }
     }else{
@@ -193,11 +188,11 @@ int8_t nr_ue_scheduled_response(nr_scheduled_response_t *scheduled_response){
 	if(ul_config->ul_config_list[i].pdu_type == FAPI_NR_UL_CONFIG_TYPE_PRACH){
 	  // prach config pdu
 	  fapi_nr_ul_config_prach_pdu *prach_config_pdu = &ul_config->ul_config_list[i].prach_config_pdu;
-	  frame_parms.prach_config_common.rootSequenceIndex = prach_config_pdu->root_sequence_index;
+	  /*frame_parms.prach_config_common.rootSequenceIndex = prach_config_pdu->root_sequence_index;
 	  frame_parms.prach_config_common.prach_ConfigInfo.prach_ConfigIndex = prach_config_pdu->prach_configuration_index;
 	  frame_parms.prach_config_common.prach_ConfigInfo.zeroCorrelationZoneConfig = prach_config_pdu->zero_correlation_zone_config;
 	  frame_parms.prach_config_common.prach_ConfigInfo.highSpeedFlag = prach_config_pdu->restrictedset_config;
-	  frame_parms.prach_config_common.prach_ConfigInfo.prach_FreqOffset = prach_config_pdu->prach_freq_offset;
+	  frame_parms.prach_config_common.prach_ConfigInfo.prach_FreqOffset = prach_config_pdu->prach_freq_offset;*/
 	  prach_resources->ra_PreambleIndex = prach_config_pdu->preamble_index;
 	}
       }
@@ -220,19 +215,18 @@ int8_t nr_ue_phy_config_request(nr_phy_config_t *phy_config){
 
   if(phy_config != NULL){
     if(phy_config->config_req.config_mask & FAPI_NR_CONFIG_REQUEST_MASK_PBCH){
-      printf("[L1][IF module][PHY CONFIG]\n");
-      printf("subcarrier spacing:          %d\n", phy_config->config_req.pbch_config.subcarrier_spacing_common);
-      printf("ssb carrier offset:          %d\n", phy_config->config_req.pbch_config.ssb_subcarrier_offset);
-      printf("dmrs type A position:        %d\n", phy_config->config_req.pbch_config.dmrs_type_a_position);
-      printf("pdcch config sib1:           %d\n", phy_config->config_req.pbch_config.pdcch_config_sib1);
-      printf("cell barred:                 %d\n", phy_config->config_req.pbch_config.cell_barred);
-      printf("intra frequency reselection: %d\n", phy_config->config_req.pbch_config.intra_frequency_reselection);
-      printf("system frame number:         %d\n", phy_config->config_req.pbch_config.system_frame_number);
-      printf("ssb index:                   %d\n", phy_config->config_req.pbch_config.ssb_index);
-      printf("half frame bit:              %d\n", phy_config->config_req.pbch_config.half_frame_bit);
-      printf("-------------------------------\n");
+      LOG_I(MAC,"[L1][IF module][PHY CONFIG]\n");
+      LOG_I(MAC,"subcarrier spacing:          %d\n", phy_config->config_req.pbch_config.subcarrier_spacing_common);
+      LOG_I(MAC,"ssb carrier offset:          %d\n", phy_config->config_req.pbch_config.ssb_subcarrier_offset);
+      LOG_I(MAC,"dmrs type A position:        %d\n", phy_config->config_req.pbch_config.dmrs_type_a_position);
+      LOG_I(MAC,"pdcch config sib1:           %d\n", phy_config->config_req.pbch_config.pdcch_config_sib1);
+      LOG_I(MAC,"cell barred:                 %d\n", phy_config->config_req.pbch_config.cell_barred);
+      LOG_I(MAC,"intra frequency reselection: %d\n", phy_config->config_req.pbch_config.intra_frequency_reselection);
+      LOG_I(MAC,"system frame number:         %d\n", phy_config->config_req.pbch_config.system_frame_number);
+      LOG_I(MAC,"ssb index:                   %d\n", phy_config->config_req.pbch_config.ssb_index);
+      LOG_I(MAC,"half frame bit:              %d\n", phy_config->config_req.pbch_config.half_frame_bit);
+      LOG_I(MAC,"-------------------------------\n");
 
-      PHY_vars_UE_g[0][0]->proc.proc_rxtx[0].frame_rx = phy_config->config_req.pbch_config.system_frame_number;
     }
         
     if(phy_config->config_req.config_mask & FAPI_NR_CONFIG_REQUEST_MASK_DL_BWP_COMMON){
@@ -252,7 +246,7 @@ int8_t nr_ue_phy_config_request(nr_phy_config_t *phy_config){
     }
   }
     
-
+  
 
   return 0;
 }
diff --git a/openair1/SCHED_NR_UE/harq_nr.c b/openair1/SCHED_NR_UE/harq_nr.c
index 23d828ec93..31dcfcacbe 100644
--- a/openair1/SCHED_NR_UE/harq_nr.c
+++ b/openair1/SCHED_NR_UE/harq_nr.c
@@ -150,7 +150,7 @@ void get_dci_info_for_harq(PHY_VARS_NR_UE *ue, NR_DCI_INFO_EXTRACTED_t *nr_dci_i
 *
 *********************************************************************/
 
-void config_uplink_harq_process(PHY_VARS_NR_UE *ue, int gNB_id, uint8_t number_harq_processes_pusch)
+void config_uplink_harq_process(PHY_VARS_NR_UE *ue, int gNB_id, int thread_id, int code_word_idx, uint8_t number_harq_processes_pusch)
 {
   NR_UE_ULSCH_t *ulsch;
 
@@ -160,7 +160,7 @@ void config_uplink_harq_process(PHY_VARS_NR_UE *ue, int gNB_id, uint8_t number_h
 
     memset(ulsch,0,sizeof(NR_UE_ULSCH_t));
 
-    ue->ulsch[gNB_id] = ulsch;
+    ue->ulsch[thread_id][gNB_id][code_word_idx] = ulsch;
   }
   else {
     LOG_E(PHY, "Fatal memory allocation problem at line %d in function %s of file %s \n", __LINE__ , __func__, __FILE__);
@@ -185,7 +185,7 @@ void config_uplink_harq_process(PHY_VARS_NR_UE *ue, int gNB_id, uint8_t number_h
   }
 
   for (int slot_tx = 0; slot_tx < NR_MAX_SLOTS_PER_FRAME; slot_tx++) {
-    ue->ulsch[gNB_id]->harq_process_id[slot_tx] = NR_MAX_HARQ_PROCESSES;
+    ue->ulsch[thread_id][gNB_id][code_word_idx]->harq_process_id[slot_tx] = NR_MAX_HARQ_PROCESSES;
   }
 }
 
@@ -202,9 +202,9 @@ void config_uplink_harq_process(PHY_VARS_NR_UE *ue, int gNB_id, uint8_t number_h
 *
 *********************************************************************/
 
-void release_uplink_harq_process(PHY_VARS_NR_UE *ue, int gNB_id)
+void release_uplink_harq_process(PHY_VARS_NR_UE *ue, int gNB_id, int thread_id, int code_word_idx)
 {
-  NR_UE_ULSCH_t *ulsch = ue->ulsch[gNB_id];
+  NR_UE_ULSCH_t *ulsch = ue->ulsch[thread_id][gNB_id][code_word_idx];
 
   for (int process_id = 0; process_id < ulsch->number_harq_processes_for_pusch; process_id++) {
 
@@ -215,7 +215,7 @@ void release_uplink_harq_process(PHY_VARS_NR_UE *ue, int gNB_id)
 
   free16(ulsch, sizeof(NR_UE_ULSCH_t));
 
-  ue->ulsch[gNB_id] = NULL;
+  ue->ulsch[thread_id][gNB_id][code_word_idx] = NULL;
 }
 
 /*******************************************************************
diff --git a/openair1/SCHED_NR_UE/harq_nr.h b/openair1/SCHED_NR_UE/harq_nr.h
index 2d3e87ddab..ee6e8625b0 100644
--- a/openair1/SCHED_NR_UE/harq_nr.h
+++ b/openair1/SCHED_NR_UE/harq_nr.h
@@ -83,17 +83,21 @@ void get_dci_info_for_harq(PHY_VARS_NR_UE *ue, NR_DCI_INFO_EXTRACTED_t *nr_dci_i
 /** \brief This function configures uplink HARQ context
     @param PHY_VARS_NR_UE ue context
     @param gNB_id gNodeB identifier
+    @param thread_id RXTX thread index
+    @param code_word_idx code word index
     @param number_harq_processes_pusch maximum number of uplink HARQ processes
     @returns none */
 
-void config_uplink_harq_process(PHY_VARS_NR_UE *ue, int gNB_id, uint8_t number_harq_processes_pusch);
+void config_uplink_harq_process(PHY_VARS_NR_UE *ue, int gNB_id, int thread_id, int code_word_idx, uint8_t number_harq_processes_pusch);
 
 /** \brief This function releases uplink HARQ context
     @param PHY_VARS_NR_UE ue context
     @param gNB_id gNodeB identifier
+    @param thread_id RXTX thread index
+    @param code_word_idx code word index
     @returns none */
 
-void release_uplink_harq_process(PHY_VARS_NR_UE *ue, int gNB_id);
+void release_uplink_harq_process(PHY_VARS_NR_UE *ue, int gNB_id, int thread_id, int code_word_idx);
 
 /** \brief This function stores slot for transmission in HARQ context
     @param ulsch uplink context
diff --git a/openair1/SCHED_NR_UE/phy_procedures_nr_ue.c b/openair1/SCHED_NR_UE/phy_procedures_nr_ue.c
index 1a631000f5..0a087d5b8b 100644
--- a/openair1/SCHED_NR_UE/phy_procedures_nr_ue.c
+++ b/openair1/SCHED_NR_UE/phy_procedures_nr_ue.c
@@ -119,11 +119,12 @@ uint8_t nr_dci_decoding_procedure(int s,
                                   format_found_t *format_found,
                                   uint16_t crc_scrambled_values[TOTAL_NBR_SCRAMBLED_VALUES]);
 
+/*
 int nr_generate_ue_ul_dlsch_params_from_dci(PHY_VARS_NR_UE *ue,
 					    uint8_t eNB_id,
 					    int frame,
 					    uint8_t nr_tti_rx,
-					    uint32_t dci_pdu[4],
+					    uint64_t dci_pdu[2],
 					    uint16_t rnti,
 					    uint8_t dci_length,
 					    NR_DCI_format_t dci_format,
@@ -139,7 +140,7 @@ int nr_generate_ue_ul_dlsch_params_from_dci(PHY_VARS_NR_UE *ue,
 					    uint16_t n_RB_DLBWP,
 					    uint16_t crc_scrambled_values[TOTAL_NBR_SCRAMBLED_VALUES],
 					    NR_DCI_INFO_EXTRACTED_t *nr_dci_info_extracted);
-
+*/
 
 #if defined(EXMIMO) || defined(OAI_USRP) || defined(OAI_BLADERF) || defined(OAI_LMSSDR) || defined(OAI_ADRV9371_ZC706)
 extern uint32_t downlink_frequency[MAX_NUM_CCs][4];
@@ -1264,37 +1265,6 @@ uint16_t nr_get_n1_pucch(PHY_VARS_NR_UE *ue,
 }
 
 
-#ifdef EMOS
-
-void phy_procedures_emos_UE_TX(uint8_t next_slot,uint8_t eNB_id) {
-  uint8_t harq_pid;
-
-
-  if (next_slot%2==0) {
-    // get harq_pid from nr_tti_tx relationship
-    harq_pid = nr_subframe2harq_pid(&ue->frame_parms,ue->frame,(next_slot>>1));
-    if (harq_pid==255) {
-      LOG_E(PHY,"[UE%d] Frame %d : FATAL ERROR: illegal harq_pid, returning\n",
-	    0,ue->frame);
-      return;
-    }
-
-    if (ulsch[eNB_id]->harq_processes[harq_pid]->subframe_scheduling_flag == 1) {
-      emos_dump_UE.uci_cnt[next_slot>>1] = 1;
-      memcpy(emos_dump_UE.UCI_data[0][next_slot>>1].o,ulsch[eNB_id]->o,MAX_CQI_BITS*sizeof(char));
-      emos_dump_UE.UCI_data[0][next_slot>>1].O = ulsch[eNB_id]->O;
-      memcpy(emos_dump_UE.UCI_data[0][next_slot>>1].o_RI,ulsch[eNB_id]->o_RI,2*sizeof(char));
-      emos_dump_UE.UCI_data[0][next_slot>>1].O_RI = ulsch[eNB_id]->O_RI;
-      memcpy(emos_dump_UE.UCI_data[0][next_slot>>1].o_ACK,ulsch[eNB_id]->o_ACK,4*sizeof(char));
-      emos_dump_UE.UCI_data[0][next_slot>>1].O_ACK = ulsch[eNB_id]->harq_processes[harq_pid]->O_ACK;
-    }
-    else {
-      emos_dump_UE.uci_cnt[next_slot>>1] = 0;
-    }
-  }
-}
-
-#endif
 
 void ulsch_common_procedures(PHY_VARS_NR_UE *ue, UE_nr_rxtx_proc_t *proc, uint8_t empty_subframe) {
 
@@ -1590,25 +1560,26 @@ VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDUR
 
 #endif
 
-void ue_ulsch_uespec_procedures(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eNB_id,uint8_t abstraction_flag) {
-
-  int harq_pid;
-  int frame_tx=proc->frame_tx;
+void ue_ulsch_uespec_procedures(PHY_VARS_NR_UE *ue,
+								UE_nr_rxtx_proc_t *proc,
+								uint8_t eNB_id,
+								uint8_t abstraction_flag)
+{
   int nr_tti_tx=proc->nr_tti_tx;
-  unsigned int input_buffer_length;
-  int i;
-  int aa;
-  int tx_amp;
+
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_UE_TX_ULSCH_UESPEC,VCD_FUNCTION_IN);
 
   /* reset harq for tx of current rx slot because it is sure that transmission has already been achieved for this slot */
-  set_tx_harq_id(ue->ulsch[eNB_id], NR_MAX_HARQ_PROCESSES, proc->nr_tti_rx);
-
-  /* get harq pid related to this next tx slot */
-  harq_pid = get_tx_harq_id(ue->ulsch[eNB_id], nr_tti_tx);
+  set_tx_harq_id(ue->ulsch[ue->current_thread_id[nr_tti_tx]][eNB_id][0], NR_MAX_HARQ_PROCESSES, proc->nr_tti_rx);
 
 #if 0
+  int frame_tx=proc->frame_tx;
+  int harq_pid;
+  /* get harq pid related to this next tx slot */
+  harq_pid = get_tx_harq_id(ue->ulsch[ue->current_thread_id[nr_tti_tx]][eNB_id][0], nr_tti_tx);
 
+  int tx_amp;
+  unsigned int input_buffer_length;
   int Mod_id = ue->Mod_id;
   int CC_id = ue->CC_id;
   uint8_t Msg3_flag=0;
@@ -1629,9 +1600,9 @@ void ue_ulsch_uespec_procedures(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8
       ue->ulsch[eNB_id]->harq_processes[harq_pid]->subframe_scheduling_flag = 1;
 
       if (ue->ulsch[eNB_id]->harq_processes[harq_pid]->round==0)
-	generate_ue_ulsch_params_from_rar(ue,
-					  proc,
-					  eNB_id);
+    	  generate_ue_ulsch_params_from_rar(ue,
+    			                            proc,
+											eNB_id);
 
       ue->ulsch[eNB_id]->power_offset = 14;
       LOG_D(PHY,"[UE  %d][RAPROC] Frame %d: Setting Msg3_flag in nr_tti_rx %d, for harq_pid %d\n",
@@ -1894,7 +1865,7 @@ void ue_ulsch_uespec_procedures(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8
 #ifdef DEBUG_ULSCH
     LOG_D(PHY,"[UE] Frame %d, nr_tti_rx %d : ULSCH SDU (TX harq_pid %d)  (%d bytes) : \n",frame_tx,nr_tti_tx,harq_pid, ue->ulsch[eNB_id]->harq_processes[harq_pid]->TBS>>3);
 
-    for (i=0; i<ue->ulsch[eNB_id]->harq_processes[harq_pid]->TBS>>3; i++)
+    for (int i=0; i<ue->ulsch[eNB_id]->harq_processes[harq_pid]->TBS>>3; i++)
       LOG_T(PHY,"%x.",ulsch_input_buffer[i]);
 
     LOG_T(PHY,"\n");
@@ -1904,7 +1875,7 @@ void ue_ulsch_uespec_procedures(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8
   else {
     unsigned int taus(void);
 
-    for (i=0; i<input_buffer_length; i++)
+    for (int i=0; i<input_buffer_length; i++)
       ulsch_input_buffer[i]= (uint8_t)(taus()&0xff);
 
   }
@@ -1986,7 +1957,7 @@ if (abstraction_flag == 0) {
 		   nr_tti_tx,
 		   &ue->frame_parms,
 		   ue->ulsch[eNB_id]);
-  for (aa=0; aa<1/*frame_parms->nb_antennas_tx*/; aa++)
+  for (int aa=0; aa<1/*frame_parms->nb_antennas_tx*/; aa++)
     generate_drs_pusch(ue,
 		       proc,
 		       eNB_id,
@@ -2500,8 +2471,10 @@ void phy_procedures_UE_TX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eNB
   unsigned int aa;
   uint8_t isSubframeSRS;
 
+  /*
   uint8_t next1_thread_id = ue->current_thread_id[proc->nr_tti_rx]== (RX_NB_TH-1) ? 0:(ue->current_thread_id[proc->nr_tti_rx]+1);
   uint8_t next2_thread_id = next1_thread_id== (RX_NB_TH-1) ? 0:(next1_thread_id+1);
+  */
 
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_UE_TX,VCD_FUNCTION_IN);
 
@@ -2637,6 +2610,7 @@ void phy_procedures_UE_TX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eNB
 		   ue->ulsch[eNB_id]->o_ACK,
 		   &N_bundled,
 		   0);
+      /*
       nr_reset_ack(&ue->frame_parms,
 		   ue->dlsch[next1_thread_id][eNB_id][0]->harq_ack,
 		   nr_tti_tx,
@@ -2651,6 +2625,7 @@ void phy_procedures_UE_TX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eNB
 		   ue->ulsch[eNB_id]->o_ACK,
 		   &N_bundled,
 		   0);
+      */
     }
 
   if (ue->dlsch_SI[eNB_id] != NULL)
@@ -2696,22 +2671,18 @@ void phy_procedures_UE_S_TX(PHY_VARS_NR_UE *ue,uint8_t eNB_id,uint8_t abstractio
 
 #endif 
 
-void nr_ue_measurement_procedures(
-				  uint16_t l,    // symbol index of each slot [0..6]
-				  PHY_VARS_NR_UE *ue,
-				  UE_nr_rxtx_proc_t *proc, 
-				  uint8_t eNB_id,
-				  uint16_t slot, // slot index of each radio frame [0..19]
-				  runmode_t mode)
+void nr_ue_measurement_procedures(uint16_t l,    // symbol index of each slot [0..6]
+								  PHY_VARS_NR_UE *ue,
+								  UE_nr_rxtx_proc_t *proc,
+								  uint8_t eNB_id,
+								  uint16_t slot, // slot index of each radio frame [0..19]
+								  runmode_t mode)
 {
-
   LOG_D(PHY,"ue_measurement_procedures l %u Ncp %d\n",l,ue->frame_parms.Ncp);
 
-  NR_DL_FRAME_PARMS *frame_parms=&ue->frame_parms;
-
-  int nr_tti_rx = proc->nr_tti_rx;
-
 #if 0
+  NR_DL_FRAME_PARMS *frame_parms=&ue->frame_parms;
+  int nr_tti_rx = proc->nr_tti_rx;
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_MEASUREMENT_PROCEDURES, VCD_FUNCTION_IN);
 
   if (l==0) {
@@ -2760,129 +2731,11 @@ void nr_ue_measurement_procedures(
 
   }
 #endif
-  // accumulate and filter timing offset estimation every nr_tti_rx (instead of every frame)
-  if (( slot == 2) && (l==(1-frame_parms->Ncp))) {
-
-    // AGC
-/*
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_GAIN_CONTROL, VCD_FUNCTION_IN);
-
-#ifndef OAI_USRP
-#ifndef OAI_BLADERF
-#ifndef OAI_LMSSDR
-#ifndef OAI_ADRV9371_ZC706
-    phy_adjust_gain (ue,dB_fixed(ue->measurements.rssi),0);
-#endif
-#endif
-#endif
-#endif
-
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_GAIN_CONTROL, VCD_FUNCTION_OUT);
-*/
-    eNB_id = 0;
-
-      LOG_D(PHY,"start adjust sync l = %d slot = %d no timing %d\n",l, slot, ue->no_timing_correction);
-      if (ue->no_timing_correction==0)
-	nr_adjust_synch_ue(&ue->frame_parms,
-			   ue,
-			   eNB_id,
-			   nr_tti_rx,
-			   0,
-			   16384);
-    
-  }
 
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_MEASUREMENT_PROCEDURES, VCD_FUNCTION_OUT);
 }
 
 
-#ifdef EMOS
-void phy_procedures_emos_UE_RX(PHY_VARS_NR_UE *ue,uint8_t last_slot,uint8_t eNB_id)
-{
-
-  uint8_t i,j;
-  //uint16_t last_slot_emos;
-  uint32_t bytes;
-  int Mod_id = ue->Mod_id;
-
-  /*
-    if (last_slot<2)
-    last_slot_emos = last_slot;
-    else if (last_slot>9)
-    last_slot_emos = last_slot - 8;
-    else {
-    LOG_E(PHY,"emos rx last_slot_emos %d, last_slot %d\n", last_slot_emos,last_slot);
-    //mac_xface->macphy_exit("should never happen");
-    }
-  */
-
-#ifdef EMOS_CHANNEL
-
-  if ((last_slot==10) || (last_slot==11)) {
-    for (i=0; i<ue->frame_parms.nb_antennas_rx; i++)
-      for (j=0; j<ue->frame_parms.nb_antennas_tx; j++) {
-	// first OFDM symbol with pilots
-	memcpy(&emos_dump_UE.channel[i][j][(last_slot%2)*2*ue->frame_parms.ofdm_symbol_size],
-	       &ue->common_vars.dl_ch_estimates[eNB_id][(j<<1) + i][0],
-	       ue->frame_parms.ofdm_symbol_size*sizeof(int));
-	// second OFDM symbol with pilots
-	memcpy(&emos_dump_UE.channel[i][j][((last_slot%2)*2+1)*ue->frame_parms.ofdm_symbol_size],
-	       &ue->common_vars.dl_ch_estimates[eNB_id][(j<<1) + i][(ue->frame_parms.Ncp == 0 ? 4 : 3)*ue->frame_parms.ofdm_symbol_size],
-	       ue->frame_parms.ofdm_symbol_size*sizeof(int));
-      }
-  }
-
-#endif
-
-  if (last_slot==0) {
-    emos_dump_UE.timestamp = rt_get_time_ns();
-    emos_dump_UE.frame_rx = proc->frame_rx;
-    emos_dump_UE.UE_mode = ue->UE_mode[eNB_id];
-    emos_dump_UE.mimo_mode = ue->transmission_mode[eNB_id];
-    emos_dump_UE.freq_offset = ue->common_vars.freq_offset;
-    emos_dump_UE.timing_advance = ue->timing_advance;
-    emos_dump_UE.timing_offset  = ue->rx_offset;
-    emos_dump_UE.rx_total_gain_dB = ue->rx_total_gain_dB;
-    emos_dump_UE.eNb_id = eNB_id;
-    memcpy(&emos_dump_UE.PHY_measurements,&measurements,sizeof(PHY_MEASUREMENTS));
-  }
-
-  if (last_slot==1) {
-    emos_dump_UE.pbch_errors = ue->pbch_vars[eNB_id]->pdu_errors;
-    emos_dump_UE.pbch_errors_last = ue->pbch_vars[eNB_id]->pdu_errors_last;
-    emos_dump_UE.pbch_errors_conseq = ue->pbch_vars[eNB_id]->pdu_errors_conseq;
-    emos_dump_UE.pbch_fer = ue->pbch_vars[eNB_id]->pdu_fer;
-  }
-
-  if (last_slot==19) {
-    emos_dump_UE.dlsch_errors = ue->dlsch_errors[eNB_id];
-    emos_dump_UE.dlsch_errors_last = ue->dlsch_errors_last[eNB_id];
-    emos_dump_UE.dlsch_received = ue->dlsch_received[eNB_id];
-    emos_dump_UE.dlsch_received_last = ue->dlsch_received_last[eNB_id];
-    emos_dump_UE.dlsch_fer = ue->dlsch_fer[eNB_id];
-    emos_dump_UE.dlsch_cntl_errors = ue->dlsch_SI_errors[eNB_id];
-    emos_dump_UE.dlsch_ra_errors = ue->dlsch_ra_errors[eNB_id];
-    emos_dump_UE.total_TBS = ue->total_TBS[eNB_id];
-    emos_dump_UE.total_TBS_last = ue->total_TBS_last[eNB_id];
-    emos_dump_UE.bitrate = ue->bitrate[eNB_id];
-    emos_dump_UE.total_received_bits = ue->total_received_bits[eNB_id];
-    emos_dump_UE.pmi_saved = ue->dlsch[ue->current_thread_id[nr_tti_rx]][eNB_id][0]->pmi_alloc;
-    emos_dump_UE.mcs = ue->dlsch[ue->current_thread_id[nr_tti_rx]][eNB_id][0]->harq_processes[ue->dlsch[ue->current_thread_id[nr_tti_rx]][eNB_id][0]->current_harq_pid]->mcs;
-    emos_dump_UE.use_ia_receiver = openair_daq_vars.use_ia_receiver;
-
-    bytes = rtf_put(CHANSOUNDER_FIFO_MINOR, &emos_dump_UE, sizeof(fifo_dump_emos_UE));
-
-    if (bytes!=sizeof(fifo_dump_emos_UE)) {
-      LOG_W(PHY,"[UE  %d] frame %d, slot %d, Problem writing EMOS data to FIFO\n",Mod_id,proc->frame_rx, last_slot);
-    } else {
-      if (proc->frame_rx%100==0) {
-	LOG_I(PHY,"[UE  %d] frame %d, slot %d, Writing %d bytes EMOS data to FIFO\n",Mod_id,proc->frame_rx, last_slot, bytes);
-      }
-    }
-  }
-
-}
-#endif
 
 #if 0
 void restart_phy(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc, uint8_t eNB_id,uint8_t abstraction_flag)
@@ -2950,16 +2803,17 @@ void restart_phy(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc, uint8_t eNB_id,uint
 }
 #endif //(0)
 
-void nr_ue_pbch_procedures(uint8_t eNB_id,PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc, uint8_t abstraction_flag)
+void nr_ue_pbch_procedures(uint8_t eNB_id,
+						   PHY_VARS_NR_UE *ue,
+						   UE_nr_rxtx_proc_t *proc,
+						   uint8_t abstraction_flag)
 {
-
   //  int i;
   //int pbch_tx_ant=0;
   //uint8_t pbch_phase;
   int ret = 0;
-  uint16_t frame_tx;
-  static uint8_t first_run = 1;
-  uint8_t pbch_trials = 0;
+  //static uint8_t first_run = 1;
+  //uint8_t pbch_trials = 0;
 
   DevAssert(ue);
 
@@ -2973,6 +2827,7 @@ void nr_ue_pbch_procedures(uint8_t eNB_id,PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *
 		   ue->pbch_vars[eNB_id],
 		   &ue->frame_parms,
 		   eNB_id,
+		   ue->rx_ind.rx_indication_body[0].mib_pdu.ssb_index,
 		   SISO,
 		   ue->high_speed_flag);
 
@@ -2981,6 +2836,7 @@ void nr_ue_pbch_procedures(uint8_t eNB_id,PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *
 
 
 #ifdef DEBUG_PHY_PROC
+    uint16_t frame_tx;
     LOG_D(PHY,"[UE %d] frame %d, nr_tti_rx %d, Received PBCH (MIB): frame_tx %d. N_RB_DL %d\n",
     ue->Mod_id,
     frame_rx,
@@ -3051,9 +2907,10 @@ unsigned int get_tx_amp(int power_dBm, int power_max_dBm, int N_RB_UL, int nb_rb
 
 #ifdef NR_PDCCH_SCHED
 
-int nr_ue_pdcch_procedures(uint8_t eNB_id,PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc)
+int nr_ue_pdcch_procedures(uint8_t eNB_id,
+						   PHY_VARS_NR_UE *ue,
+						   UE_nr_rxtx_proc_t *proc)
 {
-
   //  unsigned int dci_cnt=0, i;  //removed for nr_ue_pdcch_procedures and added in the loop for nb_coreset_active
 #ifdef NR_PDCCH_SCHED_DEBUG
   printf("<-NR_PDCCH_PHY_PROCEDURES_LTE_UE (nr_ue_pdcch_procedures)-> Entering function nr_ue_pdcch_procedures() \n");
@@ -3062,8 +2919,10 @@ int nr_ue_pdcch_procedures(uint8_t eNB_id,PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *
   int frame_rx = proc->frame_rx;
   int nr_tti_rx = proc->nr_tti_rx;
   NR_DCI_ALLOC_t dci_alloc_rx[8];
+  /*
   uint8_t next1_thread_id = ue->current_thread_id[nr_tti_rx]== (RX_NB_TH-1) ? 0:(ue->current_thread_id[nr_tti_rx]+1);
   uint8_t next2_thread_id = next1_thread_id== (RX_NB_TH-1) ? 0:(next1_thread_id+1);
+  */
 
   // table dci_fields_sizes_cnt contains dci_fields_sizes for each time a dci is decoded in the slot
   // each element represents the size in bits for each dci field, for each decoded dci -> [dci_cnt-1]
@@ -3081,11 +2940,11 @@ int nr_ue_pdcch_procedures(uint8_t eNB_id,PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *
   pdcch_vars[eNB_id]->crnti = 0x1234; //to be check how to set when using loop memory
 
   uint16_t c_rnti=pdcch_vars[eNB_id]->crnti;
-  uint16_t cs_rnti=0,new_rnti=0,tc_rnti;
+  uint16_t cs_rnti=0,new_rnti=0,tc_rnti=0;
   uint16_t p_rnti=P_RNTI;
   uint16_t si_rnti=SI_RNTI;
   uint16_t ra_rnti=99;
-  uint16_t sp_csi_rnti,sfi_rnti,int_rnti,tpc_pusch_rnti,tpc_pucch_rnti,tpc_srs_rnti; //FIXME
+  uint16_t sp_csi_rnti=0,sfi_rnti=0,int_rnti=0,tpc_pusch_rnti=0,tpc_pucch_rnti=0,tpc_srs_rnti=0; //FIXME
   uint16_t crc_scrambled_values[TOTAL_NBR_SCRAMBLED_VALUES] =
     {c_rnti,cs_rnti,new_rnti,tc_rnti,p_rnti,si_rnti,ra_rnti,sp_csi_rnti,sfi_rnti,int_rnti,tpc_pusch_rnti,tpc_pucch_rnti,tpc_srs_rnti};
   #ifdef NR_PDCCH_SCHED_DEBUG
@@ -3099,10 +2958,10 @@ int nr_ue_pdcch_procedures(uint8_t eNB_id,PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *
   #endif
 
   // p in TS 38.212 Subclause 10.1, for each active BWP the UE can deal with 3 different CORESETs (including coresetId 0 for common search space)
-  int nb_coreset_total = NR_NBR_CORESET_ACT_BWP;
+  //int nb_coreset_total = NR_NBR_CORESET_ACT_BWP;
   unsigned int dci_cnt=0;
   // this table contains 56 (NBR_NR_DCI_FIELDS) elements for each dci field and format described in TS 38.212. Each element represents the size in bits for each dci field
-  uint8_t dci_fields_sizes[NBR_NR_DCI_FIELDS][NBR_NR_FORMATS] = {{0}};
+  //uint8_t dci_fields_sizes[NBR_NR_DCI_FIELDS][NBR_NR_FORMATS] = {{0}};
   // this is the UL bandwidth part. FIXME! To be defined where this value comes from
   //  uint16_t n_RB_ULBWP = 106;
   // this is the DL bandwidth part. FIXME! To be defined where this value comes from
@@ -3111,7 +2970,7 @@ int nr_ue_pdcch_procedures(uint8_t eNB_id,PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *
   // Up to 10 searchSpaces can be configured to UE (s<=10)
   for (nb_searchspace_active=0; nb_searchspace_active<nb_searchspace_total; nb_searchspace_active++){
     int nb_coreset_active=nb_searchspace_active;
-    int do_pdcch_monitoring_current_slot=1; // this variable can be removed and fapi is handling
+    //int do_pdcch_monitoring_current_slot=1; // this variable can be removed and fapi is handling
     /*
      * The following code has been removed as it is handled by higher layers (fapi)
      *
@@ -3129,7 +2988,7 @@ int nr_ue_pdcch_procedures(uint8_t eNB_id,PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *
      * To be implemented LATER !!!
      */
     //int _offset,_index,_M;
-    int searchSpace_id                              = pdcch_vars2->searchSpace[nb_searchspace_active].searchSpaceId;
+    //int searchSpace_id                              = pdcch_vars2->searchSpace[nb_searchspace_active].searchSpaceId;
 
 
     #ifdef NR_PDCCH_SCHED_DEBUG
@@ -3142,16 +3001,16 @@ int nr_ue_pdcch_procedures(uint8_t eNB_id,PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *
       // the searchSpace indicates that we need to monitor PDCCH in current nr_tti_rx
       // get the parameters describing the current SEARCHSPACE
       // the CORESET id applicable to the current SearchSpace
-      int searchSpace_coreset_id                      = pdcch_vars2->searchSpace[nb_searchspace_active].controlResourceSetId;
+      //int searchSpace_coreset_id                      = pdcch_vars2->searchSpace[nb_searchspace_active].controlResourceSetId;
       // FIXME this variable is a bit string (14 bits) identifying every OFDM symbol in a slot.
       // at the moment we will not take into consideration this variable and we will consider that the OFDM symbol offset is always the first OFDM in a symbol
       uint16_t symbol_within_slot_mon                 = pdcch_vars2->searchSpace[nb_searchspace_active].monitoringSymbolWithinSlot;
       // get the remaining parameters describing the current SEARCHSPACE:     // FIXME! To be defined where we get this information from
-      NR_UE_SEARCHSPACE_nbrCAND_t num_cand_L1         = pdcch_vars2->searchSpace[nb_searchspace_active].nrofCandidates_aggrlevel1;
+      /*NR_UE_SEARCHSPACE_nbrCAND_t num_cand_L1         = pdcch_vars2->searchSpace[nb_searchspace_active].nrofCandidates_aggrlevel1;
       NR_UE_SEARCHSPACE_nbrCAND_t num_cand_L2         = pdcch_vars2->searchSpace[nb_searchspace_active].nrofCandidates_aggrlevel2;
       NR_UE_SEARCHSPACE_nbrCAND_t num_cand_L4         = pdcch_vars2->searchSpace[nb_searchspace_active].nrofCandidates_aggrlevel4;
       NR_UE_SEARCHSPACE_nbrCAND_t num_cand_L8         = pdcch_vars2->searchSpace[nb_searchspace_active].nrofCandidates_aggrlevel8;
-      NR_UE_SEARCHSPACE_nbrCAND_t num_cand_L16        = pdcch_vars2->searchSpace[nb_searchspace_active].nrofCandidates_aggrlevel16;
+      NR_UE_SEARCHSPACE_nbrCAND_t num_cand_L16        = pdcch_vars2->searchSpace[nb_searchspace_active].nrofCandidates_aggrlevel16;*/
                                                                                                   // FIXME! A table of five enum elements
       // searchSpaceType indicates whether this is a common search space or a UE-specific search space
       //int searchSpaceType                             = pdcch_vars2->searchSpace[nb_searchspace_active].searchSpaceType.type;
@@ -3268,7 +3127,7 @@ int nr_ue_pdcch_procedures(uint8_t eNB_id,PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *
         VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_DCI_DECODING, VCD_FUNCTION_OUT);
         //LOG_D(PHY,"[UE  %d][PUSCH] Frame %d nr_tti_rx %d PHICH RX\n",ue->Mod_id,frame_rx,nr_tti_rx);
 
-
+    /*
     uint8_t *nCCE_current = &ue->pdcch_vars[ue->current_thread_id[nr_tti_rx]][eNB_id]->nCCE[nr_tti_rx];
     uint8_t *nCCE_dest = &ue->pdcch_vars[next1_thread_id][eNB_id]->nCCE[nr_tti_rx];
     uint8_t *nCCE_dest1 = &ue->pdcch_vars[next2_thread_id][eNB_id]->nCCE[nr_tti_rx];
@@ -3276,6 +3135,7 @@ int nr_ue_pdcch_procedures(uint8_t eNB_id,PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *
     memcpy(nCCE_dest1, nCCE_current, sizeof(uint8_t));
 
     LOG_D(PHY,"current_thread %d next1_thread %d next2_thread %d \n", ue->current_thread_id[nr_tti_rx], next1_thread_id, next2_thread_id);
+    */
 
     LOG_D(PHY,"[UE  %d] AbsSubFrame %d.%d, Mode %s: DCI found %i --> rnti %x / crnti %x : format %d\n",
 	  ue->Mod_id,frame_rx%1024,nr_tti_rx,mode_string[ue->UE_mode[eNB_id]],
@@ -3290,40 +3150,74 @@ int nr_ue_pdcch_procedures(uint8_t eNB_id,PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *
 #endif
 
     ue->dci_ind.number_of_dcis = dci_cnt;
-    ue->dl_indication.dci_ind = &ue->dci_ind; //  hang on rx_ind instance
 
     for (int i=0; i<dci_cnt; i++) {
       /*
        * This is the NR part
        */
-
-      if ((dci_alloc_rx[i].format == format0_0))
-        if ((dci_alloc_rx[i].format == format1_0) &&
-            (dci_alloc_rx[i].rnti != crc_scrambled_values[_P_RNTI_]) &&
-            (dci_alloc_rx[i].rnti != crc_scrambled_values[_SI_RNTI_]) &&
-            (dci_alloc_rx[i].rnti != crc_scrambled_values[_RA_RNTI_])) ue->dlsch_received[eNB_id]++;
-
-        if ((dci_alloc_rx[i].rnti == crc_scrambled_values[_SI_RNTI_]) && (dci_alloc_rx[i].format == format1_0)) ue->dlsch_SI_received[eNB_id]++;
-        if ((dci_alloc_rx[i].rnti == crc_scrambled_values[_P_RNTI_]) && (dci_alloc_rx[i].format == format1_0)) ue->dlsch_p_received[eNB_id]++;
-        if ((dci_alloc_rx[i].rnti == crc_scrambled_values[_RA_RNTI_]) && (dci_alloc_rx[i].format == format1_0)) ue->dlsch_ra_received[eNB_id]++;
-        if ((dci_alloc_rx[i].format == format2_0)){
-        }
-        if ((dci_alloc_rx[i].format == format2_1)){
-        }
-        if ((dci_alloc_rx[i].format == format2_2)){
-        }
-        if ((dci_alloc_rx[i].format == format2_3)){
-        }
-        if ((dci_alloc_rx[i].format == format0_1)){ // This format not implemented at a first time. FIXME
-        }
-        if ((dci_alloc_rx[i].format == format1_1)){ // This format not implemented at a first time. FIXME
-        }
-        NR_DCI_INFO_EXTRACTED_t nr_dci_info_extracted;
-        #ifdef NR_PDCCH_SCHED_DEBUG
-            printf("<-NR_PDCCH_PHY_PROCEDURES_LTE_UE (nr_ue_pdcch_procedures)-> Entering function nr_generate_ue_ul_dlsch_params_from_dci with eNB_id=%d dci_cnt=%d\n",
-                    eNB_id,
-                    dci_cnt);
-       #endif
+      if ((dci_alloc_rx[i].format == format0_0)){
+      }
+      
+      if (dci_alloc_rx[i].format == format1_0) {
+	if ((dci_alloc_rx[i].rnti != crc_scrambled_values[_P_RNTI_]) &&
+	    (dci_alloc_rx[i].rnti != crc_scrambled_values[_SI_RNTI_]) &&
+	    (dci_alloc_rx[i].rnti != crc_scrambled_values[_RA_RNTI_]))
+	  ue->dlsch_received[eNB_id]++;
+	
+	if (dci_alloc_rx[i].rnti == crc_scrambled_values[_SI_RNTI_])
+	  ue->dlsch_SI_received[eNB_id]++;
+	if (dci_alloc_rx[i].rnti == crc_scrambled_values[_P_RNTI_])
+	  ue->dlsch_p_received[eNB_id]++;
+	if (dci_alloc_rx[i].rnti == crc_scrambled_values[_RA_RNTI_])
+	  ue->dlsch_ra_received[eNB_id]++;
+      }
+      
+      if ((dci_alloc_rx[i].format == format2_0)){
+      }
+      if ((dci_alloc_rx[i].format == format2_1)){
+      }
+      if ((dci_alloc_rx[i].format == format2_2)){
+      }
+      if ((dci_alloc_rx[i].format == format2_3)){
+      }
+      if ((dci_alloc_rx[i].format == format0_1)){ // This format not implemented at a first time. FIXME
+      }
+      if ((dci_alloc_rx[i].format == format1_1)){ // This format not implemented at a first time. FIXME
+      }
+      
+	uint8_t status=0;
+	
+	LOG_D(PHY,"<-NR_PDCCH_PHY_PROCEDURES_UE (nr_ue_pdcch_procedures)-> dci_format=%d, rnti=%d, dci_length=%d, dci_pdu[0]=0x%lx, dci_pdu[1]=0x%lx\n",dci_alloc_rx[i].format,dci_alloc_rx[i].rnti,dci_alloc_rx[i].dci_length,dci_alloc_rx[i].dci_pdu[0],dci_alloc_rx[i].dci_pdu[1]);
+	
+	memset(&ue->dci_ind.dci_list[i].dci,0,sizeof(fapi_nr_dci_pdu_rel15_t));
+	
+	ue->dci_ind.dci_list[i].rnti = dci_alloc_rx[i].rnti;
+	ue->dci_ind.dci_list[i].dci_format = dci_alloc_rx[i].format;
+	ue->dci_ind.dci_list[i].n_CCE = dci_alloc_rx[i].firstCCE;
+	ue->dci_ind.dci_list[i].N_CCE = (int)dci_alloc_rx[i].L;
+	
+	status = nr_extract_dci_info(ue,
+				     eNB_id,
+				     ue->frame_parms.frame_type,
+				     dci_alloc_rx[i].dci_length,
+				     dci_alloc_rx[i].rnti,
+				     dci_alloc_rx[i].dci_pdu,
+				     &ue->dci_ind.dci_list[i].dci,
+				     dci_fields_sizes_cnt[i],
+				     dci_alloc_rx[i].format,
+				     nr_tti_rx,
+				     pdcch_vars2->n_RB_BWP[nb_searchspace_active],
+				     pdcch_vars2->n_RB_BWP[nb_searchspace_active],
+				     crc_scrambled_values);
+	
+	if(status == 0) {
+	  LOG_W(PHY,"<-NR_PDCCH_PHY_PROCEDURES_UE (nr_ue_pdcch_procedures)-> bad DCI %d !!! \n",dci_alloc_rx[i].format);
+	  return(-1);
+	}
+	
+	LOG_D(PHY,"<-NR_PDCCH_PHY_PROCEDURES_UE (nr_ue_pdcch_procedures)-> Ending function nr_extract_dci_info()\n");
+	
+	/*
        nr_generate_ue_ul_dlsch_params_from_dci(ue,
 					       eNB_id,
 					       frame_rx,
@@ -3335,7 +3229,7 @@ int nr_ue_pdcch_procedures(uint8_t eNB_id,PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *
 					       ue->pdcch_vars[ue->current_thread_id[nr_tti_rx]][eNB_id],
 					       ue->pdsch_vars[ue->current_thread_id[nr_tti_rx]][eNB_id],
 					       ue->dlsch[ue->current_thread_id[nr_tti_rx]][eNB_id],
-					       ue->ulsch[eNB_id],
+					       ue->ulsch[ue->current_thread_id[nr_tti_rx]][eNB_id][0],
 					       &ue->frame_parms,
 					       ue->pdsch_config_dedicated,
 					       ue->transmission_mode[eNB_id]<7?0:ue->transmission_mode[eNB_id],
@@ -3344,18 +3238,22 @@ int nr_ue_pdcch_procedures(uint8_t eNB_id,PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *
 					       pdcch_vars2->n_RB_BWP[nb_searchspace_active],
 					       crc_scrambled_values,
 					       &nr_dci_info_extracted);
+  */
 
-       ue->dci_ind.dci_list[i].rnti = dci_alloc_rx[i].rnti;
-       ue->dci_ind.dci_list[i].dci_format = dci_alloc_rx[i].format;
-       ue->dci_ind.dci_list[i].n_CCE = dci_alloc_rx[i].firstCCE;
-       ue->dci_ind.dci_list[i].N_CCE = (int)dci_alloc_rx[i].L;
-       memcpy(&ue->dci_ind.dci_list[i].dci, &nr_dci_info_extracted, sizeof(fapi_nr_dci_pdu_rel15_t) );
         
       } // end for loop dci_cnt
 
-    //  TODO: check where should we send up this message.
-    //ue->if_inst->dl_indication(&ue->dl_indication);
-
+    // fill dl_indication message
+    ue->dl_indication.module_id = ue->Mod_id;
+    ue->dl_indication.cc_id = ue->CC_id;
+    ue->dl_indication.gNB_index = eNB_id;
+    ue->dl_indication.frame = frame_rx;
+    ue->dl_indication.slot = nr_tti_rx;
+    ue->dl_indication.rx_ind = NULL; //no data, only dci for now
+    ue->dl_indication.dci_ind = &ue->dci_ind; 
+    
+    //  send to mac
+    ue->if_inst->dl_indication(&ue->dl_indication);
 
 #if UE_TIMING_TRACE
   stop_meas(&ue->dlsch_rx_pdcch_stats);
@@ -3364,7 +3262,7 @@ int nr_ue_pdcch_procedures(uint8_t eNB_id,PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *
 
 
   } // end for loop nb_searchspace_active
-  return(0);
+  return(dci_cnt);
 }
 #endif // NR_PDCCH_SCHED
 
@@ -3703,54 +3601,40 @@ void copy_harq_proc_struct(NR_DL_UE_HARQ_t *harq_processes_dest, NR_DL_UE_HARQ_t
   memcpy(harq_ack_dest, current_harq_ack, sizeof(nr_harq_status_t));
   }*/
 
-void nr_ue_pdsch_procedures(PHY_VARS_NR_UE *ue, UE_nr_rxtx_proc_t *proc, int eNB_id, PDSCH_t pdsch, NR_UE_DLSCH_t *dlsch0, NR_UE_DLSCH_t *dlsch1, int s0, int s1) {
+void nr_ue_pdsch_procedures(PHY_VARS_NR_UE *ue, UE_nr_rxtx_proc_t *proc, int eNB_id, PDSCH_t pdsch, NR_UE_DLSCH_t *dlsch0, NR_UE_DLSCH_t *dlsch1) {
 
   int nr_tti_rx = proc->nr_tti_rx;
   int m;
-  int harq_pid;
   int i_mod,eNB_id_i,dual_stream_UE;
   int first_symbol_flag=0;
 
   if (dlsch0->active == 0)
     return;
 
-  for (m=s0;m<=s1;m++) {
+  if (dlsch0 && (!dlsch1))  {
+    int harq_pid = dlsch0->current_harq_pid;
+    uint16_t pdsch_start_rb = dlsch0->harq_processes[harq_pid]->start_rb;
+    uint16_t pdsch_nb_rb =  dlsch0->harq_processes[harq_pid]->nb_rb;
+    uint16_t s0 =  dlsch0->harq_processes[harq_pid]->start_symbol;
+    uint16_t s1 =  dlsch0->harq_processes[harq_pid]->nb_symbols;
 
-    if (dlsch0 && (!dlsch1))  {
-      harq_pid = dlsch0->current_harq_pid;
-      LOG_D(PHY,"[UE %d] PDSCH type %d active in nr_tti_rx %d, harq_pid %d Symbol %d\n",ue->Mod_id,pdsch,nr_tti_rx,harq_pid,m);
+    LOG_D(PHY,"[UE %d] PDSCH type %d active in nr_tti_rx %d, harq_pid %d, rb_start %d, nb_rb %d, symbol_start %d, nb_symbols %d\n",ue->Mod_id,pdsch,nr_tti_rx,harq_pid,pdsch_start_rb,pdsch_nb_rb,s0,s1);
 
-      if ((pdsch==PDSCH) &&
-          (ue->transmission_mode[eNB_id] == 5) &&
-          (dlsch0->harq_processes[harq_pid]->dl_power_off==0) &&
-          (ue->use_ia_receiver ==1)) {
-        dual_stream_UE = 1;
-        eNB_id_i = ue->n_connected_eNB;
-        i_mod =  dlsch0->harq_processes[harq_pid]->Qm;
+    for (m=s0;m<=s1;m++) {
 
-      }
-      else if((pdsch==PDSCH) && (ue->transmission_mode[eNB_id]==3))
-	{
-          dual_stream_UE = rx_IC_dual_stream;
-          eNB_id_i       = eNB_id;
-          i_mod          = 0;
-	}
-      else {
-        dual_stream_UE = 0;
-        eNB_id_i = eNB_id+1;
-        i_mod = 0;
-      }
+      if (m==s0)
+	nr_pdsch_channel_estimation(ue,
+				    0 /*eNB_id*/,
+				    nr_tti_rx,
+				    0 /*p*/,
+				    m,
+				    ue->frame_parms.first_carrier_offset+pdsch_start_rb*12,
+				    pdsch_nb_rb);
+      
 
-      //TM7 UE specific channel estimation here!!!
-      if (ue->transmission_mode[eNB_id]==7) {
-        if (ue->frame_parms.Ncp==0) {
-          //if ((m==3) || (m==6) || (m==9) || (m==12))
-	  //LOG_D(PHY,"[UE %d] dlsch->active in nr_tti_rx %d => %d, l=%d\n",phy_vars_ue->Mod_id,nr_tti_rx,phy_vars_ue->dlsch_ue[eNB_id][0]->active, l);
-	  //lte_dl_bf_channel_estimation(ue,eNB_id,0,nr_tti_rx*2+(m>6?1:0),5,m);
-        } else {
-          LOG_E(PHY,"[UE %d]Beamforming channel estimation not supported yet for TM7 extented CP.\n",ue->Mod_id);
-        }
-      }
+      dual_stream_UE = 0;
+      eNB_id_i = eNB_id+1;
+      i_mod = 0;
 
       if ((m==s0) && (m<3))
 	first_symbol_flag = 1;
@@ -3783,7 +3667,6 @@ void nr_ue_pdsch_procedures(PHY_VARS_NR_UE *ue, UE_nr_rxtx_proc_t *proc, int eNB
 #endif
 #endif
 
-
       if(first_symbol_flag)
 	{
           proc->first_symbol_available = 1;
@@ -3800,8 +3683,10 @@ void process_rar(PHY_VARS_NR_UE *ue, UE_nr_rxtx_proc_t *proc, int eNB_id, runmod
   NR_UE_DLSCH_t *dlsch0 = ue->dlsch_ra[eNB_id];
   int harq_pid = 0;
   uint8_t *rar;
+  /*
   uint8_t next1_thread_id = ue->current_thread_id[nr_tti_rx]== (RX_NB_TH-1) ? 0:(ue->current_thread_id[nr_tti_rx]+1);
   uint8_t next2_thread_id = next1_thread_id== (RX_NB_TH-1) ? 0:(next1_thread_id+1);
+  */
 
   LOG_D(PHY,"[UE  %d][RAPROC] Frame %d nr_tti_rx %d Received RAR  mode %d\n",
 	ue->Mod_id,
@@ -3826,9 +3711,11 @@ void process_rar(PHY_VARS_NR_UE *ue, UE_nr_rxtx_proc_t *proc, int eNB_id, runmod
 	      ue->prach_resources[eNB_id]->ra_PreambleIndex,
 	      dlsch0->harq_processes[0]->b); // alter the 'b' buffer so it contains only the selected RAR header and RAR payload
       */
+      /*
       ue->pdcch_vars[next1_thread_id][eNB_id]->crnti = ue->pdcch_vars[ue->current_thread_id[nr_tti_rx]][eNB_id]->crnti;
       ue->pdcch_vars[next2_thread_id][eNB_id]->crnti = ue->pdcch_vars[ue->current_thread_id[nr_tti_rx]][eNB_id]->crnti;
-      
+      */
+
       if (timing_advance!=0xffff) {
 
 	LOG_D(PHY,"[UE  %d][RAPROC] Frame %d nr_tti_rx %d Got rnti %x and timing advance %d from RAR\n",
@@ -3898,20 +3785,22 @@ void nr_ue_dlsch_procedures(PHY_VARS_NR_UE *ue,
   int frame_rx = proc->frame_rx;
   int nr_tti_rx = proc->nr_tti_rx;
   int ret=0, ret1=0;
-  int CC_id = ue->CC_id;
+  //int CC_id = ue->CC_id;
   NR_UE_PDSCH *pdsch_vars;
   uint8_t is_cw0_active = 0;
   uint8_t is_cw1_active = 0;
-  // to be updated by higher layer
-  uint8_t nb_re_dmrs = 6;
-  uint16_t length_dmrs = 1;
-  uint16_t nb_symb_sch = 8;
+  nfapi_nr_config_request_t *cfg = &ue->nrUE_config;
+  uint8_t dmrs_type = cfg->pdsch_config.dmrs_type.value;
+  uint8_t nb_re_dmrs = (dmrs_type==NFAPI_NR_DMRS_TYPE1)?6:4;
+  uint16_t length_dmrs = 1; //cfg->pdsch_config.dmrs_max_length.value;
+  uint16_t nb_symb_sch = 9;
 
   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;
 
   if(dlsch1)
     is_cw1_active = dlsch1->harq_processes[harq_pid]->status;
@@ -3970,20 +3859,20 @@ 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);
+						     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
       nr_dlsch_unscrambling(pdsch_vars->llr[0],
-    		  	  	  	  	dlsch0->harq_processes[harq_pid]->G,
-                            0,
+    		  	  	  	    dlsch0->harq_processes[harq_pid]->G,
+							0,
 							ue->frame_parms.Nid_cell,
 							dlsch0->rnti);
-
+      
 
 #if UE_TIMING_TRACE
       stop_meas(&ue->dlsch_unscrambling_stats);
@@ -4005,7 +3894,9 @@ void nr_ue_dlsch_procedures(PHY_VARS_NR_UE *ue,
 #endif
 
 #ifdef UE_DLSCH_PARALLELISATION
-		 ret = nr_dlsch_decoding_mthread(ue,proc,eNB_id,
+		 ret = nr_dlsch_decoding_mthread(ue,
+			   proc,
+			   eNB_id,
 			   pdsch_vars->llr[0],
 			   &ue->frame_parms,
 			   dlsch0,
@@ -4016,6 +3907,7 @@ void nr_ue_dlsch_procedures(PHY_VARS_NR_UE *ue,
 			   harq_pid,
 			   pdsch==PDSCH?1:0,
 			   dlsch0->harq_processes[harq_pid]->TBS>256?1:0);
+		 LOG_T(PHY,"UE_DLSCH_PARALLELISATION is defined, ret = %d\n", ret);
 #else
       ret = nr_dlsch_decoding(ue,
 			   pdsch_vars->llr[0],
@@ -4026,8 +3918,9 @@ void nr_ue_dlsch_procedures(PHY_VARS_NR_UE *ue,
 			   nb_symb_sch,
 			   nr_tti_rx,
 			   harq_pid,
-			   pdsch==PDSCH?1:0,//proc->decoder_switch,
+			   pdsch==PDSCH?1:0,
 			   dlsch0->harq_processes[harq_pid]->TBS>256?1:0);
+      LOG_T(PHY,"UE_DLSCH_PARALLELISATION is NOT defined, ret = %d\n", ret);
       //printf("start cW0 dlsch decoding\n");
 #endif
 
@@ -4050,11 +3943,11 @@ void nr_ue_dlsch_procedures(PHY_VARS_NR_UE *ue,
       {
           // start ldpc decode for CW 1
           dlsch1->harq_processes[harq_pid]->G = nr_get_G(dlsch1->harq_processes[harq_pid]->nb_rb,
-              		  	  	  	  	  	  	  	  	  	  nb_symb_sch,
-          												  nb_re_dmrs,
-          												  length_dmrs,
-          												  dlsch1->harq_processes[harq_pid]->Qm,
-          												  dlsch1->harq_processes[harq_pid]->Nl);
+							 nb_symb_sch,
+							 nb_re_dmrs,
+							 length_dmrs,
+							 dlsch1->harq_processes[harq_pid]->Qm,
+							 dlsch1->harq_processes[harq_pid]->Nl);
 #if UE_TIMING_TRACE
           start_meas(&ue->dlsch_unscrambling_stats);
 #endif
@@ -4082,7 +3975,9 @@ void nr_ue_dlsch_procedures(PHY_VARS_NR_UE *ue,
 #endif
 
 #ifdef UE_DLSCH_PARALLELISATION
-          ret1 = nr_dlsch_decoding_mthread(ue,proc, eNB_id,
+          ret1 = nr_dlsch_decoding_mthread(ue,
+        		  	  	  	proc,
+        		  	  	    eNB_id,
                             pdsch_vars->llr[1],
                             &ue->frame_parms,
                             dlsch1,
@@ -4093,19 +3988,20 @@ void nr_ue_dlsch_procedures(PHY_VARS_NR_UE *ue,
                             harq_pid,
                             pdsch==PDSCH?1:0,
                             dlsch1->harq_processes[harq_pid]->TBS>256?1:0);
+          LOG_T(PHY,"UE_DLSCH_PARALLELISATION is defined, ret1 = %d\n", ret1);
 #else
-
           ret1 = nr_dlsch_decoding(ue,
                   pdsch_vars->llr[1],
                   &ue->frame_parms,
                   dlsch1,
                   dlsch1->harq_processes[harq_pid],
                   frame_rx,
-		  nb_symb_sch,
+				  nb_symb_sch,
                   nr_tti_rx,
                   harq_pid,
                   pdsch==PDSCH?1:0,//proc->decoder_switch,
                   dlsch1->harq_processes[harq_pid]->TBS>256?1:0);
+          LOG_T(PHY,"UE_DLSCH_PARALLELISATION is NOT defined, ret1 = %d\n", ret1);
           printf("start cw1 dlsch decoding\n");
 #endif
 
@@ -4433,552 +4329,49 @@ void *UE_thread_slot1_dl_processing(void *arg) {
 }
 #endif
 
-#ifdef UE_SLOT_PARALLELISATION
-int phy_procedures_slot_parallelization_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eNB_id,
-        uint8_t abstraction_flag,uint8_t do_pdcch_flag,runmode_t mode,
-        relaying_type_t r_type)  {
 
-  int l,l2;
-  int pmch_flag=0;
-  int frame_rx = proc->frame_rx;
-  int nr_tti_rx = proc->nr_tti_rx;
-  uint8_t pilot0;
-  uint8_t pilot1;
-  uint8_t slot0;
-  uint8_t slot1;
-  uint8_t first_ofdm_sym;
-
-  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_UE_RX, VCD_FUNCTION_IN);
-
-#if T_TRACER
-  T(T_UE_PHY_DL_TICK, T_INT(ue->Mod_id), T_INT(frame_rx%1024), T_INT(nr_tti_rx));
-
-  T(T_UE_PHY_INPUT_SIGNAL, T_INT(ue->Mod_id), T_INT(frame_rx%1024), T_INT(nr_tti_rx), T_INT(0),
-    T_BUFFER(&ue->common_vars.rxdata[0][nr_tti_rx*ue->frame_parms.samples_per_subframe],
-	     ue->frame_parms.samples_per_subframe * 4));
-#endif
-
-  // start timers
-#ifdef UE_DEBUG_TRACE
-  LOG_I(PHY," ****** start RX-Chain for AbsSubframe %d.%d ******  \n", frame_rx%1024, nr_tti_rx);
-#endif
-
-#if UE_TIMING_TRACE
-  start_meas(&ue->phy_proc_rx[ue->current_thread_id[nr_tti_rx]]);
-  start_meas(&ue->ue_front_end_stat[ue->current_thread_id[nr_tti_rx]]);
-#endif
-
-  pmch_flag = is_pmch_subframe(frame_rx,nr_tti_rx,&ue->frame_parms) ? 1 : 0;
-
-  if (do_pdcch_flag) {
-    // deactivate reception until we scan pdcch
-    if (ue->dlsch[ue->current_thread_id[nr_tti_rx]][eNB_id][0])
-      ue->dlsch[ue->current_thread_id[nr_tti_rx]][eNB_id][0]->active = 0;
-    if (ue->dlsch[ue->current_thread_id[nr_tti_rx]][eNB_id][1])
-      ue->dlsch[ue->current_thread_id[nr_tti_rx]][eNB_id][1]->active = 0;
-
-    if (ue->dlsch_SI[eNB_id])
-      ue->dlsch_SI[eNB_id]->active = 0;
-    if (ue->dlsch_p[eNB_id])
-      ue->dlsch_p[eNB_id]->active = 0;
-    if (ue->dlsch_ra[eNB_id])
-      ue->dlsch_ra[eNB_id]->active = 0;
-  }
-
-#ifdef DEBUG_PHY_PROC
-  LOG_D(PHY,"[%s %d] Frame %d nr_tti_rx %d: Doing phy_procedures_UE_RX\n",
-	(r_type == multicast_relay) ? "RN/UE" : "UE",
-	ue->Mod_id,frame_rx, nr_tti_rx);
-#endif
-
-
-
-
-  if (nr_subframe_select(&ue->frame_parms,nr_tti_rx) == SF_S) { // S-subframe, do first 5 symbols only
-    l2 = 5;
-  } else if (pmch_flag == 1) { // do first 2 symbols only
-    l2 = 1;
-  } else { // normal nr_tti_rx, last symbol to be processed is the first of the second slot
-    l2 = (ue->frame_parms.symbols_per_tti/2)-1;
-  }
-
-  int prev_nr_tti_rx = (nr_tti_rx - 1)<0? 9: (nr_tti_rx - 1);
-  if (nr_subframe_select(&ue->frame_parms,prev_nr_tti_rx) != SF_DL) {
-    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-    // RX processing of symbols l=0...l2
-    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-    first_ofdm_sym = 0;
-  } else {
-    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-    // RX processing of symbols l=1...l2 (l=0 is done in last scheduling epoch)
-    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-    first_ofdm_sym = 1;
-  }
-  slot0  = (nr_tti_rx<<1);
-  slot1  = (nr_tti_rx<<1) + 1;
-  pilot0 = 0;
-  if (ue->frame_parms.Ncp == 0) {  // normal prefix
-    pilot1 = 4;
-  } else { // extended prefix
-    pilot1 = 3;
-  }
-
-  //LOG_I(PHY,"Set available channelEst to 0 AbsSubframe %d.%d \n",frame_rx,nr_tti_rx);
-  //LOG_I(PHY,"Set available llrs slot1 to 0 AbsSubframe %d.%d \n",frame_rx,nr_tti_rx);
-  //LOG_I(PHY,"Set available dci info slot0 to 0 AbsSubframe %d.%d \n",frame_rx,nr_tti_rx);
-  proc->chan_est_pilot0_slot1_available=0;
-  proc->llr_slot1_available=0;
-  proc->dci_slot0_available=0;
-  proc->first_symbol_available=0;
-  proc->chan_est_slot1_available=0;
-  //proc->channel_level=0;
-
-  if (pthread_mutex_lock(&proc->mutex_slot1_dl_processing) != 0) {
-    LOG_E( PHY, "[SCHED][UE %d][Slot0] error locking mutex for UE slot1 dl processing\n",ue->Mod_id );
-    exit_fun("nothing to add");
-  }
-
-  proc->instance_cnt_slot1_dl_processing++;
-  if (proc->instance_cnt_slot1_dl_processing == 0)
-    {
-      LOG_D(PHY,"unblock slot1 dl processing thread blocked on instance_cnt_slot1_dl_processing : %d \n", proc->instance_cnt_slot1_dl_processing );
-      if (pthread_cond_signal(&proc->cond_slot1_dl_processing) != 0) {
-	LOG_E( PHY, "[SCHED][UE %d][Slot0] ERROR pthread_cond_signal for UE slot1 processing thread\n", ue->Mod_id);
-	exit_fun("nothing to add");
-      }
-      if (pthread_mutex_unlock(&proc->mutex_slot1_dl_processing) != 0) {
-	LOG_E( PHY, "[SCHED][UE %d][Slot0] error unlocking mutex for UE slot1 dl processing \n",ue->Mod_id );
-	exit_fun("nothing to add");
-      }
-
-    } else
-    {
-      LOG_E( PHY, "[SCHED][UE %d] UE RX thread busy (IC %d)!!\n", ue->Mod_id, proc->instance_cnt_slot1_dl_processing);
-      if (proc->instance_cnt_slot1_dl_processing > 2)
-	exit_fun("instance_cnt_slot1_dl_processing > 2");
-    }
-  //AssertFatal(pthread_cond_signal(&proc->cond_slot1_dl_processing) ==0 ,"");
-  AssertFatal(pthread_mutex_unlock(&proc->mutex_slot1_dl_processing) ==0,"");
-
-
-  /**** Slot0 FE Processing ****/
-  // I- start main thread for FFT/ChanEst symbol: 0/1 --> 7
-#if UE_TIMING_TRACE
-  start_meas(&ue->ue_front_end_per_slot_stat[ue->current_thread_id[nr_tti_rx]][0]);
-#endif
-  // 1- perform FFT for pilot ofdm symbols first (ofdmSym7 ofdmSym4 or (ofdmSym6 ofdmSym3))
-  //printf("AbsSubframe %d.%d FFT slot %d, symbol %d\n", frame_rx,nr_tti_rx,slot1,pilot0);
-  front_end_fft(ue,
-		pilot0,
-		slot1,
-		0,
-		0);
-  //printf("AbsSubframe %d.%d FFT slot %d, symbol %d\n", frame_rx,nr_tti_rx,slot0,pilot1);
-  front_end_fft(ue,
-		pilot1,
-		slot0,
-		0,
-		0);
-  //printf("AbsSubframe %d.%d ChanEst slot %d, symbol %d\n", frame_rx,nr_tti_rx,slot0,pilot1);
-  front_end_chanEst(ue,
-		    pilot1,
-		    slot0,
-		    0);
-  //printf("AbsSubframe %d.%d ChanEst slot %d, symbol %d\n", frame_rx,nr_tti_rx,slot1,pilot0);
-  front_end_chanEst(ue,
-		    pilot0,
-		    slot1,
-		    0);
-  proc->chan_est_pilot0_slot1_available = 1;
-  //printf("Set available channelEst to 1 AbsSubframe %d.%d \n",frame_rx,nr_tti_rx);
-
-  // 2- perform FFT for other ofdm symbols other than pilots
-  for (l=first_ofdm_sym; l<=l2; l++)
-    {
-      if( (l != pilot0) && (l != pilot1))
-        {
-	  //printf("AbsSubframe %d.%d FFT slot %d, symbol %d\n", frame_rx,nr_tti_rx,slot0,l);
-#if UE_TIMING_TRACE
-	  start_meas(&ue->ofdm_demod_stats);
-#endif
-	  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SLOT_FEP, VCD_FUNCTION_IN);
-	  front_end_fft(ue,
-			l,
-			slot0,
-			0,
-			0);
-	  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SLOT_FEP, VCD_FUNCTION_OUT);
-#if UE_TIMING_TRACE
-	  stop_meas(&ue->ofdm_demod_stats);
-#endif
-        }
-    } // for l=1..l2
-
-  // 3- perform Channel Estimation for slot0
-  for (l=first_ofdm_sym; l<=l2; l++)
-    {
-      if( (l != pilot0) && (l != pilot1))
-        {
-	  //printf("AbsSubframe %d.%d ChanEst slot %d, symbol %d\n", frame_rx,nr_tti_rx,slot0,l);
-	  front_end_chanEst(ue,
-			    l,
-			    slot0,
-			    0);
-        }
-      ue_measurement_procedures(l-1,ue,proc,eNB_id,(nr_tti_rx<<1),abstraction_flag,mode);
-    }
-
-  if (do_pdcch_flag) {
-#if UE_TIMING_TRACE
-    start_meas(&ue->pdcch_procedures_stat[ue->current_thread_id[nr_tti_rx]]);
-#endif
-    if (ue_pdcch_procedures(eNB_id,ue,proc,abstraction_flag) == -1) {
-      LOG_E(PHY,"[UE  %d] Frame %d, nr_tti_rx %d: Error in pdcch procedures\n",ue->Mod_id,frame_rx,nr_tti_rx);
-#if UE_TIMING_TRACE
-      stop_meas(&ue->pdcch_procedures_stat[ue->current_thread_id[nr_tti_rx]]);
-#if DISABLE_LOG_X
-      printf("[AbsSFN %d.%d] Slot0: PDCCH %5.2f \n",frame_rx,nr_tti_rx,ue->pdcch_procedures_stat[ue->current_thread_id[nr_tti_rx]].p_time/(cpuf*1000.0));
-#else
-      LOG_D(PHY, "[AbsSFN %d.%d] Slot0: PDCCH %5.2f \n",frame_rx,nr_tti_rx,ue->pdcch_procedures_stat[ue->current_thread_id[nr_tti_rx]].p_time/(cpuf*1000.0));
-#endif
-#endif
-      //proc->dci_slot0_available = 1;
-      return(-1);
-    }
-    //proc->dci_slot0_available=1;
-#if UE_TIMING_TRACE
-    stop_meas(&ue->pdcch_procedures_stat[ue->current_thread_id[nr_tti_rx]]);
-#if DISABLE_LOG_X
-    printf("[AbsSFN %d.%d] Slot0: PDCCH %5.2f \n",frame_rx,nr_tti_rx,ue->pdcch_procedures_stat[ue->current_thread_id[nr_tti_rx]].p_time/(cpuf*1000.0));
-#else
-    LOG_D(PHY, "[AbsSFN %d.%d] Slot0: PDCCH %5.2f \n",frame_rx,nr_tti_rx,ue->pdcch_procedures_stat[ue->current_thread_id[nr_tti_rx]].p_time/(cpuf*1000.0));
-#endif
-#endif
-  }
-
-  //printf("num_pdcch_symbols %d\n",ue->pdcch_vars[ue->current_thread_id[nr_tti_rx]][eNB_id]->num_pdcch_symbols);
-
-  // first slot has been processed (FFTs + Channel Estimation, PCFICH/PHICH/PDCCH)
-#if UE_TIMING_TRACE
-  stop_meas(&ue->ue_front_end_per_slot_stat[ue->current_thread_id[nr_tti_rx]][0]);
-#if DISABLE_LOG_X
-  printf("[AbsSFN %d.%d] Slot0: FFT + Channel Estimate + PCFICH/PHICH/PDCCH %5.2f \n",frame_rx,nr_tti_rx,ue->ue_front_end_per_slot_stat[ue->current_thread_id[nr_tti_rx]][0].p_time/(cpuf*1000.0));
-#else
-  LOG_D(PHY, "[AbsSFN %d.%d] Slot0: FFT + Channel Estimate + PCFICH/PHICH/PDCCH %5.2f \n",frame_rx,nr_tti_rx,ue->ue_front_end_per_slot_stat[ue->current_thread_id[nr_tti_rx]][0].p_time/(cpuf*1000.0));
-#endif
-#endif
-
-  //wait until slot1 FE is done
-  uint32_t wait = 0;
-  while(proc->chan_est_slot1_available == 0)
-    {
-      usleep(1);
-      wait++;
-    }
-
-#if UE_TIMING_TRACE
-  stop_meas(&ue->ue_front_end_stat[ue->current_thread_id[nr_tti_rx]]);
-#if DISABLE_LOG_X
-  printf("[AbsSFN %d.%d] FULL FE Processing %5.2f \n",frame_rx,nr_tti_rx,ue->ue_front_end_per_slot_stat[ue->current_thread_id[nr_tti_rx]][0].p_time/(cpuf*1000.0));
-#else
-  LOG_D(PHY, "[AbsSFN %d.%d] FULL FE Processing %5.2f \n",frame_rx,nr_tti_rx,ue->ue_front_end_per_slot_stat[ue->current_thread_id[nr_tti_rx]][0].p_time/(cpuf*1000.0));
-#endif
-#endif
-  /**** End nr_tti_rx FE Processing ****/
-
-
-#if 0
-  //Trigger LLR parallelized for Slot 1
-  proc->dci_slot0_available=1;
-  printf("Set available dci slot0 to 1 AbsSubframe %d.%d \n",frame_rx%1024,nr_tti_rx);
-#endif
-
-  /**** Pdsch Procedure Slot0 ****/
-  // start main thread for Pdsch Procedure (slot0)
-  // do procedures for C-RNTI
-  //printf("AbsSubframe %d.%d Pdsch Procedure (slot0)\n",frame_rx%1024,nr_tti_rx);
-  //printf("AbsSubframe %d.%d Pdsch Procedure PDSCH Active %d \n",frame_rx%1024,nr_tti_rx, ue->dlsch[ue->current_thread_id[nr_tti_rx]][0][0]->active);
-
-#if UE_TIMING_TRACE
-  start_meas(&ue->pdsch_procedures_stat[ue->current_thread_id[nr_tti_rx]]);
-#endif
-
-#if UE_TIMING_TRACE
-  start_meas(&ue->pdsch_procedures_per_slot_stat[ue->current_thread_id[nr_tti_rx]][0]);
-#endif
-  if (ue->dlsch[ue->current_thread_id[nr_tti_rx]][eNB_id][0]->active == 1) {
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDSCH_PROC, VCD_FUNCTION_IN);
-    ue_pdsch_procedures(ue,
-			proc,
-			eNB_id,
-			PDSCH,
-			ue->dlsch[ue->current_thread_id[nr_tti_rx]][eNB_id][0],
-			NULL,
-			ue->pdcch_vars[ue->current_thread_id[nr_tti_rx]][eNB_id]->num_pdcch_symbols,
-			(ue->frame_parms.symbols_per_tti>>1)-1,
-			abstraction_flag);
-
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDSCH_PROC, VCD_FUNCTION_OUT);
-  }
-
-  // do procedures for SI-RNTI
-  if ((ue->dlsch_SI[eNB_id]) && (ue->dlsch_SI[eNB_id]->active == 1)) {
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDSCH_PROC_SI, VCD_FUNCTION_IN);
-    ue_pdsch_procedures(ue,
-			proc,
-			eNB_id,
-			SI_PDSCH,
-			ue->dlsch_SI[eNB_id],
-			NULL,
-			ue->pdcch_vars[ue->current_thread_id[nr_tti_rx]][eNB_id]->num_pdcch_symbols,
-			(ue->frame_parms.symbols_per_tti>>1)-1,
-			abstraction_flag);
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDSCH_PROC_SI, VCD_FUNCTION_OUT);
-  }
-
-  // do procedures for SI-RNTI
-  if ((ue->dlsch_p[eNB_id]) && (ue->dlsch_p[eNB_id]->active == 1)) {
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDSCH_PROC_P, VCD_FUNCTION_IN);
-    ue_pdsch_procedures(ue,
-			proc,
-			eNB_id,
-			P_PDSCH,
-			ue->dlsch_p[eNB_id],
-			NULL,
-			ue->pdcch_vars[ue->current_thread_id[nr_tti_rx]][eNB_id]->num_pdcch_symbols,
-			(ue->frame_parms.symbols_per_tti>>1)-1,
-			abstraction_flag);
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDSCH_PROC_P, VCD_FUNCTION_OUT);
-  }
-
-  // do procedures for RA-RNTI
-  if ((ue->dlsch_ra[eNB_id]) && (ue->dlsch_ra[eNB_id]->active == 1)) {
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDSCH_PROC_RA, VCD_FUNCTION_IN);
-    ue_pdsch_procedures(ue,
-			proc,
-			eNB_id,
-			RA_PDSCH,
-			ue->dlsch_ra[eNB_id],
-			NULL,
-			ue->pdcch_vars[ue->current_thread_id[nr_tti_rx]][eNB_id]->num_pdcch_symbols,
-			(ue->frame_parms.symbols_per_tti>>1)-1,
-			abstraction_flag);
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDSCH_PROC_RA, VCD_FUNCTION_OUT);
-  }
-
-#if 1
-  // LLR linear
-  proc->dci_slot0_available=1;
-  //printf("Set available dci slot0 to 1 AbsSubframe %d.%d \n",frame_rx%1024,nr_tti_rx);
-#endif
-
-#if UE_TIMING_TRACE
-  stop_meas(&ue->pdsch_procedures_per_slot_stat[ue->current_thread_id[nr_tti_rx]][0]);
-#if DISABLE_LOG_X
-  printf("[AbsSFN %d.%d] Slot0: LLR Computation %5.2f \n",frame_rx,nr_tti_rx,ue->pdsch_procedures_per_slot_stat[ue->current_thread_id[nr_tti_rx]][0].p_time/(cpuf*1000.0));
-#else
-  LOG_D(PHY, "[AbsSFN %d.%d] Slot0: LLR Computation %5.2f \n",frame_rx,nr_tti_rx,ue->pdsch_procedures_per_slot_stat[ue->current_thread_id[nr_tti_rx]][0].p_time/(cpuf*1000.0));
-#endif
-#endif
-
-
-  //wait until LLR Slot1 is done
-  wait = 0;
-  while(proc->llr_slot1_available == 0)
-    {
-      usleep(1);
-      wait++;
-    }
-
-
-
-#if UE_TIMING_TRACE
-  stop_meas(&ue->pdsch_procedures_stat[ue->current_thread_id[nr_tti_rx]]);
-#if DISABLE_LOG_X
-  printf("[AbsSFN %d.%d] Full LLR Computation %5.2f \n",frame_rx,nr_tti_rx,ue->pdsch_procedures_stat[ue->current_thread_id[nr_tti_rx]].p_time/(cpuf*1000.0));
-#else
-  LOG_D(PHY, "[AbsSFN %d.%d] Full LLR Computation %5.2f \n",frame_rx,nr_tti_rx,ue->pdsch_procedures_stat[ue->current_thread_id[nr_tti_rx]].p_time/(cpuf*1000.0));
-#endif
-#endif
-  //printf("[slot0 dl processing] AbsSubframe %d.%d Channel Decoder Start wait %d\n",frame_rx,nr_tti_rx,wait);
-
-
-  //=====================================================================//
-#if UE_TIMING_TRACE
-  start_meas(&ue->dlsch_procedures_stat[ue->current_thread_id[nr_tti_rx]]);
-#endif
-
-  LOG_D(PHY,"==> Start Turbo Decoder active dlsch %d SI %d RA %d \n",ue->dlsch[ue->current_thread_id[nr_tti_rx]][eNB_id][0]->active,
-	ue->dlsch_SI[eNB_id]->active,
-	//ue->dlsch_p[eNB_id]->active,
-	ue->dlsch_ra[eNB_id]->active);
-  // Start Turbo decoder
-  if (ue->dlsch[ue->current_thread_id[nr_tti_rx]][eNB_id][0]->active == 1) {
-    //VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDSCH_PROC, VCD_FUNCTION_IN);
-    ue_dlsch_procedures(ue,
-			proc,
-			eNB_id,
-			PDSCH,
-			ue->dlsch[ue->current_thread_id[nr_tti_rx]][eNB_id][0],
-			ue->dlsch[ue->current_thread_id[nr_tti_rx]][eNB_id][1],
-			&ue->dlsch_errors[eNB_id],
-			mode,
-			abstraction_flag);
-    //VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDSCH_PROC, VCD_FUNCTION_OUT);
-  }
-
-  // do procedures for SI-RNTI
-  if ((ue->dlsch_SI[eNB_id]) && (ue->dlsch_SI[eNB_id]->active == 1)) {
-    ue_dlsch_procedures(ue,
-			proc,
-			eNB_id,
-			SI_PDSCH,
-			ue->dlsch_SI[eNB_id],
-			NULL,
-			&ue->dlsch_SI_errors[eNB_id],
-			mode,
-			abstraction_flag);
-    ue->dlsch_SI[eNB_id]->active = 0;
-  }
-
-  // do procedures for P-RNTI
-  if ((ue->dlsch_p[eNB_id]) && (ue->dlsch_p[eNB_id]->active == 1)) {
-    ue_dlsch_procedures(ue,
-			proc,
-			eNB_id,
-			P_PDSCH,
-			ue->dlsch_p[eNB_id],
-			NULL,
-			&ue->dlsch_p_errors[eNB_id],
-			mode,
-			abstraction_flag);
-    ue->dlsch_p[eNB_id]->active = 0;
-  }
-  // do procedures for RA-RNTI
-  if ((ue->dlsch_ra[eNB_id]) && (ue->dlsch_ra[eNB_id]->active == 1)) {
-    ue_dlsch_procedures(ue,
-			proc,
-			eNB_id,
-			RA_PDSCH,
-			ue->dlsch_ra[eNB_id],
-			NULL,
-			&ue->dlsch_ra_errors[eNB_id],
-			mode,
-			abstraction_flag);
-    ue->dlsch_ra[eNB_id]->active = 0;
-  }
-
-#if UE_TIMING_TRACE
-  stop_meas(&ue->dlsch_procedures_stat[ue->current_thread_id[nr_tti_rx]]);
-#if DISABLE_LOG_X
-  printf("[AbsSFN %d.%d] Channel Decoder: %5.2f \n",frame_rx,nr_tti_rx,ue->dlsch_procedures_stat[ue->current_thread_id[nr_tti_rx]].p_time/(cpuf*1000.0));
-#else
-  LOG_D(PHY, "[AbsSFN %d.%d] Channel Decoder: %5.2f \n",frame_rx,nr_tti_rx,ue->dlsch_procedures_stat[ue->current_thread_id[nr_tti_rx]].p_time/(cpuf*1000.0));
-#endif
-
-#endif
-
-  // duplicate harq structure
-  uint8_t          current_harq_pid        = ue->dlsch[ue->current_thread_id[nr_tti_rx]][eNB_id][0]->current_harq_pid;
-  NR_DL_UE_HARQ_t *current_harq_processes = ue->dlsch[ue->current_thread_id[nr_tti_rx]][eNB_id][0]->harq_processes[current_harq_pid];
-  nr_harq_status_t    *current_harq_ack       = &ue->dlsch[ue->current_thread_id[nr_tti_rx]][eNB_id][0]->harq_ack[nr_tti_rx];
-
-  // For Debug parallelisation
-  //if (current_harq_ack->ack == 0) {
-  //printf("[slot0 dl processing][End of Channel Decoding] AbsSubframe %d.%d Decode Fail for HarqId%d Round%d\n",frame_rx,nr_tti_rx,current_harq_pid,current_harq_processes->round);
-  //}
-  for(uint8_t rx_th_idx=1; rx_th_idx<RX_NB_TH; rx_th_idx++)
-    {
-      NR_DL_UE_HARQ_t *harq_processes_dest  = ue->dlsch[ue->current_thread_id[(nr_tti_rx+rx_th_idx)%10]][eNB_id][0]->harq_processes[current_harq_pid];
-      nr_harq_status_t    *harq_ack_dest        = &ue->dlsch[ue->current_thread_id[(nr_tti_rx+rx_th_idx)%10]][eNB_id][0]->harq_ack[nr_tti_rx];
-
-      copy_harq_proc_struct(harq_processes_dest, current_harq_processes);
-      copy_ack_struct(harq_ack_dest, current_harq_ack);
-
-    }
-  /*
-    NR_DL_UE_HARQ_t *harq_processes_dest    = ue->dlsch[(nr_tti_rx+1)%RX_NB_TH][eNB_id][0]->harq_processes[current_harq_pid];
-    NR_DL_UE_HARQ_t *harq_processes_dest1    = ue->dlsch[(nr_tti_rx+2)%RX_NB_TH][eNB_id][0]->harq_processes[current_harq_pid];
-
-    nr_harq_status_t *current_harq_ack = &ue->dlsch[nr_tti_rx%RX_NB_TH][eNB_id][0]->harq_ack[nr_tti_rx];
-    nr_harq_status_t *harq_ack_dest    = &ue->dlsch[(nr_tti_rx+1)%RX_NB_TH][eNB_id][0]->harq_ack[nr_tti_rx];
-    nr_harq_status_t *harq_ack_dest1    = &ue->dlsch[(nr_tti_rx+2)%RX_NB_TH][eNB_id][0]->harq_ack[nr_tti_rx];
-
-    copy_harq_proc_struct(harq_processes_dest, current_harq_processes);
-    copy_ack_struct(harq_ack_dest, current_harq_ack);
-
-    copy_harq_proc_struct(harq_processes_dest1, current_harq_processes);
-    copy_ack_struct(harq_ack_dest1, current_harq_ack);
-  */
-  if (nr_tti_rx==9) {
-    if (frame_rx % 10 == 0) {
-      if ((ue->dlsch_received[eNB_id] - ue->dlsch_received_last[eNB_id]) != 0)
-	ue->dlsch_fer[eNB_id] = (100*(ue->dlsch_errors[eNB_id] - ue->dlsch_errors_last[eNB_id]))/(ue->dlsch_received[eNB_id] - ue->dlsch_received_last[eNB_id]);
-
-      ue->dlsch_errors_last[eNB_id] = ue->dlsch_errors[eNB_id];
-      ue->dlsch_received_last[eNB_id] = ue->dlsch_received[eNB_id];
-    }
-
-
-    ue->bitrate[eNB_id] = (ue->total_TBS[eNB_id] - ue->total_TBS_last[eNB_id])*100;
-    ue->total_TBS_last[eNB_id] = ue->total_TBS[eNB_id];
-    LOG_D(PHY,"[UE %d] Calculating bitrate Frame %d: total_TBS = %d, total_TBS_last = %d, bitrate %f kbits\n",
-	  ue->Mod_id,frame_rx,ue->total_TBS[eNB_id],
-	  ue->total_TBS_last[eNB_id],(float) ue->bitrate[eNB_id]/1000.0);
-
-#if UE_AUTOTEST_TRACE
-    if ((frame_rx % 100 == 0)) {
-      LOG_I(PHY,"[UE  %d] AUTOTEST Metric : UE_DLSCH_BITRATE = %5.2f kbps (frame = %d) \n", ue->Mod_id, (float) ue->bitrate[eNB_id]/1000.0, frame_rx);
-    }
-#endif
-
-  }
-
-#ifdef EMOS
-  phy_procedures_emos_UE_RX(ue,slot,eNB_id);
-#endif
-
-
-  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_UE_RX, VCD_FUNCTION_OUT);
-
-#if UE_TIMING_TRACE
-  stop_meas(&ue->phy_proc_rx[ue->current_thread_id[nr_tti_rx]]);
-#if DISABLE_LOG_X
-  printf("------FULL RX PROC [AbsSFN %d.%d]: %5.2f ------\n",frame_rx,nr_tti_rx,ue->phy_proc_rx[ue->current_thread_id[nr_tti_rx]].p_time/(cpuf*1000.0));
-#else
-  LOG_D(PHY, "------FULL RX PROC [AbsSFN %d.%d]: %5.2f ------\n",frame_rx,nr_tti_rx,ue->phy_proc_rx[ue->current_thread_id[nr_tti_rx]].p_time/(cpuf*1000.0));
-#endif
-#endif
-
-  LOG_D(PHY," ****** end RX-Chain  for AbsSubframe %d.%d ******  \n", frame_rx%1024, nr_tti_rx);
-  return (0);
-}
-#endif
-
-
-int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eNB_id,
-			   uint8_t do_pdcch_flag,runmode_t mode) {
-
-
-
-  int l,l2;
-  int pilot1;
 
+int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,
+						   UE_nr_rxtx_proc_t *proc,
+						   uint8_t eNB_id,
+						   uint8_t do_pdcch_flag,
+						   runmode_t mode)
+{
   int frame_rx = proc->frame_rx;
   int nr_tti_rx = proc->nr_tti_rx;
   NR_UE_PDCCH *pdcch_vars  = ue->pdcch_vars[ue->current_thread_id[nr_tti_rx]][0];
-  uint16_t nb_symb_sch = 8; // to be updated by higher layer
+  NR_UE_DLSCH_t   **dlsch = ue->dlsch[ue->current_thread_id[nr_tti_rx]][eNB_id];
+  uint8_t harq_pid = ue->dlsch[ue->current_thread_id[nr_tti_rx]][eNB_id][0]->current_harq_pid;
+  NR_DL_UE_HARQ_t *dlsch0_harq = dlsch[0]->harq_processes[harq_pid];
+  uint16_t nb_symb_sch = dlsch0_harq->nb_symbols;
   uint8_t nb_symb_pdcch = pdcch_vars->coreset[0].duration;
+  uint8_t dci_cnt = 0;
   
   LOG_D(PHY," ****** start RX-Chain for Frame.Slot %d.%d ******  \n", frame_rx%1024, nr_tti_rx);
 
+  /*
   uint8_t next1_thread_id = ue->current_thread_id[nr_tti_rx]== (RX_NB_TH-1) ? 0:(ue->current_thread_id[nr_tti_rx]+1);
   uint8_t next2_thread_id = next1_thread_id== (RX_NB_TH-1) ? 0:(next1_thread_id+1);
+  */
+
+  uint8_t coreset_start=0, coreset_start_set=0;
+  uint16_t coreset_count = 0;
+  uint64_t coreset_freq_dom  = pdcch_vars->coreset[0].frequencyDomainResources;
+  for (int i = 0; i < 45; i++) {
+    if (((coreset_freq_dom & 0x1FFFFFFFFFFF) >> (44-i)) & 0x1) {
+      if (!coreset_start_set) {
+        coreset_start = i;
+        coreset_start_set = 1;
+      }
+      coreset_count++;
+    }
+  }
+  uint16_t coreset_nb_rb = 6 * coreset_count;
+  uint16_t coreset_start_rb = 6 * coreset_start;
 
 #ifdef NR_PDCCH_SCHED
   nr_gold_pdcch(ue,0, 2);
-  
-  //if (nr_tti_rx==1){
+
   LOG_D(PHY," ------ --> PDCCH ChannelComp/LLR Frame.slot %d.%d ------  \n", frame_rx%1024, nr_tti_rx);
   for (uint16_t l=0; l<nb_symb_pdcch; l++) {
     
@@ -4990,28 +4383,48 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eN
 		l,
 		nr_tti_rx,
 		0,
-		0,
-		1,
-		NR_PDCCH_EST);
+		0);
+
+    nr_pdcch_channel_estimation(ue,0,
+				nr_tti_rx,
+				l,
+				ue->frame_parms.first_carrier_offset+coreset_start_rb*12,
+				coreset_nb_rb);
+
+    
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SLOT_FEP, VCD_FUNCTION_OUT);
 #if UE_TIMING_TRACE
     stop_meas(&ue->ofdm_demod_stats);
 #endif
     
     //printf("phy procedure pdcch start measurement l =%d\n",l);
-    nr_ue_measurement_procedures(l,ue,proc,eNB_id,(nr_tti_rx),mode);
+    //nr_ue_measurement_procedures(l,ue,proc,eNB_id,(nr_tti_rx),mode);
       
   }
 
-  if (nr_ue_pdcch_procedures(eNB_id,ue,proc) == -1) {
-    LOG_E(PHY,"[UE  %d] Frame %d, nr_tti_rx %d: Error in pdcch procedures\n",ue->Mod_id,frame_rx,nr_tti_rx);
-    return(-1);
+  dci_cnt = nr_ue_pdcch_procedures(eNB_id,ue,proc);
+
+  if (dci_cnt > 0) {
+
+    LOG_I(PHY,"[UE  %d] Frame %d, nr_tti_rx %d: found %d DCIs\n",ue->Mod_id,frame_rx,nr_tti_rx,dci_cnt);
+    
+    if (ue->no_timing_correction==0) {
+      LOG_I(PHY,"start adjust sync slot = %d no timing %d\n", nr_tti_rx, ue->no_timing_correction);
+      nr_adjust_synch_ue(&ue->frame_parms,
+			 ue,
+			 eNB_id,
+			 nr_tti_rx,
+			 0,
+			 16384);
+    }
+  }
+  else {
+    LOG_D(PHY,"[UE  %d] Frame %d, nr_tti_rx %d: No DCIs found\n",ue->Mod_id,frame_rx,nr_tti_rx);
   }
-  //}
 #endif //NR_PDCCH_SCHED
 
   
-  if (nr_tti_rx==1){
+  if (dci_cnt > 0){
     LOG_D(PHY," ------ --> PDSCH ChannelComp/LLR Frame.slot %d.%d ------  \n", frame_rx%1024, nr_tti_rx);
     //to update from pdsch config
     nr_gold_pdsch(ue,nb_symb_pdcch,0, 1);
@@ -5021,16 +4434,14 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eN
 		  m,  //to be updated from higher layer
 		  nr_tti_rx,
 		  0,
-		  0,
-		  1,
-		  NR_PDSCH_EST);
+		  0);
       
       //printf("phy procedure pdsch start measurement\n"); 
       nr_ue_measurement_procedures(m,ue,proc,eNB_id,(nr_tti_rx<<1),mode);
       
     }
     //set active for testing, to be removed
-    ue->dlsch[ue->current_thread_id[nr_tti_rx]][eNB_id][0]->active = 0;
+    ue->dlsch[ue->current_thread_id[nr_tti_rx]][eNB_id][0]->active = 1;
   }
   else 
     ue->dlsch[ue->current_thread_id[nr_tti_rx]][eNB_id][0]->active = 0;
@@ -5046,10 +4457,17 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eN
 			   eNB_id,
 			   PDSCH,
 			   ue->dlsch[ue->current_thread_id[nr_tti_rx]][eNB_id][0],
-			   NULL,
-			   nb_symb_pdcch, //ue->pdcch_vars[ue->current_thread_id[nr_tti_rx]][eNB_id]->num_pdcch_symbols,
-			   (nb_symb_sch+nb_symb_pdcch-1)); //ue->frame_parms.symbols_per_tti>>1,
+			   NULL);
 
+    /*
+    write_output("rxF.m","rxF",&ue->common_vars.common_vars_rx_data_per_thread[ue->current_thread_id[nr_tti_rx]].rxdataF[0][0],ue->frame_parms.ofdm_symbol_size*14,1,1);
+    write_output("rxF_ch.m","rxFch",&ue->pdsch_vars[ue->current_thread_id[nr_tti_rx]][eNB_id]->dl_ch_estimates[0][0],ue->frame_parms.ofdm_symbol_size*14,1,1);
+    write_output("rxF_ch_ext.m","rxFche",&ue->pdsch_vars[ue->current_thread_id[nr_tti_rx]][eNB_id]->dl_ch_estimates_ext[0][2*50*12],50*12,1,1);
+    write_output("rxF_ext.m","rxFe",&ue->pdsch_vars[ue->current_thread_id[nr_tti_rx]][eNB_id]->rxdataF_ext[0][0],50*12*14,1,1);
+    write_output("rxF_comp.m","rxFc",&ue->pdsch_vars[ue->current_thread_id[nr_tti_rx]][eNB_id]->rxdataF_comp0[0][0],ue->frame_parms.N_RB_DL*12*14,1,1);
+    write_output("rxF_llr.m","rxFllr",ue->pdsch_vars[ue->current_thread_id[nr_tti_rx]][eNB_id]->llr[0],(nb_symb_sch-1)*50*12+50*6,1,0);
+    */
+    
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDSCH_PROC, VCD_FUNCTION_OUT);
   }
 
@@ -5061,9 +4479,8 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eN
 			   eNB_id,
 			   SI_PDSCH,
 			   ue->dlsch_SI[eNB_id],
-			   NULL,
-			   ue->pdcch_vars[ue->current_thread_id[nr_tti_rx]][eNB_id]->num_pdcch_symbols,
-			   ue->frame_parms.symbols_per_tti>>1);
+			   NULL);
+    
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDSCH_PROC_SI, VCD_FUNCTION_OUT);
   }
 
@@ -5075,9 +4492,8 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eN
 			   eNB_id,
 			   P_PDSCH,
 			   ue->dlsch_p[eNB_id],
-			   NULL,
-			   ue->pdcch_vars[ue->current_thread_id[nr_tti_rx]][eNB_id]->num_pdcch_symbols,
-			   ue->frame_parms.symbols_per_tti>>1);
+			   NULL);
+
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDSCH_PROC_P, VCD_FUNCTION_OUT);
   }
 
@@ -5089,9 +4505,8 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eN
 			   eNB_id,
 			   RA_PDSCH,
 			   ue->dlsch_ra[eNB_id],
-			   NULL,
-			   ue->pdcch_vars[ue->current_thread_id[nr_tti_rx]][eNB_id]->num_pdcch_symbols,
-			   ue->frame_parms.symbols_per_tti>>1);
+			   NULL);
+
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDSCH_PROC_RA, VCD_FUNCTION_OUT);
   }
 
@@ -5100,15 +4515,26 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eN
   if ( (nr_tti_rx == 0) && (ue->decode_MIB == 1))
     {
       LOG_D(PHY," ------  PBCH ChannelComp/LLR: frame.slot %d.%d ------  \n", frame_rx%1024, nr_tti_rx);
-      for (int i=0; i<3; i++)
+
+      uint8_t i_ssb = ue->rx_ind.rx_indication_body[0].mib_pdu.ssb_index;
+      uint8_t n_hf = (((ue->rx_ind.rx_indication_body[0].mib_pdu.additional_bits)>>4)&0x01);
+
+      for (int i=1; i<4; i++) {
 	nr_slot_fep(ue,
-		    (5+i), //mu=1 case B
+		    (ue->symbol_offset+i), //mu=1 case B
 		    nr_tti_rx,
 		    0,
-		    0,
-		    1,
-		    NR_PBCH_EST);
+		    0);
+
+#if UE_TIMING_TRACE
+  	start_meas(&ue->dlsch_channel_estimation_stats);
+#endif
+   	nr_pbch_channel_estimation(ue,0,0,ue->symbol_offset+i,i-1,i_ssb,n_hf);
+#if UE_TIMING_TRACE
+  	stop_meas(&ue->dlsch_channel_estimation_stats);
+#endif
       
+      }
       nr_ue_pbch_procedures(eNB_id,ue,proc,0);
     }
   
@@ -5116,28 +4542,11 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eN
   if (ue->dlsch[ue->current_thread_id[nr_tti_rx]][eNB_id][0]->active == 1) {
     
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDSCH_PROC, VCD_FUNCTION_IN);
+
 #if UE_TIMING_TRACE
-    
-    start_meas(&ue->pdsch_procedures_stat[ue->current_thread_id[nr_tti_rx]]);
-#endif
-    /*nr_ue_pdsch_procedures(ue,
-      proc,
-      eNB_id,
-			PDSCH,
-			ue->dlsch[ue->current_thread_id[nr_tti_rx]][eNB_id][0],
-			NULL,
-			1+(ue->frame_parms.symbols_per_tti>>1),
-			ue->frame_parms.symbols_per_tti-1,
-			abstraction_flag);
-    LOG_D(PHY," ------ end PDSCH ChannelComp/LLR slot 0: AbsSubframe %d.%d ------  \n", frame_rx%1024, nr_tti_rx);
-    LOG_D(PHY," ------ --> PDSCH Turbo Decoder slot 0/1: AbsSubframe %d.%d ------  \n", frame_rx%1024, nr_tti_rx);*/
-#if UE_TIMING_TRACE
-    stop_meas(&ue->pdsch_procedures_stat[ue->current_thread_id[nr_tti_rx]]);
     start_meas(&ue->dlsch_procedures_stat[ue->current_thread_id[nr_tti_rx]]);
 #endif
 
-//#endif //slot 1
-
     nr_ue_dlsch_procedures(ue,
 			   proc,
 			   eNB_id,
@@ -5195,9 +4604,7 @@ start_meas(&ue->generic_stat);
 			   eNB_id,
 			   SI_PDSCH,
 			   ue->dlsch_SI[eNB_id],
-			   NULL,
-			   1+(ue->frame_parms.symbols_per_tti>>1),
-			   ue->frame_parms.symbols_per_tti-1);
+			   NULL);
 
     /*ue_dlsch_procedures(ue,
       proc,
@@ -5218,9 +4625,7 @@ start_meas(&ue->generic_stat);
 			   eNB_id,
 			   P_PDSCH,
 			   ue->dlsch_p[eNB_id],
-			   NULL,
-			   1+(ue->frame_parms.symbols_per_tti>>1),
-			   ue->frame_parms.symbols_per_tti-1);
+			   NULL);
 
 
     /*ue_dlsch_procedures(ue,
@@ -5241,9 +4646,7 @@ start_meas(&ue->generic_stat);
 			   eNB_id,
 			   RA_PDSCH,
 			   ue->dlsch_ra[eNB_id],
-			   NULL,
-			   1+(ue->frame_parms.symbols_per_tti>>1),
-			   ue->frame_parms.symbols_per_tti-1);
+			   NULL);
 
     /*ue_dlsch_procedures(ue,
       proc,
@@ -5258,21 +4661,21 @@ start_meas(&ue->generic_stat);
   }
 
   // duplicate harq structure
-
+  /*
   uint8_t          current_harq_pid        = ue->dlsch[ue->current_thread_id[nr_tti_rx]][eNB_id][0]->current_harq_pid;
   NR_DL_UE_HARQ_t *current_harq_processes = ue->dlsch[ue->current_thread_id[nr_tti_rx]][eNB_id][0]->harq_processes[current_harq_pid];
   NR_DL_UE_HARQ_t *harq_processes_dest    = ue->dlsch[next1_thread_id][eNB_id][0]->harq_processes[current_harq_pid];
   NR_DL_UE_HARQ_t *harq_processes_dest1    = ue->dlsch[next2_thread_id][eNB_id][0]->harq_processes[current_harq_pid];
-
+  */
   /*nr_harq_status_t *current_harq_ack = &ue->dlsch[ue->current_thread_id[nr_tti_rx]][eNB_id][0]->harq_ack[nr_tti_rx];
   nr_harq_status_t *harq_ack_dest    = &ue->dlsch[next1_thread_id][eNB_id][0]->harq_ack[nr_tti_rx];
   nr_harq_status_t *harq_ack_dest1    = &ue->dlsch[next2_thread_id][eNB_id][0]->harq_ack[nr_tti_rx];
 */
 
-copy_harq_proc_struct(harq_processes_dest, current_harq_processes);
+  //copy_harq_proc_struct(harq_processes_dest, current_harq_processes);
 //copy_ack_struct(harq_ack_dest, current_harq_ack);
 
-copy_harq_proc_struct(harq_processes_dest1, current_harq_processes);
+//copy_harq_proc_struct(harq_processes_dest1, current_harq_processes);
 //copy_ack_struct(harq_ack_dest1, current_harq_ack);
 
 if (nr_tti_rx==9) {
@@ -5327,185 +4730,6 @@ return (0);
 }
 
 
-#if 0
-#if defined(Rel10) || defined(Rel14)
-
-int phy_procedures_RN_UE_RX(uint8_t slot_rx, uint8_t next_slot, relaying_type_t r_type)
-{
-
-  int do_proc =0; // do nothing by default
-
-  switch(r_type) {
-  case no_relay:
-    do_proc=no_relay; // perform the normal UE operation
-    break;
-
-  case multicast_relay:
-    if (slot_rx > 12)
-      do_proc = 0; // do nothing
-    else // SF#1, SF#2, SF3, SF#3, SF#4, SF#5, SF#6(do rx slot 12)
-      do_proc = multicast_relay ; // do PHY procedures UE RX
-
-    break;
-
-  default: // should'not be here
-    LOG_W(PHY,"Not supported relay type %d, do nothing \n", r_type);
-    do_proc= 0;
-    break;
-  }
-
-  return do_proc;
-}
-#endif
-
-void phy_procedures_UE_lte(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eNB_id,uint8_t abstraction_flag,uint8_t do_pdcch_flag,runmode_t mode,
-			   relaying_type_t r_type)
-{
-#if defined(ENABLE_ITTI)
-  MessageDef   *msg_p;
-  const char   *msg_name;
-  instance_t    instance;
-  unsigned int  Mod_id;
-  int           result;
-#endif
-
-  int           frame_rx = proc->frame_rx;
-  int           frame_tx = proc->frame_tx;
-  int           nr_tti_rx = proc->nr_tti_rx;
-  int           nr_tti_tx = proc->nr_tti_tx;
-  //#ifdef UE_NR_PHY_DEMO
-  //  int           nr_tti_rx = proc->nr_tti_rx;
-  //  int           nr_tti_tx = proc->nr_tti_tx;
-  //#endif
-
-#undef DEBUG_PHY_PROC
-
-  UE_L2_STATE_t ret;
-  int slot;
-
-  if (ue->mac_enabled == 0) {
-    ue->UE_mode[eNB_id]=PUSCH;
-  }
-
-
-  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_UE_LTE,1);
-#if UE_TIMING_TRACE
-  start_meas(&ue->phy_proc[ue->current_thread_id[nr_tti_rx]]);
-#endif
-#if defined(ENABLE_ITTI)
-
-  do {
-    // Checks if a message has been sent to PHY sub-task
-    itti_poll_msg (TASK_PHY_UE, &msg_p);
-
-    if (msg_p != NULL) {
-      msg_name = ITTI_MSG_NAME (msg_p);
-      instance = ITTI_MSG_INSTANCE (msg_p);
-      Mod_id = instance - NB_eNB_INST;
-
-      switch (ITTI_MSG_ID(msg_p)) {
-      case PHY_FIND_CELL_REQ:
-	LOG_I(PHY, "[UE %d] Received %s\n", Mod_id, msg_name);
-
-	/* TODO process the message */
-	break;
-
-      default:
-	LOG_E(PHY, "[UE %d] Received unexpected message %s\n", Mod_id, msg_name);
-	break;
-      }
-
-      result = itti_free (ITTI_MSG_ORIGIN_ID(msg_p), msg_p);
-      AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result);
-    }
-  } while(msg_p != NULL);
-
-#endif
-
-  for (slot=0;slot<2;slot++) {
-
-    if ((nr_subframe_select(&ue->frame_parms,nr_tti_tx)==SF_UL)||
-	(ue->frame_parms.frame_type == FDD)) {
-      phy_procedures_UE_TX(ue,proc,eNB_id,abstraction_flag,mode,r_type);
-    }
-
-    if ((nr_subframe_select(&ue->frame_parms,nr_tti_rx)==SF_DL) ||
-	(ue->frame_parms.frame_type == FDD)) {
-#if defined(Rel10) || defined(Rel14)
-
-      if (phy_procedures_RN_UE_RX(nr_tti_rx, nr_tti_tx, r_type) != 0 )
-#endif
-	phy_procedures_UE_RX(ue,proc,eNB_id,abstraction_flag,do_pdcch_flag,mode,r_type);
-    }
-
-    if ((nr_subframe_select(&ue->frame_parms,nr_tti_tx)==SF_S) &&
-	(slot==1)) {
-      phy_procedures_UE_S_TX(ue,eNB_id,abstraction_flag,r_type);
-    }
-
-    if ((nr_subframe_select(&ue->frame_parms,nr_tti_rx)==SF_S) &&
-	(slot==0)) {
-#if defined(Rel10) || defined(Rel14)
-
-      if (phy_procedures_RN_UE_RX(nr_tti_rx, nr_tti_tx, r_type) != 0 )
-#endif
-	phy_procedures_UE_RX(ue,proc,eNB_id,abstraction_flag,do_pdcch_flag,mode,r_type);
-    }
-
-    if (ue->mac_enabled==1) {
-      if (slot==0) {
-	//#ifdef UE_NR_PHY_DEMO
-        ret = mac_xface->ue_scheduler(ue->Mod_id,
-				      frame_rx,
-				      proc->subframe_rx,
-				      nr_tti_rx%(ue->frame_parms.ttis_per_subframe),
-				      frame_tx,
-				      proc->subframe_tx,
-				      nr_tti_tx%(ue->frame_parms.ttis_per_subframe),
-				      nr_subframe_select(&ue->frame_parms,nr_tti_tx),
-				      eNB_id,
-				      0/*FIXME CC_id*/);
-	//#else
-	/*        ret = mac_xface->ue_scheduler(ue->Mod_id,
-		  frame_rx,
-		  nr_tti_rx,
-		  frame_tx,
-		  nr_tti_tx,
-		  nr_subframe_select(&ue->frame_parms,nr_tti_tx),
-		  eNB_id,*/
-	//            0/*FIXME CC_id*/);
-	//#endif
-
-	if (ret == CONNECTION_LOST) {
-	  LOG_E(PHY,"[UE %d] Frame %d, nr_tti_rx %d RRC Connection lost, returning to PRACH\n",ue->Mod_id,
-		frame_rx,nr_tti_tx);
-	  ue->UE_mode[eNB_id] = PRACH;
-	  //      mac_xface->macphy_exit("Connection lost");
-	} else if (ret == PHY_RESYNCH) {
-	  LOG_E(PHY,"[UE %d] Frame %d, nr_tti_rx %d RRC Connection lost, trying to resynch\n",
-		ue->Mod_id,
-		frame_rx,nr_tti_tx);
-	  ue->UE_mode[eNB_id] = RESYNCH;
-	  //     mac_xface->macphy_exit("Connection lost");
-	} else if (ret == PHY_HO_PRACH) {
-	  LOG_I(PHY,"[UE %d] Frame %d, nr_tti_rx %d, return to PRACH and perform a contention-free access\n",
-		ue->Mod_id,frame_rx,nr_tti_tx);
-	  ue->UE_mode[eNB_id] = PRACH;
-	}
-      }
-    }
-
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_UE_LTE,0);
-#if UE_TIMING_TRACE
-    stop_meas(&ue->phy_proc[ue->current_thread_id[nr_tti_rx]]);
-#endif
-  } // slot
-}
-
-
-
-
-#endif
 
 
 uint8_t is_cqi_TXOp(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t gNB_id)
diff --git a/openair1/SCHED_NR_UE/pucch_power_control_ue_nr.c b/openair1/SCHED_NR_UE/pucch_power_control_ue_nr.c
index debb0d4ed5..296d92969c 100644
--- a/openair1/SCHED_NR_UE/pucch_power_control_ue_nr.c
+++ b/openair1/SCHED_NR_UE/pucch_power_control_ue_nr.c
@@ -67,9 +67,19 @@
 *
 *********************************************************************/
 
-int16_t get_pucch_tx_power_ue(PHY_VARS_NR_UE *ue, uint8_t gNB_id, UE_nr_rxtx_proc_t *proc, pucch_format_nr_t pucch_format,
-                              int nb_of_prbs, int N_sc_ctrl_RB, int N_symb_PUCCH, int O_UCI, int O_SR, int O_CSI, int O_ACK,
-                              int O_CRC, int n_HARQ_ACK) {
+int16_t get_pucch_tx_power_ue(PHY_VARS_NR_UE *ue,
+                              uint8_t gNB_id,
+							  UE_nr_rxtx_proc_t *proc,
+							  pucch_format_nr_t pucch_format,
+							  int nb_of_prbs,
+							  int N_sc_ctrl_RB,
+							  int N_symb_PUCCH,
+							  int O_UCI,
+							  int O_SR,
+							  int O_CSI,
+							  int O_ACK,
+                              int O_CRC,
+							  int n_HARQ_ACK) {
 
   int16_t P_O_NOMINAL_PUCCH = ue->pucch_config_common_nr[gNB_id].p0_nominal;
   PUCCH_PowerControl_t *power_config = &ue->pucch_config_dedicated_nr[gNB_id].pucch_PowerControl;
@@ -147,7 +157,6 @@ int16_t get_pucch_tx_power_ue(PHY_VARS_NR_UE *ue, uint8_t gNB_id, UE_nr_rxtx_pro
     }
   }
 
-  int l = 0;
   int k2;
 
   if (power_config->twoPUCCH_PC_AdjustmentStates > 1) {
@@ -156,11 +165,11 @@ int16_t get_pucch_tx_power_ue(PHY_VARS_NR_UE *ue, uint8_t gNB_id, UE_nr_rxtx_pro
   }
 
   /* response to a detection by the UE of a DCI format 1_0 or DCI format 1_1 */
-  int K_PUCCH = 0;
+  //int K_PUCCH = 0;
   if (O_ACK != 0) {
     /* it assumes that PDCCH is in the first symbol of receive slot FFS TDDO NR */
-    int slots_gap = (proc->nr_tti_tx > proc->nr_tti_rx ? (proc->nr_tti_tx - proc->nr_tti_rx - 1) : ((proc->nr_tti_tx + ue->frame_parms.ttis_per_subframe) - proc->nr_tti_rx - 1));
-    K_PUCCH = (slots_gap * (ue->frame_parms.symbols_per_tti)) - 1;
+    //int slots_gap = (proc->nr_tti_tx > proc->nr_tti_rx ? (proc->nr_tti_tx - proc->nr_tti_rx - 1) : ((proc->nr_tti_tx + ue->frame_parms.ttis_per_subframe) - proc->nr_tti_rx - 1));
+    //K_PUCCH = (slots_gap * (ue->frame_parms.symbols_per_tti)) - 1;
   }
   else {
     /* field k2 is not present - to check k2 of pucch from upper layer FFS TDDO NR */
@@ -189,7 +198,7 @@ int16_t get_pucch_tx_power_ue(PHY_VARS_NR_UE *ue, uint8_t gNB_id, UE_nr_rxtx_pro
        } while(ue->pusch_config.pusch_TimeDomainResourceAllocation[i] != NULL);
       k2 = k2_min;
     }
-    K_PUCCH = N_SYMB_SLOT * k2; /* the product of a number of symbols per slot and the minimum of the values provided by higher layer parameter k2 */
+    //K_PUCCH = N_SYMB_SLOT * k2; /* the product of a number of symbols per slot and the minimum of the values provided by higher layer parameter k2 */
   }
 
   int contributor = (10 * log10((double)(pow(2,(ue->frame_parms.numerology_index)) * nb_of_prbs)));
diff --git a/openair1/SCHED_UE/phy_procedures_lte_ue.c b/openair1/SCHED_UE/phy_procedures_lte_ue.c
index c9ea45f03b..3b24814951 100644
--- a/openair1/SCHED_UE/phy_procedures_lte_ue.c
+++ b/openair1/SCHED_UE/phy_procedures_lte_ue.c
@@ -36,7 +36,7 @@
 #include "PHY/defs_UE.h"
 #include "PHY/phy_extern_ue.h"
 #include <sched.h>
-#include "targets/RT/USER/lte-softmodem.h"
+#include "executables/nr-uesoftmodem.h"
 
 #include "PHY/LTE_UE_TRANSPORT/transport_proto_ue.h"
 #include "SCHED_UE/sched_UE.h"
@@ -5116,13 +5116,13 @@ void phy_procedures_UE_lte(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,u
     if (msg_p != NULL) {
       switch (ITTI_MSG_ID(msg_p)) {
       case PHY_FIND_CELL_REQ:
-  LOG_I(PHY, "[UE %d] Received %s\n", ITTI_MSG_INSTANCE (msg_p) - NB_eNB_INST, ITTI_MSG_NAME (msg_p));
+  LOG_I(PHY, "[UE ] Received %s\n", ITTI_MSG_NAME (msg_p));
 
   /* TODO process the message */
   break;
 
       default:
-  LOG_E(PHY, "[UE %d] Received unexpected message %s\n", ITTI_MSG_INSTANCE (msg_p) - NB_eNB_INST, ITTI_MSG_NAME (msg_p));
+  LOG_E(PHY, "[UE %d] Received unexpected message %s\n", ITTI_MSG_INSTANCE (msg_p) , ITTI_MSG_NAME (msg_p));
   break;
       }
 
diff --git a/openair1/SIMULATION/NR_PHY/dlschsim.c b/openair1/SIMULATION/NR_PHY/dlschsim.c
index 2b36a03e61..0eed21c446 100644
--- a/openair1/SIMULATION/NR_PHY/dlschsim.c
+++ b/openair1/SIMULATION/NR_PHY/dlschsim.c
@@ -103,6 +103,7 @@ void exit_function(const char *file, const char *function, const int line,
 // needed for some functions
 PHY_VARS_NR_UE *PHY_vars_UE_g[1][1] = { { NULL } };
 uint16_t n_rnti = 0x1234;
+openair0_config_t openair0_cfg[MAX_CARDS];
 
 char quantize(double D, double x, unsigned char B) {
 	double qxd;
@@ -131,21 +132,22 @@ int main(int argc, char **argv) {
 	//  int sync_pos, sync_pos_slot;
 	//  FILE *rx_frame_file;
 	FILE *output_fd = NULL;
-	uint8_t write_output_file = 0;
+	//uint8_t write_output_file = 0;
 	//  int subframe_offset;
 	//  char fname[40], vname[40];
 	int trial, n_trials = 1, n_errors = 0, n_false_positive = 0;
-	uint8_t transmission_mode = 1, n_tx = 1, n_rx = 1;
+	uint8_t n_tx = 1, n_rx = 1;
+	//uint8_t transmission_mode = 1;
 	uint16_t Nid_cell = 0;
 	channel_desc_t *gNB2UE;
 	uint8_t extended_prefix_flag = 0;
-	int8_t interf1 = -21, interf2 = -21;
+	//int8_t interf1 = -21, interf2 = -21;
 	FILE *input_fd = NULL, *pbch_file_fd = NULL;
 	//char input_val_str[50],input_val_str2[50];
 	//uint16_t NB_RB=25;
 	SCM_t channel_model = AWGN;  //Rayleigh1_anticorr;
 	uint16_t N_RB_DL = 106, mu = 1;
-	unsigned char frame_type = 0;
+	//unsigned char frame_type = 0;
 	unsigned char pbch_phase = 0;
 	int frame = 0, subframe = 0;
 	int frame_length_complex_samples;
@@ -160,7 +162,7 @@ int main(int argc, char **argv) {
 	//int run_initial_sync=0;
 	int loglvl = OAILOG_WARNING;
 	float target_error_rate = 0.01;
-
+        uint64_t SSB_positions=0x01;
 	uint16_t nb_symb_sch = 12;
 	uint16_t nb_rb = 50;
 	uint8_t Imcs = 9;
@@ -174,9 +176,9 @@ int main(int argc, char **argv) {
 	//logInit();
 	randominit(0);
 
-	while ((c = getopt(argc, argv, "df:hpg:i:j:n:l:m:r:s:S:y:z:N:F:R:P:")) != -1) {
+	while ((c = getopt(argc, argv, "df:hpg:i:j:n:l:m:r:s:S:y:z:M:N:F:R:P:L:")) != -1) {
 		switch (c) {
-		case 'f':
+		/*case 'f':
 			write_output_file = 1;
 			output_fd = fopen(optarg, "w");
 
@@ -185,11 +187,11 @@ int main(int argc, char **argv) {
 				exit(-1);
 			}
 
-			break;
+			break;*/
 
-		case 'd':
+		/*case 'd':
 			frame_type = 1;
-			break;
+			break;*/
 
 		case 'g':
 			switch ((char) *optarg) {
@@ -228,13 +230,13 @@ int main(int argc, char **argv) {
 
 			break;
 
-		case 'i':
+		/*case 'i':
 			interf1 = atoi(optarg);
 			break;
 
 		case 'j':
 			interf2 = atoi(optarg);
-			break;
+			break;*/
 
 		case 'n':
 			n_trials = atoi(optarg);
@@ -285,6 +287,10 @@ int main(int argc, char **argv) {
 
 			break;
 
+	        case 'M':
+      			SSB_positions = atoi(optarg);
+			break;		    
+
 		case 'N':
 			Nid_cell = atoi(optarg);
 			break;
@@ -311,6 +317,10 @@ int main(int argc, char **argv) {
 
 			break;
 
+		case 'L':
+		  loglvl = atoi(optarg);
+		  break;
+
 		case 'm':
 			Imcs = atoi(optarg);
 			break;
@@ -323,32 +333,33 @@ int main(int argc, char **argv) {
 			nb_rb = atoi(optarg);
 			break;
 
-		case 'x':
+		/*case 'x':
 			transmission_mode = atoi(optarg);
-			break;
+			break;*/
 
 		default:
 		case 'h':
 			printf("%s -h(elp) -p(extended_prefix) -N cell_id -f output_filename -F input_filename -g channel_model -n n_frames -t Delayspread -s snr0 -S snr1 -x transmission_mode -y TXant -z RXant -i Intefrence0 -j Interference1 -A interpolation_file -C(alibration offset dB) -N CellId\n", argv[0]);
 			printf("-h This message\n");
 			printf("-p Use extended prefix mode\n");
-			printf("-d Use TDD\n");
+			//printf("-d Use TDD\n");
 			printf("-n Number of frames to simulate\n");
 			printf("-s Starting SNR, runs from SNR0 to SNR0 + 5 dB.  If n_frames is 1 then just SNR is simulated\n");
 			printf("-S Ending SNR, runs from SNR0 to SNR1\n");
 			printf("-t Delay spread for multipath channel\n");
 			printf("-g [A,B,C,D,E,F,G] Use 3GPP SCM (A,B,C,D) or 36-101 (E-EPA,F-EVA,G-ETU) models (ignores delay spread and Ricean factor)\n");
-			printf("-x Transmission mode (1,2,6 for the moment)\n");
+			//printf("-x Transmission mode (1,2,6 for the moment)\n");
 			printf("-y Number of TX antennas used in eNB\n");
 			printf("-z Number of RX antennas used in UE\n");
-			printf("-i Relative strength of first intefering eNB (in dB) - cell_id mod 3 = 1\n");
-			printf("-j Relative strength of second intefering eNB (in dB) - cell_id mod 3 = 2\n");
+			//printf("-i Relative strength of first intefering eNB (in dB) - cell_id mod 3 = 1\n");
+			//printf("-j Relative strength of second intefering eNB (in dB) - cell_id mod 3 = 2\n");
+  		    printf("-M Multiple SSB positions in burst\n");
 			printf("-N Nid_cell\n");
 			printf("-R N_RB_DL\n");
 			printf("-O oversampling factor (1,2,4,8,16)\n");
 			printf("-A Interpolation_filname Run with Abstraction to generate Scatter plot using interpolation polynomial in file\n");
-			//    printf("-C Generate Calibration information for Abstraction (effective SNR adjustment to remove Pe bias w.r.t. AWGN)\n");
-			printf("-f Output filename (.txt format) for Pe/SNR results\n");
+			//printf("-C Generate Calibration information for Abstraction (effective SNR adjustment to remove Pe bias w.r.t. AWGN)\n");
+			//printf("-f Output filename (.txt format) for Pe/SNR results\n");
 			printf("-F Input filename (.txt format) for RX conformance testing\n");
 			exit(-1);
 			break;
@@ -383,7 +394,7 @@ int main(int argc, char **argv) {
 	frame_parms->N_RB_DL = N_RB_DL;
 	frame_parms->Ncp = extended_prefix_flag ? EXTENDED : NORMAL;
 	crcTableInit();
-	nr_phy_config_request_sim(gNB, N_RB_DL, N_RB_DL, mu, Nid_cell);
+	nr_phy_config_request_sim(gNB, N_RB_DL, N_RB_DL, mu, Nid_cell,SSB_positions);
 	phy_init_nr_gNB(gNB, 0, 0);
 	//init_eNB_afterRU();
 	frame_length_complex_samples = frame_parms->samples_per_subframe;
@@ -404,7 +415,7 @@ int main(int argc, char **argv) {
 		r_im[i] = malloc(frame_length_complex_samples * sizeof(double));
 		bzero(r_im[i], frame_length_complex_samples * sizeof(double));
 		txdata[i] = malloc(frame_length_complex_samples * sizeof(int));
-		bzero(r_re[i], frame_length_complex_samples * sizeof(int));
+		bzero(r_re[i], frame_length_complex_samples * sizeof(int)); // [hna] r_re should be txdata
 	}
 
 	if (pbch_file_fd != NULL) {
@@ -480,16 +491,16 @@ int main(int argc, char **argv) {
 	rel15->nb_layers = Nl;
 	rel15->nb_re_dmrs = nb_re_dmrs;
 	rel15->transport_block_size = TBS;
-	double *modulated_input = malloc16(sizeof(double) * 16 * 68 * 384);
+	double *modulated_input = malloc16(sizeof(double) * 16 * 68 * 384); // [hna] 16 segments, 68*Zc
 	short *channel_output_fixed = malloc16(sizeof(short) * 16 * 68 * 384);
 	short *channel_output_uncoded = malloc16(sizeof(unsigned short) * 16 * 68 * 384);
 	double errors_bit_uncoded = 0;
-	unsigned char *estimated_output;
+	//unsigned char *estimated_output;
 	unsigned char *estimated_output_bit;
 	unsigned char *test_input_bit;
 	unsigned int errors_bit = 0;
 	test_input_bit = (unsigned char *) malloc16(sizeof(unsigned char) * 16 * 68 * 384);
-	estimated_output = (unsigned char *) malloc16(sizeof(unsigned char) * 16 * 68 * 384);
+	//estimated_output = (unsigned char *) malloc16(sizeof(unsigned char) * 16 * 68 * 384);
 	estimated_output_bit = (unsigned char *) malloc16(sizeof(unsigned char) * 16 * 68 * 384);
 	NR_UE_DLSCH_t *dlsch0_ue = UE->dlsch[0][0][0];
 	NR_DL_UE_HARQ_t *harq_process = dlsch0_ue->harq_processes[harq_pid];
@@ -505,7 +516,7 @@ int main(int argc, char **argv) {
 	for (i = 0; i < TBS / 8; i++)
 		test_input[i] = (unsigned char) rand();
 
-	estimated_output = harq_process->b;
+	//estimated_output = harq_process->b;
 
 #ifdef DEBUG_DLSCHSIM
 	for (i = 0; i < TBS / 8; i++) printf("test_input[i]=%d \n",test_input[i]);
diff --git a/openair1/SIMULATION/NR_PHY/dlsim.c b/openair1/SIMULATION/NR_PHY/dlsim.c
index 7a08ede713..771b6ba7c6 100644
--- a/openair1/SIMULATION/NR_PHY/dlsim.c
+++ b/openair1/SIMULATION/NR_PHY/dlsim.c
@@ -45,15 +45,25 @@
 #include "PHY/NR_UE_TRANSPORT/nr_transport_proto_ue.h"
 
 #include "SCHED_NR/sched_nr.h"
+#include "SCHED_NR/fapi_nr_l1.h"
+#include "SCHED_NR_UE/defs.h"
 #include "SCHED_NR_UE/fapi_nr_ue_l1.h"
 
 #include "LAYER2/NR_MAC_gNB/nr_mac_gNB.h"
 #include "LAYER2/NR_MAC_UE/mac_defs.h"
 #include "LAYER2/NR_MAC_UE/mac_extern.h"
+#include "LAYER2/NR_MAC_UE/mac_proto.h"
+#include "LAYER2/NR_MAC_gNB/mac_proto.h"
 
 #include "NR_PHY_INTERFACE/NR_IF_Module.h"
 #include "NR_UE_PHY_INTERFACE/NR_IF_Module.h"
 
+#include "LAYER2/NR_MAC_UE/mac_proto.h"
+//#include "LAYER2/NR_MAC_gNB/mac_proto.h"
+//#include "openair2/LAYER2/NR_MAC_UE/mac_proto.h"
+#include "openair2/LAYER2/NR_MAC_gNB/mac_proto.h"
+#include "RRC/NR/MESSAGES/asn1_msg.h"
+
 
 PHY_VARS_gNB *gNB;
 PHY_VARS_NR_UE *UE;
@@ -77,8 +87,8 @@ int32_t get_uldl_offset(int nr_bandP) {return(0);}
 
 NR_IF_Module_t *NR_IF_Module_init(int Mod_id){return(NULL);}
 
-int8_t dummy_nr_ue_dl_indication(nr_downlink_indication_t *dl_info){return(0);}
-int8_t dummy_nr_ue_ul_indication(nr_uplink_indication_t *ul_info){return(0);}
+int dummy_nr_ue_dl_indication(nr_downlink_indication_t *dl_info){return(0);}
+int dummy_nr_ue_ul_indication(nr_uplink_indication_t *ul_info){return(0);}
 
 lte_subframe_t subframe_select(LTE_DL_FRAME_PARMS *frame_parms,unsigned char subframe) { return(SF_DL);}
 
@@ -101,7 +111,9 @@ int rrc_init_nr_global_param(void){return(0);}
 
 void config_common(int Mod_idP, 
                    int CC_idP,
+		   int Nid_cell,
                    int nr_bandP,
+		   uint64_t ssb_pattern,
                    uint64_t dl_CarrierFreqP,
                    uint32_t dl_BandwidthP
 		   );
@@ -109,49 +121,54 @@ void config_common(int Mod_idP,
 
 // needed for some functions
 PHY_VARS_NR_UE ***PHY_vars_UE_g;
-uint16_t conjugate[8]__attribute__((aligned(32))) = {-1,1,-1,1,-1,1,-1,1};
+short conjugate[8]__attribute__((aligned(32))) = {-1,1,-1,1,-1,1,-1,1};
+openair0_config_t openair0_cfg[MAX_CARDS];
 
 int main(int argc, char **argv)
 {
 
   char c;
 
-  int i,l,aa;
+  int i,aa;//,l;
   double sigma2, sigma2_dB=10,SNR,snr0=-2.0,snr1=2.0;
   uint8_t snr1set=0;
   int **txdata;
   double **s_re,**s_im,**r_re,**r_im;
-  double iqim = 0.0;
-  unsigned char pbch_pdu[6];
+  //double iqim = 0.0;
+  //unsigned char pbch_pdu[6];
   //  int sync_pos, sync_pos_slot;
   //  FILE *rx_frame_file;
   FILE *output_fd = NULL;
-  uint8_t write_output_file=0;
+  //uint8_t write_output_file=0;
   //int result;
-  int freq_offset;
+  //int freq_offset;
   //  int subframe_offset;
   //  char fname[40], vname[40];
-  int trial,n_trials=1,n_errors,n_errors2,n_alamouti;
+  int trial,n_trials=1,n_errors=0;
+  //int n_errors2, n_alamouti;
   uint8_t transmission_mode = 1,n_tx=1,n_rx=1;
   uint16_t Nid_cell=0;
+  uint64_t SSB_positions=0x01;
 
   channel_desc_t *gNB2UE;
-  uint32_t nsymb,tx_lev,tx_lev1 = 0,tx_lev2 = 0;
-  uint8_t extended_prefix_flag=0;
-  int8_t interf1=-21,interf2=-21;
+  //uint32_t nsymb,tx_lev,tx_lev1 = 0,tx_lev2 = 0;
+  //uint8_t extended_prefix_flag=0;
+  //int8_t interf1=-21,interf2=-21;
 
   FILE *input_fd=NULL,*pbch_file_fd=NULL;
-  char input_val_str[50],input_val_str2[50];
+  //char input_val_str[50],input_val_str2[50];
 
-  uint8_t frame_mod4,num_pdcch_symbols = 0;
+  //uint8_t frame_mod4,num_pdcch_symbols = 0;
 
   SCM_t channel_model=AWGN;//Rayleigh1_anticorr;
 
-  double pbch_sinr;
-  int pbch_tx_ant;
+  //double pbch_sinr;
+  //int pbch_tx_ant;
   int N_RB_DL=273,mu=1;
 
-  unsigned char frame_type = 0;
+  uint64_t ssb_pattern = 0x01;
+
+  //unsigned char frame_type = 0;
   unsigned char pbch_phase = 0;
 
   int frame=0,slot=1;
@@ -182,9 +199,9 @@ int main(int argc, char **argv)
 
   randominit(0);
 
-  while ((c = getopt (argc, argv, "f:hA:pf:g:i:j:n:s:S:t:x:y:z:N:F:GR:dP:IL:")) != -1) {
+  while ((c = getopt (argc, argv, "f:hA:pf:g:i:j:n:s:S:t:x:y:z:M:N:F:GR:dP:IL:")) != -1) {
     switch (c) {
-    case 'f':
+    /*case 'f':
       write_output_file=1;
       output_fd = fopen(optarg,"w");
 
@@ -192,12 +209,11 @@ int main(int argc, char **argv)
         printf("Error opening %s\n",optarg);
         exit(-1);
       }
+      break;*/
 
-      break;
-
-    case 'd':
+    /*case 'd':
       frame_type = 1;
-      break;
+      break;*/
 
     case 'g':
       switch((char)*optarg) {
@@ -236,13 +252,13 @@ int main(int argc, char **argv)
 
       break;
 
-    case 'i':
+    /*case 'i':
       interf1=atoi(optarg);
       break;
 
     case 'j':
       interf2=atoi(optarg);
-      break;
+      break;*/
 
     case 'n':
       n_trials = atoi(optarg);
@@ -264,9 +280,9 @@ int main(int argc, char **argv)
       Td= atof(optarg);
       break;
       */
-    case 'p':
+    /*case 'p':
       extended_prefix_flag=1;
-      break;
+      break;*/
 
       /*
       case 'r':
@@ -309,6 +325,10 @@ int main(int argc, char **argv)
 
       break;
 
+    case 'M':
+      SSB_positions = atoi(optarg);
+      break;
+
     case 'N':
       Nid_cell = atoi(optarg);
       break;
@@ -349,8 +369,8 @@ int main(int argc, char **argv)
       printf("%s -h(elp) -p(extended_prefix) -N cell_id -f output_filename -F input_filename -g channel_model -n n_frames -t Delayspread -s snr0 -S snr1 -x transmission_mode -y TXant -z RXant -i Intefrence0 -j Interference1 -A interpolation_file -C(alibration offset dB) -N CellId\n",
              argv[0]);
       printf("-h This message\n");
-      printf("-p Use extended prefix mode\n");
-      printf("-d Use TDD\n");
+      //printf("-p Use extended prefix mode\n");
+      //printf("-d Use TDD\n");
       printf("-n Number of frames to simulate\n");
       printf("-s Starting SNR, runs from SNR0 to SNR0 + 5 dB.  If n_frames is 1 then just SNR is simulated\n");
       printf("-S Ending SNR, runs from SNR0 to SNR1\n");
@@ -359,14 +379,15 @@ int main(int argc, char **argv)
       printf("-x Transmission mode (1,2,6 for the moment)\n");
       printf("-y Number of TX antennas used in eNB\n");
       printf("-z Number of RX antennas used in UE\n");
-      printf("-i Relative strength of first intefering eNB (in dB) - cell_id mod 3 = 1\n");
-      printf("-j Relative strength of second intefering eNB (in dB) - cell_id mod 3 = 2\n");
+      //printf("-i Relative strength of first intefering eNB (in dB) - cell_id mod 3 = 1\n");
+      //printf("-j Relative strength of second intefering eNB (in dB) - cell_id mod 3 = 2\n");
+      printf("-M Multiple SSB positions in burst\n");
       printf("-N Nid_cell\n");
       printf("-R N_RB_DL\n");
       printf("-O oversampling factor (1,2,4,8,16)\n");
       printf("-A Interpolation_filname Run with Abstraction to generate Scatter plot using interpolation polynomial in file\n");
-      //    printf("-C Generate Calibration information for Abstraction (effective SNR adjustment to remove Pe bias w.r.t. AWGN)\n");
-      printf("-f Output filename (.txt format) for Pe/SNR results\n");
+      //printf("-C Generate Calibration information for Abstraction (effective SNR adjustment to remove Pe bias w.r.t. AWGN)\n");
+      //printf("-f Output filename (.txt format) for Pe/SNR results\n");
       printf("-F Input filename (.txt format) for RX conformance testing\n");
       exit (-1);
       break;
@@ -396,7 +417,7 @@ int main(int argc, char **argv)
   frame_parms->N_RB_UL = N_RB_DL;
 
   // stub to configure frame_parms
-  nr_phy_config_request_sim(gNB,N_RB_DL,N_RB_DL,mu,Nid_cell);
+  nr_phy_config_request_sim(gNB,N_RB_DL,N_RB_DL,mu,Nid_cell,SSB_positions);
   // call MAC to configure common parameters
 
   phy_init_nr_gNB(gNB,0,0);
@@ -499,8 +520,8 @@ int main(int argc, char **argv)
   mac_top_init_gNB();
   gNB_mac = RC.nrmac[0];
 
-  config_common(0,0,78,(uint64_t)3640000000L,N_RB_DL);
-  config_nr_mib(0,0,1,kHz30,0,0,0,0);
+  config_common(0,0,Nid_cell,78,ssb_pattern,(uint64_t)3640000000L,N_RB_DL);
+  config_nr_mib(0,0,1,kHz30,0,0,0,0,0);
 
   nr_l2_init_ue();
   UE_mac = get_mac_inst(0);
@@ -514,7 +535,7 @@ int main(int argc, char **argv)
   UE->if_inst->ul_indication = dummy_nr_ue_ul_indication;
   
 
-  //mac->if_module = nr_ue_if_module_init(0);
+  UE_mac->if_module = nr_ue_if_module_init(0);
 
   
   // generate signal
@@ -601,11 +622,19 @@ int main(int argc, char **argv)
   carrier.sizeof_MIB = do_MIB_NR(&carrier,0,ssb_SubcarrierOffset,pdcch_ConfigSIB1,30,2);
 
   nr_rrc_mac_config_req_ue(0,0,0,carrier.mib.message.choice.mib,NULL,NULL,NULL);
-  fapi_nr_dl_config_request_t dl_config; 
+
+  // Initial bandwidth part configuration -- full carrier bandwidth
+  UE_mac->initial_bwp_dl.bwp_id = 0;
+  UE_mac->initial_bwp_dl.location = 0;
+  UE_mac->initial_bwp_dl.scs = UE->frame_parms.subcarrier_spacing;
+  UE_mac->initial_bwp_dl.N_RB = UE->frame_parms.N_RB_DL;
+  UE_mac->initial_bwp_dl.cyclic_prefix = UE->frame_parms.Ncp;
+  
+  fapi_nr_dl_config_request_t *dl_config = &UE_mac->dl_config_request; 
   //  Type0 PDCCH search space
-  dl_config.number_pdus =  1;
-  dl_config.dl_config_list[0].pdu_type = FAPI_NR_DL_CONFIG_TYPE_DCI;
-  dl_config.dl_config_list[0].dci_config_pdu.dci_config_rel15.rnti = 0x1234;	//	to be set
+  dl_config->number_pdus =  1;
+  dl_config->dl_config_list[0].pdu_type = FAPI_NR_DL_CONFIG_TYPE_DCI;
+  dl_config->dl_config_list[0].dci_config_pdu.dci_config_rel15.rnti = 0x1234;	
   
   uint64_t mask = 0x0;
   uint16_t num_rbs=24;
@@ -616,16 +645,16 @@ int main(int argc, char **argv)
     mask = mask >> 1;
     mask = mask | 0x100000000000;
   }
-  dl_config.dl_config_list[0].dci_config_pdu.dci_config_rel15.coreset.frequency_domain_resource = mask;
-  dl_config.dl_config_list[0].dci_config_pdu.dci_config_rel15.coreset.rb_offset = rb_offset;  //  additional parameter other than coreset
+  dl_config->dl_config_list[0].dci_config_pdu.dci_config_rel15.coreset.frequency_domain_resource = mask;
+  dl_config->dl_config_list[0].dci_config_pdu.dci_config_rel15.coreset.rb_offset = rb_offset;  //  additional parameter other than coreset
   
-  dl_config.dl_config_list[0].dci_config_pdu.dci_config_rel15.coreset.duration = num_symbols;
-  dl_config.dl_config_list[0].dci_config_pdu.dci_config_rel15.coreset.cce_reg_mapping_type =CCE_REG_MAPPING_TYPE_NON_INTERLEAVED;
-  dl_config.dl_config_list[0].dci_config_pdu.dci_config_rel15.coreset.cce_reg_interleaved_reg_bundle_size = 0;   //  L 38.211 7.3.2.2
-  dl_config.dl_config_list[0].dci_config_pdu.dci_config_rel15.coreset.cce_reg_interleaved_interleaver_size = 0;  //  R 38.211 7.3.2.2
-  dl_config.dl_config_list[0].dci_config_pdu.dci_config_rel15.coreset.cce_reg_interleaved_shift_index = cell_id;
-  dl_config.dl_config_list[0].dci_config_pdu.dci_config_rel15.coreset.precoder_granularity = PRECODER_GRANULARITY_SAME_AS_REG_BUNDLE;
-  dl_config.dl_config_list[0].dci_config_pdu.dci_config_rel15.coreset.pdcch_dmrs_scrambling_id = cell_id;
+  dl_config->dl_config_list[0].dci_config_pdu.dci_config_rel15.coreset.duration = num_symbols;
+  dl_config->dl_config_list[0].dci_config_pdu.dci_config_rel15.coreset.cce_reg_mapping_type =CCE_REG_MAPPING_TYPE_NON_INTERLEAVED;
+  dl_config->dl_config_list[0].dci_config_pdu.dci_config_rel15.coreset.cce_reg_interleaved_reg_bundle_size = 0;   //  L 38.211 7.3.2.2
+  dl_config->dl_config_list[0].dci_config_pdu.dci_config_rel15.coreset.cce_reg_interleaved_interleaver_size = 0;  //  R 38.211 7.3.2.2
+  dl_config->dl_config_list[0].dci_config_pdu.dci_config_rel15.coreset.cce_reg_interleaved_shift_index = cell_id;
+  dl_config->dl_config_list[0].dci_config_pdu.dci_config_rel15.coreset.precoder_granularity = PRECODER_GRANULARITY_SAME_AS_REG_BUNDLE;
+  dl_config->dl_config_list[0].dci_config_pdu.dci_config_rel15.coreset.pdcch_dmrs_scrambling_id = cell_id;
   
   uint32_t number_of_search_space_per_slot=1;
   uint32_t first_symbol_index=0;
@@ -634,21 +663,29 @@ int main(int argc, char **argv)
   
   coreset_duration = num_symbols * number_of_search_space_per_slot;
   
-  dl_config.dl_config_list[0].dci_config_pdu.dci_config_rel15.number_of_candidates[0] = table_38213_10_1_1_c2[0];
-  dl_config.dl_config_list[0].dci_config_pdu.dci_config_rel15.number_of_candidates[1] = table_38213_10_1_1_c2[1];
-  dl_config.dl_config_list[0].dci_config_pdu.dci_config_rel15.number_of_candidates[2] = table_38213_10_1_1_c2[2];   //  CCE aggregation level = 4
-  dl_config.dl_config_list[0].dci_config_pdu.dci_config_rel15.number_of_candidates[3] = table_38213_10_1_1_c2[3];   //  CCE aggregation level = 8
-  dl_config.dl_config_list[0].dci_config_pdu.dci_config_rel15.number_of_candidates[4] = table_38213_10_1_1_c2[4];   //  CCE aggregation level = 16
-  dl_config.dl_config_list[0].dci_config_pdu.dci_config_rel15.duration = search_space_duration;
-  dl_config.dl_config_list[0].dci_config_pdu.dci_config_rel15.monitoring_symbols_within_slot = (0x3fff << first_symbol_index) & (0x3fff >> (14-coreset_duration-first_symbol_index)) & 0x3fff;
+  dl_config->dl_config_list[0].dci_config_pdu.dci_config_rel15.number_of_candidates[0] = table_38213_10_1_1_c2[0];
+  dl_config->dl_config_list[0].dci_config_pdu.dci_config_rel15.number_of_candidates[1] = table_38213_10_1_1_c2[1];
+  dl_config->dl_config_list[0].dci_config_pdu.dci_config_rel15.number_of_candidates[2] = table_38213_10_1_1_c2[2];   //  CCE aggregation level = 4
+  dl_config->dl_config_list[0].dci_config_pdu.dci_config_rel15.number_of_candidates[3] = table_38213_10_1_1_c2[3];   //  CCE aggregation level = 8
+  dl_config->dl_config_list[0].dci_config_pdu.dci_config_rel15.number_of_candidates[4] = table_38213_10_1_1_c2[4];   //  CCE aggregation level = 16
+  dl_config->dl_config_list[0].dci_config_pdu.dci_config_rel15.duration = search_space_duration;
+  dl_config->dl_config_list[0].dci_config_pdu.dci_config_rel15.monitoring_symbols_within_slot = (0x3fff << first_symbol_index) & (0x3fff >> (14-coreset_duration-first_symbol_index)) & 0x3fff;
 
-  dl_config.dl_config_list[0].dci_config_pdu.dci_config_rel15.N_RB_BWP = N_RB_DL;
+  dl_config->dl_config_list[0].dci_config_pdu.dci_config_rel15.N_RB_BWP = N_RB_DL;
+
+  UE_mac->scheduled_response.dl_config = dl_config;
+  UE_mac->scheduled_response.ul_config = NULL;
+  UE_mac->scheduled_response.tx_request = NULL;
+  UE_mac->scheduled_response.module_id = 0;
+  UE_mac->scheduled_response.CC_id = 0;
+  UE_mac->scheduled_response.frame = frame;
+  UE_mac->scheduled_response.slot = slot;
 
   for (SNR=snr0; SNR<snr1; SNR+=.2) {
 
     n_errors = 0;
-    n_errors2 = 0;
-    n_alamouti = 0;
+    //n_errors2 = 0;
+    //n_alamouti = 0;
 
     for (trial=0; trial<n_trials; trial++) {
 
@@ -674,7 +711,8 @@ int main(int argc, char **argv)
 	  LOG_M("rxsig1.m","rxs1", UE->common_vars.rxdata[1],frame_length_complex_samples,1,1);
       }
       if (UE->is_synchronized == 0) {
-	ret = nr_initial_sync(UE, normal_txrx);
+	UE_nr_rxtx_proc_t proc={0};
+	ret = nr_initial_sync(&proc, UE, normal_txrx);
 	printf("nr_initial_sync1 returns %d\n",ret);
 	if (ret<0) n_errors++;
       }
@@ -685,7 +723,6 @@ int main(int argc, char **argv)
 	UE_proc.nr_tti_rx= slot;
 	UE_proc.subframe_rx = slot;
 	
-	UE_mac->scheduled_response.dl_config = &dl_config;
 	nr_ue_scheduled_response(&UE_mac->scheduled_response);
 
 	printf("Running phy procedures UE RX %d.%d\n",frame,slot);
@@ -741,6 +778,3 @@ int main(int argc, char **argv)
   return(n_errors);
 
 }
-
-
-
diff --git a/openair1/SIMULATION/NR_PHY/pbchsim.c b/openair1/SIMULATION/NR_PHY/pbchsim.c
index 214a33fb73..847fac3213 100644
--- a/openair1/SIMULATION/NR_PHY/pbchsim.c
+++ b/openair1/SIMULATION/NR_PHY/pbchsim.c
@@ -43,6 +43,7 @@
 #include "PHY/INIT/phy_init.h"
 #include "PHY/NR_TRANSPORT/nr_transport.h"
 #include "PHY/NR_UE_TRANSPORT/nr_transport_proto_ue.h"
+#include "PHY/NR_UE_ESTIMATION/nr_estimation.h"
 
 #include "SCHED_NR/sched_nr.h"
 
@@ -79,6 +80,7 @@ void exit_function(const char* file, const char* function, const int line,const
 
 // needed for some functions
 PHY_VARS_NR_UE * PHY_vars_UE_g[1][1]={{NULL}};
+openair0_config_t openair0_cfg[MAX_CARDS];
 
 int main(int argc, char **argv)
 {
@@ -91,13 +93,13 @@ int main(int argc, char **argv)
   uint8_t snr1set=0;
   int **txdata;
   double **s_re,**s_im,**r_re,**r_im;
-  double iqim = 0.0;
+  //double iqim = 0.0;
   double ip =0.0;
-  unsigned char pbch_pdu[6];
+  //unsigned char pbch_pdu[6];
   //  int sync_pos, sync_pos_slot;
   //  FILE *rx_frame_file;
   FILE *output_fd = NULL;
-  uint8_t write_output_file=0;
+  //uint8_t write_output_file=0;
   //int result;
   //int freq_offset;
   //  int subframe_offset;
@@ -105,11 +107,12 @@ int main(int argc, char **argv)
   int trial,n_trials=1,n_errors=0,n_errors_payload=0;
   uint8_t transmission_mode = 1,n_tx=1,n_rx=1;
   uint16_t Nid_cell=0;
+  uint64_t SSB_positions=0x01;
 
   channel_desc_t *gNB2UE;
 
-  uint8_t extended_prefix_flag=0;
-  int8_t interf1=-21,interf2=-21;
+  //uint8_t extended_prefix_flag=0;
+  //int8_t interf1=-21,interf2=-21;
 
   FILE *input_fd=NULL,*pbch_file_fd=NULL;
 
@@ -124,10 +127,10 @@ int main(int argc, char **argv)
 
   int N_RB_DL=273,mu=1;
 
-  unsigned char frame_type = 0;
+  //unsigned char frame_type = 0;
   unsigned char pbch_phase = 0;
 
-  int frame=0,subframe=0;
+  int frame=0;
   int frame_length_complex_samples;
   int frame_length_complex_samples_no_prefix;
   NR_DL_FRAME_PARMS *frame_parms;
@@ -148,9 +151,9 @@ int main(int argc, char **argv)
 
   randominit(0);
 
-  while ((c = getopt (argc, argv, "f:hA:pf:g:i:j:n:o:s:S:t:x:y:z:N:F:GR:dP:IL:")) != -1) {
+  while ((c = getopt (argc, argv, "f:hA:pf:g:i:j:n:o:s:S:t:x:y:z:M:N:F:GR:dP:IL:")) != -1) {
     switch (c) {
-    case 'f':
+    /*case 'f':
       write_output_file=1;
       output_fd = fopen(optarg,"w");
 
@@ -159,11 +162,11 @@ int main(int argc, char **argv)
         exit(-1);
       }
 
-      break;
+      break;*/
 
-    case 'd':
+    /*case 'd':
       frame_type = 1;
-      break;
+      break;*/
 
     case 'g':
       switch((char)*optarg) {
@@ -202,13 +205,13 @@ int main(int argc, char **argv)
 
       break;
 
-    case 'i':
+    /*case 'i':
       interf1=atoi(optarg);
       break;
 
     case 'j':
       interf2=atoi(optarg);
-      break;
+      break;*/
 
     case 'n':
       n_trials = atoi(optarg);
@@ -235,9 +238,9 @@ int main(int argc, char **argv)
       Td= atof(optarg);
       break;
       */
-    case 'p':
+    /*case 'p':
       extended_prefix_flag=1;
-      break;
+      break;*/
 
       /*
       case 'r':
@@ -280,6 +283,10 @@ int main(int argc, char **argv)
 
       break;
 
+    case 'M':
+      SSB_positions = atoi(optarg);
+      break;
+
     case 'N':
       Nid_cell = atoi(optarg);
       break;
@@ -320,8 +327,8 @@ int main(int argc, char **argv)
       printf("%s -h(elp) -p(extended_prefix) -N cell_id -f output_filename -F input_filename -g channel_model -n n_frames -t Delayspread -s snr0 -S snr1 -x transmission_mode -y TXant -z RXant -i Intefrence0 -j Interference1 -A interpolation_file -C(alibration offset dB) -N CellId\n",
              argv[0]);
       printf("-h This message\n");
-      printf("-p Use extended prefix mode\n");
-      printf("-d Use TDD\n");
+      //printf("-p Use extended prefix mode\n");
+      //printf("-d Use TDD\n");
       printf("-n Number of frames to simulate\n");
       printf("-s Starting SNR, runs from SNR0 to SNR0 + 5 dB.  If n_frames is 1 then just SNR is simulated\n");
       printf("-S Ending SNR, runs from SNR0 to SNR1\n");
@@ -330,15 +337,16 @@ int main(int argc, char **argv)
       printf("-x Transmission mode (1,2,6 for the moment)\n");
       printf("-y Number of TX antennas used in eNB\n");
       printf("-z Number of RX antennas used in UE\n");
-      printf("-i Relative strength of first intefering eNB (in dB) - cell_id mod 3 = 1\n");
-      printf("-j Relative strength of second intefering eNB (in dB) - cell_id mod 3 = 2\n");
+      //printf("-i Relative strength of first intefering eNB (in dB) - cell_id mod 3 = 1\n");
+      //printf("-j Relative strength of second intefering eNB (in dB) - cell_id mod 3 = 2\n");
       printf("-o Carrier frequency offset in Hz\n");
+      printf("-M Multiple SSB positions in burst\n");
       printf("-N Nid_cell\n");
       printf("-R N_RB_DL\n");
       printf("-O oversampling factor (1,2,4,8,16)\n");
       printf("-A Interpolation_filname Run with Abstraction to generate Scatter plot using interpolation polynomial in file\n");
-      //    printf("-C Generate Calibration information for Abstraction (effective SNR adjustment to remove Pe bias w.r.t. AWGN)\n");
-      printf("-f Output filename (.txt format) for Pe/SNR results\n");
+      //printf("-C Generate Calibration information for Abstraction (effective SNR adjustment to remove Pe bias w.r.t. AWGN)\n");
+      //printf("-f Output filename (.txt format) for Pe/SNR results\n");
       printf("-F Input filename (.txt format) for RX conformance testing\n");
       exit (-1);
       break;
@@ -365,33 +373,39 @@ int main(int argc, char **argv)
   frame_parms->N_RB_DL = N_RB_DL;
   frame_parms->N_RB_UL = N_RB_DL;
   frame_parms->Nid_cell = Nid_cell;
+  frame_parms->nushift = Nid_cell%4;
+  frame_parms->ssb_type = nr_ssb_type_C;
 
-  nr_phy_config_request_sim(gNB,N_RB_DL,N_RB_DL,mu,Nid_cell);
+  nr_phy_config_request_sim(gNB,N_RB_DL,N_RB_DL,mu,Nid_cell,SSB_positions);
   phy_init_nr_gNB(gNB,0,0);
 
-  double fs,bw,scs,eps;
+  uint8_t n_hf = gNB_config->sch_config.half_frame_index.value;
 
-  if (mu == 1 && N_RB_DL == 217) { 
-    fs = 122.88e6;
-    bw = 80e6;
-    scs = 30000;
-  }					       
-  else if (mu == 1 && N_RB_DL == 245) {
-    fs = 122.88e6;
-    bw = 90e6;
-    scs = 30000;
+  double fs,bw,scs,eps;
+  
+  switch (mu) {
+    case 1:
+	scs = 30000;
+	if (N_RB_DL == 217) { 
+	    fs = 122.88e6;
+	    bw = 80e6;
+	    
+	}					       
+	else if (N_RB_DL == 245) {
+	    fs = 122.88e6;
+	    bw = 90e6;
+	}
+	else if (N_RB_DL == 273) {
+	    fs = 122.88e6;
+	    bw = 100e6;
+	}
+	else if (N_RB_DL == 106) { 
+	    fs = 61.44e6;
+	    bw = 40e6;
+	}
+	else AssertFatal(1==0,"Unsupported numerology for mu %d, N_RB %d\n",mu, N_RB_DL);
+	break;
   }
-  else if (mu == 1 && N_RB_DL == 273) {
-    fs = 122.88e6;
-    bw = 100e6;
-    scs = 30000;
-  }
-  else if (mu == 1 && N_RB_DL == 106) { 
-    fs = 61.44e6;
-    bw = 40e6;
-    scs = 30000;
-  }
-  else AssertFatal(1==0,"Unsupported numerology for mu %d, N_RB %d\n",mu, N_RB_DL);
 
   // cfo with respect to sub-carrier spacing
   eps = cfo/scs;
@@ -476,31 +490,38 @@ int main(int argc, char **argv)
   if (input_fd==NULL) {
     gNB->pbch_configured = 1;
     for (int i=0;i<4;i++) gNB->pbch_pdu[i]=i+1;
-    nr_common_signal_procedures (gNB,frame,subframe);
 
-	LOG_M("txsigF0.m","txsF0", gNB->common_vars.txdataF[0],frame_length_complex_samples_no_prefix,1,1);
-	if (gNB->frame_parms.nb_antennas_tx>1)
-	LOG_M("txsigF1.m","txsF1", gNB->common_vars.txdataF[1],frame_length_complex_samples_no_prefix,1,1);
-
-    //TODO: loop over slots
-    for (aa=0; aa<gNB->frame_parms.nb_antennas_tx; aa++) {
-      if (gNB_config->subframe_config.dl_cyclic_prefix_type.value == 1) {
-	PHY_ofdm_mod(gNB->common_vars.txdataF[aa],
-		     txdata[aa],
-		     frame_parms->ofdm_symbol_size,
-		     12,
-		     frame_parms->nb_prefix_samples,
-		     CYCLIC_PREFIX);
-      } else {
-	nr_normal_prefix_mod(gNB->common_vars.txdataF[aa],
-			     txdata[aa],
-			     14,
-			     frame_parms);
+    for (int slot=0;slot<frame_parms->slots_per_frame;slot++) {
+      for (aa=0; aa<gNB->frame_parms.nb_antennas_tx; aa++)
+	memset(gNB->common_vars.txdataF[aa],0,frame_parms->samples_per_slot_wCP*sizeof(int32_t));
+      
+      nr_common_signal_procedures (gNB,frame,slot);
+      
+      for (aa=0; aa<gNB->frame_parms.nb_antennas_tx; aa++) {
+	if (gNB_config->subframe_config.dl_cyclic_prefix_type.value == 1) {
+	  PHY_ofdm_mod(gNB->common_vars.txdataF[aa],
+		       &txdata[aa][slot*frame_parms->samples_per_slot],
+		       frame_parms->ofdm_symbol_size,
+		       12,
+		       frame_parms->nb_prefix_samples,
+		       CYCLIC_PREFIX);
+	} else {
+	  nr_normal_prefix_mod(gNB->common_vars.txdataF[aa],
+			       &txdata[aa][slot*frame_parms->samples_per_slot],
+			       14,
+			       frame_parms);
+	}
       }
     }
+
+    LOG_M("txsigF0.m","txsF0", gNB->common_vars.txdataF[0],frame_length_complex_samples_no_prefix,1,1);
+    if (gNB->frame_parms.nb_antennas_tx>1)
+      LOG_M("txsigF1.m","txsF1", gNB->common_vars.txdataF[1],frame_length_complex_samples_no_prefix,1,1);
+
+
   } else {
     printf("Reading %d samples from file to antenna buffer %d\n",frame_length_complex_samples,0);
-    
+    UE->UE_fo_compensation = 1; // perform fo compensation when samples from file are used
     if (fread(txdata[0],
 	      sizeof(int32_t),
 	      frame_length_complex_samples,
@@ -517,10 +538,9 @@ int main(int argc, char **argv)
   if (output_fd) 
     fwrite(txdata[0],sizeof(int32_t),frame_length_complex_samples,output_fd);
 
-  int txlev = signal_energy(&txdata[0][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);
-
-  //  printf("txlev %d (%f)\n",txlev,10*log10(txlev));
+  /*int txlev = signal_energy(&txdata[0][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);
+  printf("txlev %d (%f)\n",txlev,10*log10(txlev));*/
 
 
   for (i=0; i<frame_length_complex_samples; i++) {
@@ -536,7 +556,6 @@ int main(int argc, char **argv)
     n_errors_payload = 0;
 
     for (trial=0; trial<n_trials; trial++) {
-
       // multipath channel
       //multipath_channel(gNB2UE,s_re,s_im,r_re,r_im,frame_length_complex_samples,0);
       
@@ -575,52 +594,43 @@ int main(int argc, char **argv)
       }
 
       if (n_trials==1) {
-	LOG_M("rxsig0.m","rxs0", UE->common_vars.rxdata[0],frame_parms->samples_per_subframe,1,1);
+	LOG_M("rxsig0.m","rxs0", UE->common_vars.rxdata[0],frame_parms->samples_per_frame,1,1);
 	if (gNB->frame_parms.nb_antennas_tx>1)
-	  LOG_M("rxsig1.m","rxs1", UE->common_vars.rxdata[1],frame_parms->samples_per_subframe,1,1);
+	  LOG_M("rxsig1.m","rxs1", UE->common_vars.rxdata[1],frame_parms->samples_per_frame,1,1);
       }
 
       if (UE->is_synchronized == 0) {
-	ret = nr_initial_sync(UE, normal_txrx);
+	UE_nr_rxtx_proc_t proc={0};
+	ret = nr_initial_sync(&proc, UE, normal_txrx);
 	printf("nr_initial_sync1 returns %d\n",ret);
 	if (ret<0) n_errors++;
       }
       else {
 	UE->rx_offset=0;
-	//symbol 1
-	nr_slot_fep(UE,
-		    5,
-		    0,
-		    0,
-		    0,
-		    1,
-		    NR_PBCH_EST);
 	
-	//symbol 2
-	nr_slot_fep(UE,
-		    6,
-		    0,
-		    0,
-		    0,
-		    1,
-		    NR_PBCH_EST);
-	
-	//symbol 3
-	nr_slot_fep(UE,
-		    7,
-		    0,
-		    0,
-		    0,
-		    1,
-		    NR_PBCH_EST);
-	 
-	ret = nr_rx_pbch(UE,
-			 &UE->proc.proc_rxtx[0],
-			 UE->pbch_vars[0],
-			 frame_parms,
-			 0,
-			 SISO,
-			 UE->high_speed_flag);
+	uint8_t ssb_index = 0;
+        while (!((SSB_positions >> ssb_index) & 0x01)) ssb_index++;  // to select the first transmitted ssb
+
+	UE->symbol_offset = nr_get_ssb_start_symbol(frame_parms, ssb_index, n_hf);
+	for (int i=UE->symbol_offset+1; i<UE->symbol_offset+4; i++) {
+	  nr_slot_fep(UE,
+	  	      i,
+		      0,
+		      0,
+		      0);
+
+          nr_pbch_channel_estimation(UE,0,0,i,i-(UE->symbol_offset+1),ssb_index%8,n_hf);
+        }
+	UE_nr_rxtx_proc_t proc={0};
+
+        ret = nr_rx_pbch(UE,
+	                 &proc,
+		         UE->pbch_vars[0],
+		         frame_parms,
+		         0,
+		         ssb_index%8,
+                         SISO,
+                         UE->high_speed_flag);
 
 	if (ret==0) {
 	  //UE->rx_ind.rx_indication_body->mib_pdu.ssb_index;  //not yet detected automatically
@@ -643,11 +653,11 @@ int main(int argc, char **argv)
 	if (ret!=0) n_errors++;
       }
     } //noise trials
-
     printf("SNR %f: trials %d, n_errors_crc = %d, n_errors_payload %d\n", SNR,n_trials,n_errors,n_errors_payload);
 
     if (((float)n_errors/(float)n_trials <= target_error_rate) && (n_errors_payload==0)) {
       printf("PBCH test OK\n");
+      printf("Synchronization obtained for i_ssb = %d\n",UE->rx_ind.rx_indication_body[0].mib_pdu.ssb_index);
       break;
     }
       
@@ -679,6 +689,3 @@ int main(int argc, char **argv)
   return(n_errors);
 
 }
-
-
-
diff --git a/openair1/SIMULATION/NR_PHY/ulschsim.c b/openair1/SIMULATION/NR_PHY/ulschsim.c
new file mode 100644
index 0000000000..e021683a43
--- /dev/null
+++ b/openair1/SIMULATION/NR_PHY/ulschsim.c
@@ -0,0 +1,746 @@
+/*
+* 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
+*/
+
+#include <string.h>
+#include <math.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+
+#include "common/config/config_userapi.h"
+#include "common/utils/LOG/log.h"
+#include "common/ran_context.h"
+
+#include "SIMULATION/TOOLS/sim.h"
+#include "SIMULATION/RF/rf.h"
+
+#include "PHY/types.h"
+#include "PHY/defs_nr_common.h"
+#include "PHY/defs_nr_UE.h"
+#include "PHY/defs_gNB.h"
+#include "PHY/INIT/phy_init.h"
+#include "PHY/NR_REFSIG/refsig_defs_ue.h"
+#include "PHY/NR_REFSIG/nr_mod_table.h"
+#include "PHY/MODULATION/modulation_eNB.h"
+#include "PHY/MODULATION/modulation_UE.h"
+#include "PHY/NR_TRANSPORT/nr_transport.h"
+#include "PHY/NR_TRANSPORT/nr_dlsch.h"
+#include "PHY/NR_TRANSPORT/nr_ulsch.h"
+#include "PHY/NR_UE_TRANSPORT/nr_transport_proto_ue.h"
+
+#include "SCHED_NR/sched_nr.h"
+
+//#include "PHY/MODULATION/modulation_common.h"
+//#include "common/config/config_load_configmodule.h"
+//#include "UTIL/LISTS/list.h"
+//#include "common/ran_context.h"
+
+//#define DEBUG_ULSCHSIM
+
+PHY_VARS_gNB *gNB;
+PHY_VARS_NR_UE *UE;
+RAN_CONTEXT_t RC;
+
+double cpuf;
+
+// dummy functions
+int nfapi_mode = 0;
+int oai_nfapi_hi_dci0_req(nfapi_hi_dci0_request_t *hi_dci0_req) {
+  return (0);
+}
+int oai_nfapi_tx_req(nfapi_tx_request_t *tx_req) {
+  return (0);
+}
+
+int oai_nfapi_dl_config_req(nfapi_dl_config_request_t *dl_config_req) {
+  return (0);
+}
+
+int oai_nfapi_ul_config_req(nfapi_ul_config_request_t *ul_config_req) {
+  return (0);
+}
+
+int oai_nfapi_nr_dl_config_req(nfapi_nr_dl_config_request_t *dl_config_req) {
+  return (0);
+}
+
+uint32_t from_nrarfcn(int nr_bandP, uint32_t dl_earfcn) {
+  return (0);
+}
+int32_t get_uldl_offset(int eutra_bandP) {
+  return (0);
+}
+
+NR_IF_Module_t *
+NR_IF_Module_init(int Mod_id) {
+  return (NULL);
+}
+
+void exit_function(const char *file, const char *function, const int line, const char *s) {
+  const char *msg = s == NULL ? "no comment" : s;
+  printf("Exiting at: %s:%d %s(), %s\n", file, line, function, msg);
+  exit(-1);
+}
+
+// needed for some functions
+PHY_VARS_NR_UE *PHY_vars_UE_g[1][1] = { { NULL } };
+uint16_t n_rnti = 0x1234;
+openair0_config_t openair0_cfg[MAX_CARDS];
+
+char quantize(double D, double x, unsigned char B) {
+  double qxd;
+  short maxlev;
+  qxd = floor(x / D);
+  maxlev = 1 << (B - 1); //(char)(pow(2,B-1));
+
+  //printf("x=%f,qxd=%f,maxlev=%d\n",x,qxd, maxlev);
+
+  if (qxd <= -maxlev)
+    qxd = -maxlev;
+  else if (qxd >= maxlev)
+    qxd = maxlev - 1;
+
+  return ((char) qxd);
+}
+
+int main(int argc, char **argv) {
+
+  char c;
+  int i,sf; //,j,l,aa;
+  double SNR, SNR_lin, snr0 = -2.0, snr1 = 2.0;
+  double snr_step = 0.1;
+  uint8_t snr1set = 0;
+  int **txdata;
+  double **s_re, **s_im, **r_re, **r_im;
+  //  int sync_pos, sync_pos_slot;
+  //  FILE *rx_frame_file;
+  FILE *output_fd = NULL;
+  //uint8_t write_output_file = 0;
+  //  int subframe_offset;
+  //  char fname[40], vname[40];
+  int trial, n_trials = 1, n_errors = 0, n_false_positive = 0;
+  uint8_t n_tx = 1, n_rx = 1;
+  //uint8_t transmission_mode = 1;
+  uint16_t Nid_cell = 0;
+  channel_desc_t *gNB2UE;
+  uint8_t extended_prefix_flag = 0;
+  //int8_t interf1 = -21, interf2 = -21;
+  FILE *input_fd = NULL, *pbch_file_fd = NULL;
+  //char input_val_str[50],input_val_str2[50];
+  //uint16_t NB_RB=25;
+  SCM_t channel_model = AWGN;  //Rayleigh1_anticorr;
+  uint16_t N_RB_DL = 106, N_RB_UL = 106, mu = 1;
+  //unsigned char frame_type = 0;
+  unsigned char pbch_phase = 0;
+  int frame = 0, subframe = 0;
+  int frame_length_complex_samples;
+  //int frame_length_complex_samples_no_prefix;
+  NR_DL_FRAME_PARMS *frame_parms;
+  //nfapi_nr_config_request_t *gNB_config;
+  // uint8_t Kmimo = 0;
+  uint32_t Nsoft = 0;
+  double sigma;
+  unsigned char qbits = 8;
+  int ret;
+  //int run_initial_sync=0;
+  int loglvl = OAILOG_WARNING;
+  float target_error_rate = 0.01;
+  uint64_t SSB_positions=0x01;
+  uint16_t nb_symb_sch = 12;
+  uint16_t nb_rb = 50;
+  uint8_t Imcs = 9;
+
+  cpuf = get_cpu_freq_GHz();
+
+  if (load_configmodule(argc, argv) == 0) {
+    exit_fun("[SOFTMODEM] Error, configuration module init failed\n");
+  }
+
+  //logInit();
+  randominit(0);
+
+  while ((c = getopt(argc, argv, "df:hpg:i:j:n:l:m:r:s:S:y:z:M:N:F:R:P:")) != -1) {
+    switch (c) {
+      /*case 'f':
+         write_output_file = 1;
+         output_fd = fopen(optarg, "w");
+
+         if (output_fd == NULL) {
+             printf("Error opening %s\n", optarg);
+             exit(-1);
+         }
+
+         break;*/
+
+      /*case 'd':
+        frame_type = 1;
+        break;*/
+
+      case 'g':
+        switch ((char) *optarg) {
+          case 'A':
+            channel_model = SCM_A;
+            break;
+
+          case 'B':
+            channel_model = SCM_B;
+            break;
+
+          case 'C':
+            channel_model = SCM_C;
+            break;
+
+          case 'D':
+            channel_model = SCM_D;
+            break;
+
+          case 'E':
+            channel_model = EPA;
+            break;
+
+          case 'F':
+            channel_model = EVA;
+            break;
+
+          case 'G':
+            channel_model = ETU;
+            break;
+
+          default:
+            msg("Unsupported channel model!\n");
+            exit(-1);
+        }
+
+        break;
+
+      /*case 'i':
+        interf1 = atoi(optarg);
+        break;
+
+      case 'j':
+        interf2 = atoi(optarg);
+        break;*/
+
+      case 'n':
+        n_trials = atoi(optarg);
+        break;
+
+      case 's':
+        snr0 = atof(optarg);
+        msg("Setting SNR0 to %f\n", snr0);
+        break;
+
+      case 'S':
+        snr1 = atof(optarg);
+        snr1set = 1;
+        msg("Setting SNR1 to %f\n", snr1);
+        break;
+
+      case 'p':
+        extended_prefix_flag = 1;
+        break;
+
+      /*
+       case 'r':
+       ricean_factor = pow(10,-.1*atof(optarg));
+       if (ricean_factor>1) {
+       printf("Ricean factor must be between 0 and 1\n");
+       exit(-1);
+       }
+       break;
+       */
+
+      case 'y':
+        n_tx = atoi(optarg);
+
+        if ((n_tx == 0) || (n_tx > 2)) {
+          msg("Unsupported number of tx antennas %d\n", n_tx);
+          exit(-1);
+        }
+
+        break;
+
+      case 'z':
+        n_rx = atoi(optarg);
+
+        if ((n_rx == 0) || (n_rx > 2)) {
+          msg("Unsupported number of rx antennas %d\n", n_rx);
+          exit(-1);
+        }
+
+        break;
+
+      case 'M':
+        SSB_positions = atoi(optarg);
+        break;
+
+      case 'N':
+        Nid_cell = atoi(optarg);
+        break;
+
+      case 'R':
+        N_RB_DL = atoi(optarg);
+        N_RB_UL = N_RB_DL;
+        break;
+
+      case 'F':
+        input_fd = fopen(optarg, "r");
+
+        if (input_fd == NULL) {
+            printf("Problem with filename %s\n", optarg);
+            exit(-1);
+        }
+
+        break;
+
+      case 'P':
+        pbch_phase = atoi(optarg);
+
+        if (pbch_phase > 3)
+          printf("Illegal PBCH phase (0-3) got %d\n", pbch_phase);
+
+        break;
+
+      case 'm':
+        Imcs = atoi(optarg);
+        break;
+
+      case 'l':
+        nb_symb_sch = atoi(optarg);
+        break;
+
+      case 'r':
+        nb_rb = atoi(optarg);
+        break;
+
+      /*case 'x':
+        transmission_mode = atoi(optarg);
+        break;*/
+
+      default:
+        case 'h':
+          printf("%s -h(elp) -p(extended_prefix) -N cell_id -f output_filename -F input_filename -g channel_model -n n_frames -t Delayspread -s snr0 -S snr1 -x transmission_mode -y TXant -z RXant -i Intefrence0 -j Interference1 -A interpolation_file -C(alibration offset dB) -N CellId\n", argv[0]);
+          printf("-h This message\n");
+          printf("-p Use extended prefix mode\n");
+          //printf("-d Use TDD\n");
+          printf("-n Number of frames to simulate\n");
+          printf("-s Starting SNR, runs from SNR0 to SNR0 + 5 dB.  If n_frames is 1 then just SNR is simulated\n");
+          printf("-S Ending SNR, runs from SNR0 to SNR1\n");
+          printf("-t Delay spread for multipath channel\n");
+          printf("-g [A,B,C,D,E,F,G] Use 3GPP SCM (A,B,C,D) or 36-101 (E-EPA,F-EVA,G-ETU) models (ignores delay spread and Ricean factor)\n");
+          //printf("-x Transmission mode (1,2,6 for the moment)\n");
+          printf("-y Number of TX antennas used in eNB\n");
+          printf("-z Number of RX antennas used in UE\n");
+          //printf("-i Relative strength of first intefering eNB (in dB) - cell_id mod 3 = 1\n");
+          //printf("-j Relative strength of second intefering eNB (in dB) - cell_id mod 3 = 2\n");
+          printf("-M Multiple SSB positions in burst\n");
+          printf("-N Nid_cell\n");
+          printf("-R N_RB_DL\n");
+          printf("-O oversampling factor (1,2,4,8,16)\n");
+          printf("-A Interpolation_filname Run with Abstraction to generate Scatter plot using interpolation polynomial in file\n");
+          //printf("-C Generate Calibration information for Abstraction (effective SNR adjustment to remove Pe bias w.r.t. AWGN)\n");
+          //printf("-f Output filename (.txt format) for Pe/SNR results\n");
+          printf("-F Input filename (.txt format) for RX conformance testing\n");
+          exit(-1);
+          break;
+    }
+  }
+
+  logInit();
+  set_glog(loglvl);
+  T_stdout = 1;
+
+  if (snr1set == 0)
+    snr1 = snr0 + 10;
+
+  gNB2UE = new_channel_desc_scm(n_tx, n_rx, channel_model,
+                                61.44e6, //N_RB2sampling_rate(N_RB_DL),
+                                40e6, //N_RB2channel_bandwidth(N_RB_DL),
+                                0, 0, 0);
+
+  if (gNB2UE == NULL) {
+    msg("Problem generating channel model. Exiting.\n");
+    exit(-1);
+  }
+
+  RC.gNB = (PHY_VARS_gNB ** *) malloc(sizeof(PHY_VARS_gNB **));
+  RC.gNB[0] = (PHY_VARS_gNB **) malloc(sizeof(PHY_VARS_gNB *));
+  RC.gNB[0][0] = malloc(sizeof(PHY_VARS_gNB));
+  gNB = RC.gNB[0][0];
+  //gNB_config = &gNB->gNB_config;
+
+  frame_parms = &gNB->frame_parms; //to be initialized I suppose (maybe not necessary for PBCH)
+  frame_parms->nb_antennas_tx = n_tx;
+  frame_parms->nb_antennas_rx = n_rx;
+  frame_parms->N_RB_DL = N_RB_DL;
+  frame_parms->N_RB_UL = N_RB_UL;
+  frame_parms->Ncp = extended_prefix_flag ? EXTENDED : NORMAL;
+
+  crcTableInit();
+
+  nr_phy_config_request_sim(gNB, N_RB_DL, N_RB_DL, mu, Nid_cell, SSB_positions);
+
+  phy_init_nr_gNB(gNB, 0, 0);
+  //init_eNB_afterRU();
+
+  frame_length_complex_samples = frame_parms->samples_per_subframe;
+  //frame_length_complex_samples_no_prefix = frame_parms->samples_per_subframe_wCP;
+  s_re   = malloc(2 * sizeof(double *));
+  s_im   = malloc(2 * sizeof(double *));
+  r_re   = malloc(2 * sizeof(double *));
+  r_im   = malloc(2 * sizeof(double *));
+  txdata = malloc(2 * sizeof(int *   ));
+
+  for (i = 0; i < 2; i++) {
+    s_re[i] = malloc(frame_length_complex_samples * sizeof(double));
+    bzero(s_re[i], frame_length_complex_samples * sizeof(double));
+    s_im[i] = malloc(frame_length_complex_samples * sizeof(double));
+    bzero(s_im[i], frame_length_complex_samples * sizeof(double));
+    r_re[i] = malloc(frame_length_complex_samples * sizeof(double));
+    bzero(r_re[i], frame_length_complex_samples * sizeof(double));
+    r_im[i] = malloc(frame_length_complex_samples * sizeof(double));
+    bzero(r_im[i], frame_length_complex_samples * sizeof(double));
+    txdata[i] = malloc(frame_length_complex_samples * sizeof(int));
+    bzero(r_re[i], frame_length_complex_samples * sizeof(int)); // [hna] r_re should be txdata
+  }
+
+  if (pbch_file_fd != NULL) {
+    load_pbch_desc(pbch_file_fd);
+  }
+
+  /*  for (int k=0; k<2; k++) {
+   // Create transport channel structures for 2 transport blocks (MIMO)
+   for (i=0; i<2; i++) {
+   gNB->dlsch[k][i] = new_gNB_dlsch(Kmimo,8,Nsoft,0,frame_parms,gNB_config);
+
+   if (!gNB->dlsch[k][i]) {
+   printf("Can't get eNB dlsch structures\n");
+   exit(-1);
+   }
+   gNB->dlsch[k][i]->Nsoft = 10;
+   gNB->dlsch[k][i]->rnti = n_rnti+k;
+   }
+   }*/
+  //configure UE
+  UE = malloc(sizeof(PHY_VARS_NR_UE));
+  memcpy(&UE->frame_parms, frame_parms, sizeof(NR_DL_FRAME_PARMS));
+
+  //phy_init_nr_top(frame_parms);
+  if (init_nr_ue_signal(UE, 1, 0) != 0) {
+    printf("Error at UE NR initialisation\n");
+    exit(-1);
+  }
+
+  //nr_init_frame_parms_ue(&UE->frame_parms);
+  //init_nr_ue_transport(UE, 0);
+  for (sf = 0; sf < 2; sf++) {
+    for (i = 0; i < 2; i++) {
+
+        UE->ulsch[sf][0][i] = new_nr_ue_ulsch(N_RB_UL, 8, 0);
+
+        if (!UE->ulsch[sf][0][i]) {
+          printf("Can't get ue ulsch structures\n");
+          exit(-1);
+        }
+
+    }
+  }
+
+  UE->dlsch_SI[0] = new_nr_ue_dlsch(1, 1, Nsoft, 5, N_RB_DL, 0);
+  UE->dlsch_ra[0] = new_nr_ue_dlsch(1, 1, Nsoft, 5, N_RB_DL, 0);
+
+  unsigned char harq_pid = 0; //dlsch->harq_ids[subframe];
+  //time_stats_t *rm_stats, *te_stats, *i_stats;
+  uint8_t is_crnti = 0, llr8_flag = 0;
+  unsigned int TBS = 8424;
+  unsigned int available_bits;
+  uint8_t nb_re_dmrs = 6;
+  uint16_t length_dmrs = 1;
+  unsigned char mod_order;
+  uint8_t Nl = 1;
+  uint8_t rvidx = 0;
+  uint8_t UE_id = 1;
+
+  NR_gNB_ULSCH_t *ulsch_gNB = gNB->ulsch[UE_id][0];
+  nfapi_nr_ul_config_ulsch_pdu_rel15_t *rel15_ul = &ulsch_gNB->harq_processes[harq_pid]->ulsch_pdu.ulsch_pdu_rel15;
+
+  NR_UE_ULSCH_t *ulsch_ue = UE->ulsch[0][0][0];
+
+  ulsch_ue->nb_re_dmrs = nb_re_dmrs; //[adk] A HOT FIX until cearting nfapi_nr_ul_config_ulsch_pdu_rel15_t
+
+  mod_order = nr_get_Qm(Imcs, 1);
+  available_bits = nr_get_G(nb_rb, nb_symb_sch, nb_re_dmrs, length_dmrs, mod_order, 1);
+  TBS = nr_compute_tbs(Imcs, nb_rb, nb_symb_sch, nb_re_dmrs, length_dmrs, Nl);
+  printf("available bits %d TBS %d mod_order %d\n", available_bits, TBS, mod_order);
+
+  /////////// setting rel15_ul parameters ///////////
+  rel15_ul->number_rbs     = nb_rb;
+  rel15_ul->number_symbols = nb_symb_sch;
+  rel15_ul->Qm             = mod_order;
+  rel15_ul->mcs            = Imcs;
+  rel15_ul->rv             = rvidx;
+  rel15_ul->n_layers       = Nl;
+  ///////////////////////////////////////////////////
+
+  double *modulated_input = malloc16(sizeof(double) * 16 * 68 * 384); // [hna] 16 segments, 68*Zc
+  short *channel_output_fixed = malloc16(sizeof(short) * 16 * 68 * 384);
+  short *channel_output_uncoded = malloc16(sizeof(unsigned short) * 16 * 68 * 384);
+  unsigned int errors_bit_uncoded = 0;
+  // unsigned char *estimated_output;
+  unsigned char *estimated_output_bit;
+  unsigned char *test_input_bit;
+  unsigned int errors_bit = 0;
+
+  test_input_bit = (unsigned char *) malloc16(sizeof(unsigned char) * 16 * 68 * 384);
+  // estimated_output = (unsigned char *) malloc16(sizeof(unsigned char) * 16 * 68 * 384);
+  estimated_output_bit = (unsigned char *) malloc16(sizeof(unsigned char) * 16 * 68 * 384);
+
+  unsigned char *test_input;
+  test_input = (unsigned char *) malloc16(sizeof(unsigned char) * TBS / 8);
+
+  for (i = 0; i < TBS / 8; i++)
+    test_input[i] = (unsigned char) rand();
+
+  // estimated_output = ulsch_gNB->harq_processes[harq_pid]->b;
+
+  /////////////////////////[adk] preparing UL harq_process parameters/////////////////////////
+  ///////////
+  NR_UL_UE_HARQ_t *harq_process_ul_ue = ulsch_ue->harq_processes[harq_pid];
+
+  if (harq_process_ul_ue) {
+
+    harq_process_ul_ue->mcs = Imcs;
+    harq_process_ul_ue->Nl = Nl;
+    harq_process_ul_ue->nb_rb = nb_rb;
+    harq_process_ul_ue->nb_symbols = nb_symb_sch;
+    harq_process_ul_ue->rvidx = rvidx;
+    harq_process_ul_ue->TBS = TBS;
+    harq_process_ul_ue->a = &test_input[0];
+
+  }
+  ///////////
+  ////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef DEBUG_ULSCHSIM
+  for (i = 0; i < TBS / 8; i++) printf("test_input[i]=%d \n",test_input[i]);
+#endif
+
+  /*for (int i=0; i<TBS/8; i++)
+   printf("test input[%d]=%d \n",i,test_input[i]);*/
+
+  //printf("crc32: [0]->0x%08x\n",crc24c(test_input, 32));
+  // generate signal
+
+  /////////////////////////[adk] ULSCH coding/////////////////////////
+  ///////////
+
+  if (input_fd == NULL) {
+    nr_ulsch_encoding(ulsch_ue, frame_parms, harq_pid);
+  }
+
+  ///////////
+  ////////////////////////////////////////////////////////////////////
+
+
+  for (SNR = snr0; SNR < snr1; SNR += snr_step) {
+    n_errors = 0;
+    n_false_positive = 0;
+
+    for (trial = 0; trial < n_trials; trial++) {
+
+      errors_bit_uncoded = 0;
+
+      for (i = 0; i < available_bits; i++) {
+
+#ifdef DEBUG_CODER
+        if ((i&0xf)==0)
+          printf("\ne %d..%d:    ",i,i+15);
+#endif
+        /*
+            if (i<16){
+               printf("dlsch_encoder output f[%d] = %d\n",i,dlsch->harq_processes[0]->f[i]);
+               printf("ulsch_encoder output f[%d] = %d\n",i,ulsch_ue->harq_processes[0]->f[i]);
+            }
+        */
+
+        if (ulsch_ue->harq_processes[0]->f[i] == 0)
+          modulated_input[i] = 1.0;        ///sqrt(2);  //QPSK
+        else
+          modulated_input[i] = -1.0;        ///sqrt(2);
+  
+        //if (i<16) printf("modulated_input[%d] = %d\n",i,modulated_input[i]);
+        //SNR =10;
+
+        SNR_lin = pow(10, SNR / 10.0);
+        sigma = 1.0 / sqrt(2 * SNR_lin);
+#if 1
+        channel_output_fixed[i] = (short) quantize(sigma / 4.0 / 4.0,
+                                                   modulated_input[i] + sigma * gaussdouble(0.0, 1.0),
+                                                   qbits);
+#else
+        channel_output_fixed[i] = (short) quantize(0.01, modulated_input[i], qbits);
+#endif
+        //channel_output_fixed[i] = (char)quantize8bit(sigma/4.0,(2.0*modulated_input[i]) - 1.0 + sigma*gaussdouble(0.0,1.0));
+        //printf("llr[%d]=%d\n",i,channel_output_fixed[i]);
+        //printf("channel_output_fixed[%d]: %d\n",i,channel_output_fixed[i]);
+
+        //channel_output_fixed[i] = (char)quantize(1,channel_output_fixed[i],qbits);
+
+        //if (i<16)   printf("channel_output_fixed[%d] = %d\n",i,channel_output_fixed[i]);
+
+        //Uncoded BER
+        if (channel_output_fixed[i] < 0)
+          channel_output_uncoded[i] = 1;  //QPSK demod
+        else
+          channel_output_uncoded[i] = 0;
+
+        if (channel_output_uncoded[i] != ulsch_ue->harq_processes[harq_pid]->f[i])
+          errors_bit_uncoded = errors_bit_uncoded + 1;
+      }
+
+      //if (errors_bit_uncoded>10)
+      printf("errors bits uncoded %u\n", errors_bit_uncoded);
+
+#ifdef DEBUG_CODER
+      printf("\n");
+      exit(-1);
+#endif
+
+      ret = nr_ulsch_decoding(gNB, UE_id, channel_output_fixed, frame_parms,
+                              frame, nb_symb_sch, subframe, harq_pid, is_crnti, llr8_flag);
+
+      if (ret > ulsch_gNB->max_ldpc_iterations)
+        n_errors++;
+
+      //count errors
+      errors_bit = 0;
+
+      for (i = 0; i < TBS; i++) {
+        estimated_output_bit[i] = (ulsch_gNB->harq_processes[harq_pid]->b[i/8] & (1 << (i & 7))) >> (i & 7);
+        test_input_bit[i] = (test_input[i / 8] & (1 << (i & 7))) >> (i & 7); // Further correct for multiple segments
+
+        if (estimated_output_bit[i] != test_input_bit[i]) {
+          errors_bit++;
+          //printf("estimated bits error occurs @%d ",i);
+        }
+      }
+
+      if (errors_bit > 0) {
+        n_false_positive++;
+        if (n_trials == 1)
+          printf("errors_bit %d (trial %d)\n", errors_bit, trial);
+      }
+    }
+    
+    printf("*****************************************\n");
+    printf("SNR %f, BLER %f (false positive %f)\n", SNR,
+           (float) n_errors / (float) n_trials,
+           (float) n_false_positive / (float) n_trials);
+    printf("*****************************************\n");
+
+    if ((float) n_errors / (float) n_trials < target_error_rate) {
+      printf("PUSCH test OK\n");
+      break;
+    }
+  }
+
+  /*LOG_M("txsigF0.m","txsF0", gNB->common_vars.txdataF[0],frame_length_complex_samples_no_prefix,1,1);
+   if (gNB->frame_parms.nb_antennas_tx>1)
+   LOG_M("txsigF1.m","txsF1", gNB->common_vars.txdataF[1],frame_length_complex_samples_no_prefix,1,1);*/
+
+  //TODO: loop over slots
+  /*for (aa=0; aa<gNB->frame_parms.nb_antennas_tx; aa++) {
+   if (gNB_config->subframe_config.dl_cyclic_prefix_type.value == 1) {
+   PHY_ofdm_mod(gNB->common_vars.txdataF[aa],
+   txdata[aa],
+   frame_parms->ofdm_symbol_size,
+   12,
+   frame_parms->nb_prefix_samples,
+   CYCLIC_PREFIX);
+   } else {
+   nr_normal_prefix_mod(gNB->common_vars.txdataF[aa],
+   txdata[aa],
+   14,
+   frame_parms);
+   }
+   }
+
+   LOG_M("txsig0.m","txs0", txdata[0],frame_length_complex_samples,1,1);
+   if (gNB->frame_parms.nb_antennas_tx>1)
+   LOG_M("txsig1.m","txs1", txdata[1],frame_length_complex_samples,1,1);
+
+
+   for (i=0; i<frame_length_complex_samples; i++) {
+   for (aa=0; aa<frame_parms->nb_antennas_tx; aa++) {
+   r_re[aa][i] = ((double)(((short *)txdata[aa]))[(i<<1)]);
+   r_im[aa][i] = ((double)(((short *)txdata[aa]))[(i<<1)+1]);
+   }
+   }*/
+
+  for (i = 0; i < 2; i++) {
+
+    printf("----------------------\n");
+    printf("freeing codeword %d\n", i);
+    printf("----------------------\n");
+
+    printf("gNB ulsch[0][%d]\n", i); // [hna] ulsch[0] is for RA
+
+    free_gNB_ulsch(gNB->ulsch[0][i]);
+
+    printf("gNB ulsch[%d][%d]\n",UE_id, i);
+
+    free_gNB_ulsch(gNB->ulsch[UE_id][i]);
+
+    for (sf = 0; sf < 2; sf++) {
+
+      printf("UE  ulsch[%d][0][%d]\n", sf, i);
+
+      if (UE->ulsch[sf][0][i])
+        free_nr_ue_ulsch(UE->ulsch[sf][0][i]);
+    }
+
+    printf("\n");
+  }
+
+  for (i = 0; i < 2; i++) {
+    free(s_re[i]);
+    free(s_im[i]);
+    free(r_re[i]);
+    free(r_im[i]);
+    free(txdata[i]);
+  }
+
+  free(s_re);
+  free(s_im);
+  free(r_re);
+  free(r_im);
+  free(txdata);
+
+  if (output_fd)
+    fclose(output_fd);
+
+  if (input_fd)
+    fclose(input_fd);
+
+  return (n_errors);
+}
+
diff --git a/openair1/SIMULATION/NR_UE_PHY/unit_tests/src/harq_test.c b/openair1/SIMULATION/NR_UE_PHY/unit_tests/src/harq_test.c
index ab99841668..05170e0bc9 100644
--- a/openair1/SIMULATION/NR_UE_PHY/unit_tests/src/harq_test.c
+++ b/openair1/SIMULATION/NR_UE_PHY/unit_tests/src/harq_test.c
@@ -54,6 +54,8 @@
 int test_harq_uplink(PHY_VARS_NR_UE *phy_vars_ue)
 {
   int gNB_id = 0;
+  int thread_number = 0;
+  int code_word_idx = 0;
   int harq_pid = 0;
   int ndi = 1;
   uint8_t rnti_type = _C_RNTI_;
@@ -61,7 +63,7 @@ int test_harq_uplink(PHY_VARS_NR_UE *phy_vars_ue)
 
   printf("\nHARQ Uplink \n");
 
-  config_uplink_harq_process(phy_vars_ue , gNB_id, NR_DEFAULT_DLSCH_HARQ_PROCESSES);
+  config_uplink_harq_process(phy_vars_ue , gNB_id, thread_number, code_word_idx, NR_DEFAULT_DLSCH_HARQ_PROCESSES);
 
   NR_UE_ULSCH_t *ulsch_harq = phy_vars_ue->ulsch[gNB_id];
 
@@ -91,7 +93,7 @@ int test_harq_uplink(PHY_VARS_NR_UE *phy_vars_ue)
     }
   }
 
-  release_uplink_harq_process(phy_vars_ue , gNB_id);
+  release_uplink_harq_process(phy_vars_ue , gNB_id, thread_number, code_word_idx);
 
   return 0;
 }
diff --git a/openair2/COMMON/rrc_messages_types.h b/openair2/COMMON/rrc_messages_types.h
index 922c949307..1c12f41150 100644
--- a/openair2/COMMON/rrc_messages_types.h
+++ b/openair2/COMMON/rrc_messages_types.h
@@ -361,7 +361,7 @@ typedef struct NRRrcConfigurationReq_s {
   lte_prefix_type_t       UL_BWP_prefix_type[MAX_NUM_CCs];
   long                    UL_timeAlignmentTimerCommon[MAX_NUM_CCs];
   long                    ServingCellConfigCommon_n_TimingAdvanceOffset[MAX_NUM_CCs];
-  long                    ServingCellConfigCommon_ssb_PositionsInBurst_PR[MAX_NUM_CCs];
+  uint64_t                ServingCellConfigCommon_ssb_PositionsInBurst_PR[MAX_NUM_CCs];
   long                    ServingCellConfigCommon_ssb_periodicityServingCell[MAX_NUM_CCs]; //ServingCellConfigCommon
   long                    ServingCellConfigCommon_dmrs_TypeA_Position[MAX_NUM_CCs];        //ServingCellConfigCommon
   long                    NIA_SubcarrierSpacing[MAX_NUM_CCs];      //ServingCellConfigCommon Used only for non-initial access
diff --git a/openair2/ENB_APP/RRC_config_tools.h b/openair2/ENB_APP/RRC_config_tools.h
index a44da1f90c..488441ff59 100644
--- a/openair2/ENB_APP/RRC_config_tools.h
+++ b/openair2/ENB_APP/RRC_config_tools.h
@@ -30,7 +30,7 @@
 #define RRC_CONFIG_TOOLS_H_
 
 #define KHz (1000UL)
-#define MHz (1000 * KHz)
+#define MHz (1000*KHz)
 
 typedef struct eutra_band_s {
   int16_t             band;
diff --git a/openair2/ENB_APP/enb_app.c b/openair2/ENB_APP/enb_app.c
index 37bcd36653..baa1409c52 100644
--- a/openair2/ENB_APP/enb_app.c
+++ b/openair2/ENB_APP/enb_app.c
@@ -55,6 +55,7 @@
 extern unsigned char NB_eNB_INST;
 #endif
 
+#include <nr-softmodem.h>
 extern RAN_CONTEXT_t RC;
 
 #if defined(ENABLE_ITTI)
@@ -64,8 +65,6 @@ extern RAN_CONTEXT_t RC;
 #   define ENB_REGISTER_RETRY_DELAY 10
 # endif
 
-#include "targets/RT/USER/lte-softmodem.h"
-
 /*------------------------------------------------------------------------------*/
 
 /*
diff --git a/openair2/ENB_APP/flexran_agent.c b/openair2/ENB_APP/flexran_agent.c
index 9c0af82e90..225a60e285 100644
--- a/openair2/ENB_APP/flexran_agent.c
+++ b/openair2/ENB_APP/flexran_agent.c
@@ -27,12 +27,12 @@
  */
 
 #include "flexran_agent.h"
+#include <common/utils/system.h>
 
 #include <arpa/inet.h>
 
 void *send_thread(void *args);
 void *receive_thread(void *args);
-pthread_t new_thread(void *(*f)(void *), void *b);
 Protocol__FlexranMessage *flexran_agent_timeout(void* args);
 
 
@@ -145,38 +145,6 @@ error:
 }
 
 
-/* utility function to create a thread */
-pthread_t new_thread(void *(*f)(void *), void *b) {
-  pthread_t t;
-  pthread_attr_t att;
-
-  if (pthread_attr_init(&att)){ 
-    fprintf(stderr, "pthread_attr_init err\n"); 
-    exit(1); 
-  }
-
-  struct sched_param sched_param_recv_thread;
-
-  sched_param_recv_thread.sched_priority = sched_get_priority_max(SCHED_FIFO) - 1;
-  pthread_attr_setschedparam(&att, &sched_param_recv_thread);
-  pthread_attr_setschedpolicy(&att, SCHED_FIFO);
-
-  if (pthread_attr_setdetachstate(&att, PTHREAD_CREATE_DETACHED)) { 
-    fprintf(stderr, "pthread_attr_setdetachstate err\n"); 
-    exit(1); 
-  }
-  if (pthread_create(&t, &att, f, b)) { 
-    fprintf(stderr, "pthread_create err\n"); 
-    exit(1); 
-  }
-  if (pthread_attr_destroy(&att)) { 
-    fprintf(stderr, "pthread_attr_destroy err\n"); 
-    exit(1); 
-  }
-
-  return t;
-}
-
 int channel_container_init = 0;
 int flexran_agent_start(mid_t mod_id)
 {
@@ -227,8 +195,8 @@ int flexran_agent_start(mid_t mod_id)
 
   /*Initialize the continuous stats update mechanism*/
   flexran_agent_init_cont_stats_update(mod_id);
-  
-  new_thread(receive_thread, flexran);
+  pthread_t t; 
+ threadCreate(&t, receive_thread, flexran, "flexran", -1, OAI_PRIORITY_RT);
 
   /*Initialize and register the mac xface. Must be modified later
    *for more flexibility in agent management */
diff --git a/openair2/GNB_APP/gnb_config.c b/openair2/GNB_APP/gnb_config.c
index 4484cc18a8..ab36765445 100644
--- a/openair2/GNB_APP/gnb_config.c
+++ b/openair2/GNB_APP/gnb_config.c
@@ -56,7 +56,7 @@
 #include "L1_paramdef.h"
 #include "MACRLC_paramdef.h"
 #include "common/config/config_userapi.h"
-#include "RRC_config_tools.h"
+//#include "RRC_config_tools.h"
 #include "gnb_paramdef.h"
 #include "LAYER2/NR_MAC_gNB/mac_proto.h"
 
@@ -81,6 +81,8 @@ extern void set_parallel_conf(char *parallel_conf);
 extern void set_worker_conf(char *worker_conf);
 extern PARALLEL_CONF_t get_thread_parallel_conf(void);
 extern WORKER_CONF_t   get_thread_worker_conf(void);
+extern int config_check_band_frequencies(int ind, int16_t band, uint32_t downlink_frequency,
+                                         int32_t uplink_frequency_offset, uint32_t  frame_type);
 
 void RCconfig_nr_flexran()
 {
@@ -103,7 +105,6 @@ void RCconfig_nr_flexran()
             *UL_frequencyShift7p5khz, *UL_SCS_SubcarrierSpacing, *UL_BWP_SubcarrierSpacing,
             *UL_BWP_prefix_type, *UL_timeAlignmentTimerCommon, 
             *ServingCellConfigCommon_n_TimingAdvanceOffset,
-            *ServingCellConfigCommon_ssb_PositionsInBurst_PR,
             *NIA_SubcarrierSpacing, *referenceSubcarrierSpacing, *dl_UL_TransmissionPeriodicity,
             *rach_ssb_perRACH_OccasionAndCB_PreamblesPerSSB_choice,
             *rach_groupBconfigured, *rach_messagePowerOffsetGroupB, 
@@ -118,7 +119,7 @@ void RCconfig_nr_flexran()
             *SearchSpace_searchSpaceType, *ue_Specific__dci_Formats,
             *RateMatchPatternLTE_CRS_subframeAllocation_choice;
 
-  uint64_t  downlink_frequency;
+  uint64_t  downlink_frequency, ServingCellConfigCommon_ssb_PositionsInBurst_PR;
 
   int32_t   nr_band, uplink_frequency_offset, N_RB_DL, nb_antenna_ports,
             MIB_subCarrierSpacingCommon, MIB_ssb_SubcarrierOffset, MIB_dmrs_TypeA_Position,
@@ -484,7 +485,7 @@ void RCconfig_NRRRC(MessageDef *msg_p, uint32_t i, gNB_RRC_INST *rrc) {
   char*                  UL_timeAlignmentTimerCommon                                   = 0;
   
   char*                  ServingCellConfigCommon_n_TimingAdvanceOffset                 = 0;
-  char*                  ServingCellConfigCommon_ssb_PositionsInBurst_PR               = 0;
+  uint64_t               ServingCellConfigCommon_ssb_PositionsInBurst_PR               = 0;
   int32_t                ServingCellConfigCommon_ssb_periodicityServingCell            = 0;
   int32_t                ServingCellConfigCommon_dmrs_TypeA_Position                   = 0;
   char*                  NIA_SubcarrierSpacing                                         = 0; 
@@ -629,7 +630,7 @@ void RCconfig_NRRRC(MessageDef *msg_p, uint32_t i, gNB_RRC_INST *rrc) {
   paramdef_t GNBParams[]  = GNBPARAMS_DESC;
   paramlist_def_t GNBParamList = {GNB_CONFIG_STRING_GNB_LIST,NULL,0};
   ////////// Physical parameters
-  checkedparam_t config_check_CCparams[] = NRCCPARAMS_CHECK;
+  //checkedparam_t config_check_CCparams[] = NRCCPARAMS_CHECK;
   paramdef_t CCsParams[] = NRCCPARAMS_DESC;
   paramlist_def_t CCsParamList = {GNB_CONFIG_STRING_COMPONENT_CARRIERS,NULL,0};
   
@@ -1125,19 +1126,23 @@ void RCconfig_NRRRC(MessageDef *msg_p, uint32_t i, gNB_RRC_INST *rrc) {
                            RC.config_file_name, i, ServingCellConfigCommon_n_TimingAdvanceOffset);
             }        
 
-            if (strcmp(ServingCellConfigCommon_ssb_PositionsInBurst_PR,"shortBitmap")==0) {
-              NRRRC_CONFIGURATION_REQ (msg_p).ServingCellConfigCommon_ssb_PositionsInBurst_PR[j] = NR_ServingCellConfigCommon__ssb_PositionsInBurst_PR_shortBitmap;
-            }else if (strcmp(ServingCellConfigCommon_ssb_PositionsInBurst_PR,"mediumBitmap")==0) {
-              NRRRC_CONFIGURATION_REQ (msg_p).ServingCellConfigCommon_ssb_PositionsInBurst_PR[j] = NR_ServingCellConfigCommon__ssb_PositionsInBurst_PR_mediumBitmap;
-            }else if (strcmp(ServingCellConfigCommon_ssb_PositionsInBurst_PR,"longBitmap")==0) {
-              NRRRC_CONFIGURATION_REQ (msg_p).ServingCellConfigCommon_ssb_PositionsInBurst_PR[j] = NR_ServingCellConfigCommon__ssb_PositionsInBurst_PR_longBitmap;
-            }else if (strcmp(ServingCellConfigCommon_ssb_PositionsInBurst_PR,"NOTHING")==0) {
-              NRRRC_CONFIGURATION_REQ (msg_p).ServingCellConfigCommon_ssb_PositionsInBurst_PR[j] = NR_ServingCellConfigCommon__ssb_PositionsInBurst_PR_NOTHING;
-            }else { 
-              AssertFatal (0,"Failed to parse gNB configuration file %s, gnb %d unknown value \"%s\" for ServingCellConfigCommon_ssb_PositionsInBurst_PR choice !\n",
-                           RC.config_file_name, i, ServingCellConfigCommon_ssb_PositionsInBurst_PR);
-            }            
 
+	    uint64_t t_freq;
+	    if(nr_band == 41 || (nr_band > 76 && nr_band < 80))
+		t_freq = 2400000000;
+	    else
+		t_freq = 3000000000;
+		
+            if (downlink_frequency<t_freq && (ServingCellConfigCommon_ssb_PositionsInBurst_PR > 15))
+		AssertFatal (0,"Failed to parse gNB configuration file %s, gnb %d unvalid value \"%ld\" for ssb_PositionsInBurst at DL frequency %ld !\n",
+                           RC.config_file_name, i, ServingCellConfigCommon_ssb_PositionsInBurst_PR, downlink_frequency);
+	    else {
+		if(downlink_frequency<6000000000 && (ServingCellConfigCommon_ssb_PositionsInBurst_PR > 255))
+			AssertFatal (0,"Failed to parse gNB configuration file %s, gnb %d unvalid value \"%ld\" for ssb_PositionsInBurst at DL frequency %ld !\n",
+                           RC.config_file_name, i, ServingCellConfigCommon_ssb_PositionsInBurst_PR, downlink_frequency);
+		else
+			NRRRC_CONFIGURATION_REQ (msg_p).ServingCellConfigCommon_ssb_PositionsInBurst_PR[j] = ServingCellConfigCommon_ssb_PositionsInBurst_PR;
+	    }
 
             switch (ServingCellConfigCommon_ssb_periodicityServingCell) {
               case 5:
diff --git a/openair2/GNB_APP/gnb_paramdef.h b/openair2/GNB_APP/gnb_paramdef.h
index 15a2e97239..6ac5bfc42d 100644
--- a/openair2/GNB_APP/gnb_paramdef.h
+++ b/openair2/GNB_APP/gnb_paramdef.h
@@ -640,7 +640,7 @@ typedef enum {
 {GNB_CONFIG_STRING_UL_BWP_PREFIX_TYPE,                                               NULL,        0,        strptr:&UL_BWP_prefix_type,                                             defstrval:"NORMAL",             TYPE_STRING,     0},  \
 {GNB_CONFIG_STRING_UL_TIMEALIGNMENTTIMERCOMMON,                                      NULL,        0,        strptr:&UL_timeAlignmentTimerCommon,                                    defstrval:"infinity",           TYPE_STRING,     0},  \
 {GNB_CONFIG_STRING_SERVINGCELLCONFIGCOMMON_N_TIMINGADVANCEOFFSET,                    NULL,        0,        strptr:&ServingCellConfigCommon_n_TimingAdvanceOffset,                  defstrval:"n0",                 TYPE_STRING,     0},  \
-{GNB_CONFIG_STRING_SERVINGCELLCONFIGCOMMON_SSB_POSITIONSINBURST_PR,                  NULL,        0,        strptr:&ServingCellConfigCommon_ssb_PositionsInBurst_PR,                defstrval:"shortBitmap",        TYPE_STRING,     0},  \
+{GNB_CONFIG_STRING_SERVINGCELLCONFIGCOMMON_SSB_POSITIONSINBURST_PR,                  NULL,        0,        i64ptr:(int64_t *)&ServingCellConfigCommon_ssb_PositionsInBurst_PR,                                  defint64val:0,         TYPE_UINT64,     0},  \
 {GNB_CONFIG_STRING_SERVINGCELLCONFIGCOMMON_SSB_PERIODICITYSERVINGCELL,               NULL,        0,        iptr:&ServingCellConfigCommon_ssb_periodicityServingCell,               defintval:10,                   TYPE_UINT,       0},  \
 {GNB_CONFIG_STRING_SERVINGCELLCONFIGCOMMON_DMRS_TYPEA_POSITION,                      NULL,        0,        iptr:&ServingCellConfigCommon_dmrs_TypeA_Position,                      defintval:0,                    TYPE_UINT,       0},  \
 {GNB_CONFIG_STRING_NIA_SUBCARRIERSPACING,                                            NULL,        0,        strptr:&NIA_SubcarrierSpacing,                                          defstrval:"kHz15",              TYPE_STRING,     0},  \
diff --git a/openair2/LAYER2/MAC/config_ue.c b/openair2/LAYER2/MAC/config_ue.c
index c38c32a4de..12786f7095 100644
--- a/openair2/LAYER2/MAC/config_ue.c
+++ b/openair2/LAYER2/MAC/config_ue.c
@@ -238,8 +238,7 @@ rrc_mac_config_req_ue(module_id_t Mod_idP,
       }
       if(nfapi_mode!=3)
         phy_config_harq_ue(Mod_idP, 0, eNB_index,
-			   UE_mac_inst[Mod_idP].
-			   scheduling_info.maxHARQ_Tx);
+			   UE_mac_inst[Mod_idP].scheduling_info.maxHARQ_Tx);
 
       if (mac_MainConfig->ul_SCH_Config->retxBSR_Timer) {
 	UE_mac_inst[Mod_idP].scheduling_info.retxBSR_Timer =
diff --git a/openair2/LAYER2/MAC/mac_extern.h b/openair2/LAYER2/MAC/mac_extern.h
index ca72882471..825756a095 100644
--- a/openair2/LAYER2/MAC/mac_extern.h
+++ b/openair2/LAYER2/MAC/mac_extern.h
@@ -58,11 +58,7 @@ extern eNB_DLSCH_INFO eNB_dlsch_info[NUMBER_OF_eNB_MAX][MAX_NUM_CCs][MAX_MOBILES
 
 
 
-#ifndef PHYSIM
-#define NB_INST 1
-#else
 extern unsigned char NB_INST;
-#endif
 extern unsigned char NB_eNB_INST;
 extern unsigned char NB_UE_INST;
 extern unsigned char NB_RN_INST;
diff --git a/openair2/LAYER2/NR_MAC_UE/mac.h b/openair2/LAYER2/NR_MAC_UE/mac.h
index d0b6d4730d..fe8e91500a 100644
--- a/openair2/LAYER2/NR_MAC_UE/mac.h
+++ b/openair2/LAYER2/NR_MAC_UE/mac.h
@@ -43,10 +43,10 @@
 
 /*!\brief UE layer 2 status */
 typedef enum {
-    CONNECTION_OK = 0,
-    CONNECTION_LOST,
-    PHY_RESYNCH,
-    PHY_HO_PRACH
+    UE_CONNECTION_OK = 0,
+    UE_CONNECTION_LOST,
+    UE_PHY_RESYNCH,
+    UE_PHY_HO_PRACH
 } NR_UE_L2_STATE_t;
 
 typedef struct {
diff --git a/openair2/LAYER2/NR_MAC_UE/mac_defs.h b/openair2/LAYER2/NR_MAC_UE/mac_defs.h
index 4f69c4db18..f196293ea0 100755
--- a/openair2/LAYER2/NR_MAC_UE/mac_defs.h
+++ b/openair2/LAYER2/NR_MAC_UE/mac_defs.h
@@ -57,6 +57,8 @@
 #include "fapi_nr_ue_interface.h"
 #include "NR_IF_Module.h"
 
+#include "PHY/defs_nr_common.h"
+
 #define NB_NR_UE_MAC_INST 1
 
 typedef enum {
@@ -64,44 +66,42 @@ typedef enum {
     SFN_C_MOD_2_EQ_1
 } SFN_C_TYPE;
 
+
 /*!\brief Top level UE MAC structure */
 typedef struct {
-    
-    ////  MAC config
-    NR_DRX_Config_t    	            *drx_Config;
-    NR_SchedulingRequestConfig_t    *schedulingRequestConfig;
-    NR_BSR_Config_t    	            *bsr_Config;
-    NR_TAG_Config_t		            *tag_Config;
-    NR_PHR_Config_t		            *phr_Config;
-    NR_RNTI_Value_t 	            *cs_RNTI;
-	NR_MIB_t 			            *mib;
-
-    ///     Type0-PDCCH seach space
-    fapi_nr_dl_config_dci_dl_pdu_rel15_t type0_pdcch_dci_config;
-    uint32_t type0_pdcch_ss_mux_pattern;
-    SFN_C_TYPE type0_pdcch_ss_sfn_c;
-    uint32_t type0_pdcch_ss_n_c;
-    uint32_t type0_pdcch_consecutive_slots;
-
-    ///     Random access parameter
-    uint16_t ra_rnti;
-
-
-	////	FAPI-like interface message
-	fapi_nr_tx_request_t tx_request;
-	fapi_nr_ul_config_request_t ul_config_request;
-	fapi_nr_dl_config_request_t dl_config_request;
-
-
-
-	///     Interface module instances
-	nr_ue_if_module_t *if_module;
-	nr_scheduled_response_t	scheduled_response;
-	nr_phy_config_t phy_config;
-
+  
+  ////  MAC config
+  NR_DRX_Config_t    	          *drx_Config;
+  NR_SchedulingRequestConfig_t    *schedulingRequestConfig;
+  NR_BSR_Config_t    	          *bsr_Config;
+  NR_TAG_Config_t	          *tag_Config;
+  NR_PHR_Config_t	          *phr_Config;
+  NR_RNTI_Value_t 	          *cs_RNTI;
+  NR_MIB_t 	                  *mib;
+  
+  ///     Type0-PDCCH seach space
+  fapi_nr_dl_config_dci_dl_pdu_rel15_t type0_pdcch_dci_config;
+  uint32_t type0_pdcch_ss_mux_pattern;
+  SFN_C_TYPE type0_pdcch_ss_sfn_c;
+  uint32_t type0_pdcch_ss_n_c;
+  uint32_t type0_pdcch_consecutive_slots;
+  
+  ///     Random access parameter
+  uint16_t ra_rnti;
 
+   //BWP params
+  NR_BWP_PARMS initial_bwp_dl;
+  NR_BWP_PARMS initial_bwp_ul;
 
+  ////	FAPI-like interface message
+  fapi_nr_tx_request_t tx_request;
+  fapi_nr_ul_config_request_t ul_config_request;
+  fapi_nr_dl_config_request_t dl_config_request;
 
+  ///     Interface module instances
+  nr_ue_if_module_t       *if_module;
+  nr_scheduled_response_t scheduled_response;
+  nr_phy_config_t         phy_config;
 } NR_UE_MAC_INST_t;
 
 typedef enum seach_space_mask_e {
diff --git a/openair2/LAYER2/NR_MAC_UE/mac_proto.h b/openair2/LAYER2/NR_MAC_UE/mac_proto.h
index f34000bc98..c338920397 100755
--- a/openair2/LAYER2/NR_MAC_UE/mac_proto.h
+++ b/openair2/LAYER2/NR_MAC_UE/mac_proto.h
@@ -30,11 +30,12 @@
  * \warning
  */
 
-#ifndef __LAYER2_MAC_PROTO_H__
-#define __LAYER2_MAC_PROTO_H__
+#ifndef __LAYER2_MAC_UE_PROTO_H__
+#define __LAYER2_MAC_UE_PROTO_H__
 
 #include "mac_defs.h"
 #include "mac.h"
+#include <openair1/PHY/defs_nr_UE.h>
 
 /**\brief decode mib pdu in NR_UE, from if_module ul_ind with P7 tx_ind message
    \param module_id      module id
@@ -46,6 +47,7 @@
    \param pdu_length     length of pdu
    \param cell_id        cell id */
 int8_t nr_ue_decode_mib(
+    UE_nr_rxtx_proc_t *proc,
     module_id_t module_id, 
     int cc_id, 
     uint8_t gNB_index, 
diff --git a/openair2/LAYER2/NR_MAC_UE/mac_vars.c b/openair2/LAYER2/NR_MAC_UE/mac_vars.c
index b2b1fa0ed1..95dea61a45 100644
--- a/openair2/LAYER2/NR_MAC_UE/mac_vars.c
+++ b/openair2/LAYER2/NR_MAC_UE/mac_vars.c
@@ -90,7 +90,7 @@ const float   table_38213_13_12_c3[16] = { 1, 0.5f, 1, 0.5f, 1, 0.5f, 0.5f, 0.5f
 
 const int32_t table_38213_10_1_1_c2[5] = { 0, 0, 4, 2, 1 };
 
-
+/*
  #define mu_pusch 1
 // definition table j Table 6.1.2.1.1-4
  #define j ((mu_pusch==3)?3:(mu_pusch==2)?2:1)
@@ -131,4 +131,5 @@ const int32_t table_38213_10_1_1_c2[5] = { 0, 0, 4, 2, 1 };
   {0,2,4},  // row index 14
   {0,4,7},  // row index 15
   {0,8,4}   // row index 16
-  };
\ No newline at end of file
+  };
+*/
diff --git a/openair2/LAYER2/NR_MAC_UE/nr_ue_procedures.c b/openair2/LAYER2/NR_MAC_UE/nr_ue_procedures.c
index 44f1cf05ea..05e88e3ed9 100644
--- a/openair2/LAYER2/NR_MAC_UE/nr_ue_procedures.c
+++ b/openair2/LAYER2/NR_MAC_UE/nr_ue_procedures.c
@@ -35,6 +35,7 @@
 #include "RRC/NR_UE/rrc_proto.h"
 #include "assertions.h"
 #include "PHY/defs_nr_UE.h"
+#include "common/utils/LOG/log.h"
 
 #include <stdio.h>
 #include <math.h>
@@ -64,11 +65,16 @@ uint8_t table_9_2_2_1[16][8]={
 {1,0, 14,4, 0,3,6,9},
 {1,0, 14,26,0,3,0,0}
 };
-int8_t nr_ue_process_dlsch(module_id_t module_id, int cc_id, uint8_t gNB_index, fapi_nr_dci_indication_t *dci_ind, void *pduP, uint32_t pdu_len){
-
+int8_t nr_ue_process_dlsch(module_id_t module_id,
+		                   int cc_id,
+						   uint8_t gNB_index,
+						   fapi_nr_dci_indication_t *dci_ind,
+						   void *pduP,
+						   uint32_t pdu_len)
+{
     NR_UE_MAC_INST_t *mac = get_mac_inst(module_id);
     fapi_nr_ul_config_request_t *ul_config = &mac->ul_config_request;
-    fapi_nr_dl_config_request_t *dl_config = &mac->dl_config_request;
+    //fapi_nr_dl_config_request_t *dl_config = &mac->dl_config_request;
     nr_phy_config_t *phy_config = &mac->phy_config;
 
     //ul_config->ul_config_list[ul_config->number_pdus].ulsch_config_pdu.rnti = rnti;
@@ -186,13 +192,14 @@ int8_t nr_ue_process_dlsch(module_id_t module_id, int cc_id, uint8_t gNB_index,
       ul_config->ul_config_list[ul_config->number_pdus].pucch_config_pdu.twoPUCCH_PC_AdjustmentStates = 0;
 
     }
-    if(mac->if_module != NULL && mac->if_module->ul_indication != NULL){
-        mac->if_module->dl_indication(&mac->scheduled_response);
+    if(mac->if_module != NULL && mac->if_module->scheduled_response != NULL){
+        mac->if_module->scheduled_response(&mac->scheduled_response);
     }
     return 0;
 }
 
 int8_t nr_ue_decode_mib(
+	UE_nr_rxtx_proc_t *proc,
 	module_id_t module_id,
 	int 		cc_id,
 	uint8_t 	gNB_index,
@@ -202,7 +209,7 @@ int8_t nr_ue_decode_mib(
 	void 		*pduP,
     uint16_t    cell_id ){
 
-    printf("[L2][MAC] decode mib\n");
+    LOG_I(MAC,"[L2][MAC] decode mib\n");
 
 	NR_UE_MAC_INST_t *mac = get_mac_inst(module_id);
 
@@ -233,16 +240,16 @@ int8_t nr_ue_decode_mib(
 	    }
 
 #ifdef DEBUG_MIB
-		printf("system frame number(6 MSB bits): %d\n",  mac->mib->systemFrameNumber.buf[0]);
-		printf("system frame number(with LSB): %d\n", (int)frame);
-		printf("subcarrier spacing:            %d\n", (int)mac->mib->subCarrierSpacingCommon);
-		printf("ssb carrier offset(with MSB):  %d\n", (int)ssb_subcarrier_offset);
-		printf("dmrs type A position:          %d\n", (int)mac->mib->dmrs_TypeA_Position);
-		printf("pdcch config sib1:             %d\n", (int)mac->mib->pdcch_ConfigSIB1);
-		printf("cell barred:                   %d\n", (int)mac->mib->cellBarred);
-		printf("intra frequency reselection:   %d\n", (int)mac->mib->intraFreqReselection);
-		printf("half frame bit(extra bits):    %d\n", (int)half_frame_bit);
-		printf("ssb index(extra bits):         %d\n", (int)ssb_index);
+		LOG_I(MAC,"system frame number(6 MSB bits): %d\n",  mac->mib->systemFrameNumber.buf[0]);
+		LOG_I(MAC,"system frame number(with LSB): %d\n", (int)frame);
+		LOG_I(MAC,"subcarrier spacing (0=15or60, 1=30or120): %d\n", (int)mac->mib->subCarrierSpacingCommon);
+		LOG_I(MAC,"ssb carrier offset(with MSB):  %d\n", (int)ssb_subcarrier_offset);
+		LOG_I(MAC,"dmrs type A position (0=pos2,1=pos3): %d\n", (int)mac->mib->dmrs_TypeA_Position);
+		LOG_I(MAC,"pdcch config sib1:             %d\n", (int)mac->mib->pdcch_ConfigSIB1);
+		LOG_I(MAC,"cell barred (0=barred,1=notBarred): %d\n", (int)mac->mib->cellBarred);
+		LOG_I(MAC,"intra frequency reselection (0=allowed,1=notAllowed): %d\n", (int)mac->mib->intraFreqReselection);
+		LOG_I(MAC,"half frame bit(extra bits):    %d\n", (int)half_frame_bit);
+		LOG_I(MAC,"ssb index(extra bits):         %d\n", (int)ssb_index);
 #endif
 
 	    subcarrier_spacing_t scs_ssb = scs_30kHz;      //  default for 
@@ -271,7 +278,7 @@ int8_t nr_ue_decode_mib(
         int32_t num_rbs = -1;
         int32_t num_symbols = -1;
         int32_t rb_offset = -1;
-        //printf("<<<<<<<<<configSIB1 %d index_4msb %d index_4lsb %d scs_ssb %d scs_pdcch %d switch %d ",
+        //LOG_I(MAC,"<<<<<<<<<configSIB1 %d index_4msb %d index_4lsb %d scs_ssb %d scs_pdcch %d switch %d ",
         //mac->mib->pdcch_ConfigSIB1,index_4msb,index_4lsb,scs_ssb,scs_pdcch, (scs_ssb << 5)|scs_pdcch);
 
         //  type0-pdcch coreset
@@ -315,7 +322,7 @@ int8_t nr_ue_decode_mib(
                     num_rbs     = table_38213_13_4_c2[index_4msb];
                     num_symbols = table_38213_13_4_c3[index_4msb];
                     rb_offset   = table_38213_13_4_c4[index_4msb];
-                    printf("<<<<<<<<<index_4msb %d num_rbs %d num_symb %d rb_offset %d\n",index_4msb,num_rbs,num_symbols,rb_offset );
+                    LOG_I(MAC,"<<<<<<<<<index_4msb %d num_rbs %d num_symb %d rb_offset %d\n",index_4msb,num_rbs,num_symbols,rb_offset );
                 }else if(min_channel_bw & bw_40MHz){
                     AssertFatal(index_4msb < 10, "38.213 Table 13-6 4 MSB out of range\n");
                     mac->type0_pdcch_ss_mux_pattern = 1;
@@ -402,7 +409,7 @@ int8_t nr_ue_decode_mib(
             mask = mask >> 1;
             mask = mask | 0x100000000000;
         }
-        //printf(">>>>>>>>mask %x num_rbs %d rb_offset %d\n", mask, num_rbs, rb_offset);
+        //LOG_I(MAC,">>>>>>>>mask %x num_rbs %d rb_offset %d\n", mask, num_rbs, rb_offset);
         mac->type0_pdcch_dci_config.coreset.frequency_domain_resource = mask;
         mac->type0_pdcch_dci_config.coreset.rb_offset = rb_offset;  //  additional parameter other than coreset
 
@@ -594,6 +601,7 @@ int8_t nr_ue_decode_mib(
 	    if(mac->if_module != NULL && mac->if_module->phy_config_request != NULL){
 		mac->if_module->phy_config_request(&mac->phy_config);
 	    }
+	    proc->decoded_frame_rx=frame;
     //}
     return 0;
 }
@@ -660,10 +668,11 @@ NR_UE_L2_STATE_t nr_ue_scheduler(
         dl_config->dl_config_list[dl_config->number_pdus].dci_config_pdu.dci_config_rel15 = mac->type0_pdcch_dci_config;
         dl_config->dl_config_list[dl_config->number_pdus].pdu_type = FAPI_NR_DL_CONFIG_TYPE_DCI;
     	
+	/*
     	dl_config->dl_config_list[dl_config->number_pdus].dci_config_pdu.dci_config_rel15.rnti = 0xaaaa;	//	to be set
     	dl_config->dl_config_list[dl_config->number_pdus].dci_config_pdu.dci_config_rel15.N_RB_BWP = 106;	//	to be set
-	/*
-	printf("nr_ue_scheduler Type0 PDCCH with rnti %x, BWP %d\n",
+
+	LOG_I(MAC,"nr_ue_scheduler Type0 PDCCH with rnti %x, BWP %d\n",
 	       dl_config->dl_config_list[dl_config->number_pdus].dci_config_pdu.dci_config_rel15.rnti,
 	       dl_config->dl_config_list[dl_config->number_pdus].dci_config_pdu.dci_config_rel15.N_RB_BWP);  
 	*/   
@@ -686,7 +695,7 @@ NR_UE_L2_STATE_t nr_ue_scheduler(
     mac->scheduled_response.dl_config = dl_config;
     
 
-	return CONNECTION_OK;
+	return UE_CONNECTION_OK;
 }
 
 //////////////
@@ -1083,7 +1092,7 @@ int8_t nr_ue_process_dci_freq_dom_resource_assignment(
     start_RB = riv%n_RB_DLBWP;
     // if (l_RB - 1)  > floor (n_RB_DLBWP/2) we need to recalculate them using the following lines
     tmp_RIV = n_RB_DLBWP * (l_RB - 1) + start_RB;
-    if (tmp_RIV != riv) { // then (l_RB - 1)  > floor (n_RB_DLBWP/2) and we need to recalculate l_RB and start_RB
+    if ((tmp_RIV != riv) || ((start_RB+l_RB)>n_RB_DLBWP)) { // then (l_RB - 1)  > floor (n_RB_DLBWP/2) and we need to recalculate l_RB and start_RB
       l_RB = n_RB_DLBWP - l_RB + 2;
       start_RB = n_RB_DLBWP - start_RB - 1;
     }
@@ -1122,19 +1131,19 @@ int8_t nr_ue_process_dci_time_dom_resource_assignment(
   fapi_nr_ul_config_pusch_pdu_rel15_t *ulsch_config_pdu,
   fapi_nr_dl_config_dlsch_pdu_rel15_t *dlsch_config_pdu,
   uint8_t time_domain_ind,
-  long dmrs_typeA_pos
+  long dmrs_typeA_pos //0=pos2,1=pos3
 ){
   uint8_t k_offset=0;
   uint8_t sliv_S=0;
   uint8_t sliv_L=0;
   uint8_t table_5_1_2_1_1_2_time_dom_res_alloc_A[16][3]={ // for PDSCH from TS 38.214 subclause 5.1.2.1.1
-  {0,(dmrs_typeA_pos == 2)?2:3, (dmrs_typeA_pos == 2)?12:11}, // row index 1
-  {0,(dmrs_typeA_pos == 2)?2:3, (dmrs_typeA_pos == 2)?10:9},  // row index 2
-  {0,(dmrs_typeA_pos == 2)?2:3, (dmrs_typeA_pos == 2)?9:8},   // row index 3
-  {0,(dmrs_typeA_pos == 2)?2:3, (dmrs_typeA_pos == 2)?7:6},   // row index 4
-  {0,(dmrs_typeA_pos == 2)?2:3, (dmrs_typeA_pos == 2)?5:4},   // row index 5
-  {0,(dmrs_typeA_pos == 2)?9:10,(dmrs_typeA_pos == 2)?4:4},   // row index 6
-  {0,(dmrs_typeA_pos == 2)?4:6, (dmrs_typeA_pos == 2)?4:4},   // row index 7
+  {0,(dmrs_typeA_pos == 0)?2:3, (dmrs_typeA_pos == 0)?12:11}, // row index 1
+  {0,(dmrs_typeA_pos == 0)?2:3, (dmrs_typeA_pos == 0)?10:9},  // row index 2
+  {0,(dmrs_typeA_pos == 0)?2:3, (dmrs_typeA_pos == 0)?9:8},   // row index 3
+  {0,(dmrs_typeA_pos == 0)?2:3, (dmrs_typeA_pos == 0)?7:6},   // row index 4
+  {0,(dmrs_typeA_pos == 0)?2:3, (dmrs_typeA_pos == 0)?5:4},   // row index 5
+  {0,(dmrs_typeA_pos == 0)?9:10,(dmrs_typeA_pos == 0)?4:4},   // row index 6
+  {0,(dmrs_typeA_pos == 0)?4:6, (dmrs_typeA_pos == 0)?4:4},   // row index 7
   {0,5,7},  // row index 8
   {0,5,2},  // row index 9
   {0,9,2},  // row index 10
@@ -1145,14 +1154,14 @@ int8_t nr_ue_process_dci_time_dom_resource_assignment(
   {0,4,7},  // row index 15
   {0,8,4}   // row index 16
   };
-  uint8_t table_5_1_2_1_1_3_time_dom_res_alloc_A_extCP[16][3]={ // for PDSCH from TS 38.214 subclause 5.1.2.1.1
-  {0,(dmrs_typeA_pos == 2)?2:3, (dmrs_typeA_pos == 2)?6:5},   // row index 1
-  {0,(dmrs_typeA_pos == 2)?2:3, (dmrs_typeA_pos == 2)?10:9},  // row index 2
-  {0,(dmrs_typeA_pos == 2)?2:3, (dmrs_typeA_pos == 2)?9:8},   // row index 3
-  {0,(dmrs_typeA_pos == 2)?2:3, (dmrs_typeA_pos == 2)?7:6},   // row index 4
-  {0,(dmrs_typeA_pos == 2)?2:3, (dmrs_typeA_pos == 2)?5:4},   // row index 5
-  {0,(dmrs_typeA_pos == 2)?6:8, (dmrs_typeA_pos == 2)?4:2},   // row index 6
-  {0,(dmrs_typeA_pos == 2)?4:6, (dmrs_typeA_pos == 2)?4:4},   // row index 7
+  /*uint8_t table_5_1_2_1_1_3_time_dom_res_alloc_A_extCP[16][3]={ // for PDSCH from TS 38.214 subclause 5.1.2.1.1
+  {0,(dmrs_typeA_pos == 0)?2:3, (dmrs_typeA_pos == 0)?6:5},   // row index 1
+  {0,(dmrs_typeA_pos == 0)?2:3, (dmrs_typeA_pos == 0)?10:9},  // row index 2
+  {0,(dmrs_typeA_pos == 0)?2:3, (dmrs_typeA_pos == 0)?9:8},   // row index 3
+  {0,(dmrs_typeA_pos == 0)?2:3, (dmrs_typeA_pos == 0)?7:6},   // row index 4
+  {0,(dmrs_typeA_pos == 0)?2:3, (dmrs_typeA_pos == 0)?5:4},   // row index 5
+  {0,(dmrs_typeA_pos == 0)?6:8, (dmrs_typeA_pos == 0)?4:2},   // row index 6
+  {0,(dmrs_typeA_pos == 0)?4:6, (dmrs_typeA_pos == 0)?4:4},   // row index 7
   {0,5,6},  // row index 8
   {0,5,2},  // row index 9
   {0,9,2},  // row index 10
@@ -1162,8 +1171,8 @@ int8_t nr_ue_process_dci_time_dom_resource_assignment(
   {0,2,4},  // row index 14
   {0,4,6},  // row index 15
   {0,8,4}   // row index 16
-  };
-  uint8_t table_5_1_2_1_1_4_time_dom_res_alloc_B[16][3]={ // for PDSCH from TS 38.214 subclause 5.1.2.1.1
+  };*/
+  /*uint8_t table_5_1_2_1_1_4_time_dom_res_alloc_B[16][3]={ // for PDSCH from TS 38.214 subclause 5.1.2.1.1
   {0,2,2},  // row index 1
   {0,4,2},  // row index 2
   {0,6,2},  // row index 3
@@ -1177,11 +1186,11 @@ int8_t nr_ue_process_dci_time_dom_resource_assignment(
   {0,8,4},  // row index 11
   {0,10,4}, // row index 12
   {0,2,7},  // row index 13
-  {0,(dmrs_typeA_pos == 2)?2:3,(dmrs_typeA_pos == 2)?12:11},  // row index 14
+  {0,(dmrs_typeA_pos == 0)?2:3,(dmrs_typeA_pos == 0)?12:11},  // row index 14
   {1,2,4},  // row index 15
   {0,0,0}   // row index 16
-  };
-  uint8_t table_5_1_2_1_1_5_time_dom_res_alloc_C[16][3]={ // for PDSCH from TS 38.214 subclause 5.1.2.1.1
+  };*/
+  /*uint8_t table_5_1_2_1_1_5_time_dom_res_alloc_C[16][3]={ // for PDSCH from TS 38.214 subclause 5.1.2.1.1
   {0,2,2},  // row index 1
   {0,4,2},  // row index 2
   {0,6,2},  // row index 3
@@ -1195,10 +1204,10 @@ int8_t nr_ue_process_dci_time_dom_resource_assignment(
   {0,8,4},  // row index 11
   {0,10,4}, // row index 12
   {0,2,7},  // row index 13
-  {0,(dmrs_typeA_pos == 2)?2:3,(dmrs_typeA_pos == 2)?12:11},  // row index 14
+  {0,(dmrs_typeA_pos == 0)?2:3,(dmrs_typeA_pos == 0)?12:11},  // row index 14
   {0,0,6},  // row index 15
   {0,2,6}   // row index 16
-  };
+  };*/
   uint8_t mu_pusch = 1;
   // definition table j Table 6.1.2.1.1-4
   uint8_t j = (mu_pusch==3)?3:(mu_pusch==2)?2:1;
@@ -1220,7 +1229,7 @@ int8_t nr_ue_process_dci_time_dom_resource_assignment(
   {j+3,0,14}, // row index 15
   {j+3,0,10}  // row index 16
   };
-  uint8_t table_6_1_2_1_1_3_time_dom_res_alloc_A_extCP[16][3]={ // for PUSCH from TS 38.214 subclause 6.1.2.1.1
+  /*uint8_t table_6_1_2_1_1_3_time_dom_res_alloc_A_extCP[16][3]={ // for PUSCH from TS 38.214 subclause 6.1.2.1.1
   {j,  0,8},  // row index 1
   {j,  0,12}, // row index 2
   {j,  0,10}, // row index 3
@@ -1237,15 +1246,15 @@ int8_t nr_ue_process_dci_time_dom_resource_assignment(
   {j,  8,4},  // row index 14
   {j+3,0,8},  // row index 15
   {j+3,0,10}  // row index 16
-  };
+  };*/
 
 /*
  * TS 38.214 subclause 5.1.2.1 Resource allocation in time domain (downlink)
  */
   if(dlsch_config_pdu != NULL){
-      k_offset = table_5_1_2_1_1_2_time_dom_res_alloc_A[time_domain_ind][0];
-      sliv_S   = table_5_1_2_1_1_2_time_dom_res_alloc_A[time_domain_ind][1];
-      sliv_L   = table_5_1_2_1_1_2_time_dom_res_alloc_A[time_domain_ind][2];
+      k_offset = table_5_1_2_1_1_2_time_dom_res_alloc_A[time_domain_ind-1][0];
+      sliv_S   = table_5_1_2_1_1_2_time_dom_res_alloc_A[time_domain_ind-1][1];
+      sliv_L   = table_5_1_2_1_1_2_time_dom_res_alloc_A[time_domain_ind-1][2];
       // k_offset = table_5_1_2_1_1_3_time_dom_res_alloc_A_extCP[nr_pdci_info_extracted->time_dom_resource_assignment][0];
       // sliv_S   = table_5_1_2_1_1_3_time_dom_res_alloc_A_extCP[nr_pdci_info_extracted->time_dom_resource_assignment][1];
       // sliv_L   = table_5_1_2_1_1_3_time_dom_res_alloc_A_extCP[nr_pdci_info_extracted->time_dom_resource_assignment][2];
@@ -1262,9 +1271,9 @@ int8_t nr_ue_process_dci_time_dom_resource_assignment(
  * TS 38.214 subclause 6.1.2.1 Resource allocation in time domain (uplink)
  */
   if(ulsch_config_pdu != NULL){
-      k_offset = table_6_1_2_1_1_2_time_dom_res_alloc_A[time_domain_ind][0];
-      sliv_S   = table_6_1_2_1_1_2_time_dom_res_alloc_A[time_domain_ind][1];
-      sliv_L   = table_6_1_2_1_1_2_time_dom_res_alloc_A[time_domain_ind][2];
+      k_offset = table_6_1_2_1_1_2_time_dom_res_alloc_A[time_domain_ind-1][0];
+      sliv_S   = table_6_1_2_1_1_2_time_dom_res_alloc_A[time_domain_ind-1][1];
+      sliv_L   = table_6_1_2_1_1_2_time_dom_res_alloc_A[time_domain_ind-1][2];
       // k_offset = table_6_1_2_1_1_3_time_dom_res_alloc_A_extCP[nr_pdci_info_extracted->time_dom_resource_assignment][0];
       // sliv_S   = table_6_1_2_1_1_3_time_dom_res_alloc_A_extCP[nr_pdci_info_extracted->time_dom_resource_assignment][1];
       // sliv_L   = table_6_1_2_1_1_3_time_dom_res_alloc_A_extCP[nr_pdci_info_extracted->time_dom_resource_assignment][2];
@@ -1281,10 +1290,12 @@ int8_t nr_ue_process_dci(module_id_t module_id, int cc_id, uint8_t gNB_index, fa
     NR_UE_MAC_INST_t *mac = get_mac_inst(module_id);
     fapi_nr_dl_config_request_t *dl_config = &mac->dl_config_request;
     fapi_nr_ul_config_request_t *ul_config = &mac->ul_config_request;
-    const uint16_t n_RB_ULBWP = 106;
-    const uint16_t n_RB_DLBWP = 106;
+    
+    //const uint16_t n_RB_DLBWP = dl_config->dl_config_list[dl_config->number_pdus].dci_config_pdu.dci_config_rel15.N_RB_BWP; //make sure this has been set
+    const uint16_t n_RB_DLBWP = mac->initial_bwp_dl.N_RB;
+    const uint16_t n_RB_ULBWP = mac->initial_bwp_ul.N_RB;
 
-printf("\n>>> nr_ue_process_dci at MAC layer with dci_format=%d\n",dci_format);
+    LOG_I(MAC,"nr_ue_process_dci at MAC layer with dci_format=%d (DL BWP %d, UL BWP %d)\n",dci_format,n_RB_DLBWP,n_RB_ULBWP);
 
     switch(dci_format){
         case format0_0:
@@ -1741,20 +1752,18 @@ printf("\n>>> nr_ue_process_dci at MAC layer with dci_format=%d\n",dci_format);
         /* PDSCH_TO_HARQ_FEEDBACK_TIME_IND (only if CRC scrambled by C-RNTI or CS-RNTI or new-RNTI)*/
             dlsch_config_pdu_1_0->pdsch_to_harq_feedback_time_ind = dci->pdsch_to_harq_feedback_time_ind;
 
-            dl_config->number_pdus = dl_config->number_pdus + 1;
-            
-            printf("\n>>> (nr_ue_procedures.c) rnti=%d dl_config->number_pdus=%d\n",
+            LOG_D(MAC,"(nr_ue_procedures.c) rnti=%d dl_config->number_pdus=%d\n",
                     dl_config->dl_config_list[dl_config->number_pdus].dlsch_config_pdu.rnti,
                     dl_config->number_pdus);
-            printf(">>> (nr_ue_procedures.c) frequency_domain_resource_assignment=%d \t number_rbs=%d \t start_rb=%d\n",
+            LOG_D(MAC,"(nr_ue_procedures.c) frequency_domain_resource_assignment=%d \t number_rbs=%d \t start_rb=%d\n",
                     dci->freq_dom_resource_assignment_DL,
                     dlsch_config_pdu_1_0->number_rbs,
                     dlsch_config_pdu_1_0->start_rb);
-            printf(">>> (nr_ue_procedures.c) time_domain_resource_assignment=%d \t number_symbols=%d \t start_symbol=%d\n",
+            LOG_D(MAC,"(nr_ue_procedures.c) time_domain_resource_assignment=%d \t number_symbols=%d \t start_symbol=%d\n",
                     dci->time_dom_resource_assignment,
                     dlsch_config_pdu_1_0->number_symbols,
                     dlsch_config_pdu_1_0->start_symbol);
-            printf(">>> (nr_ue_procedures.c) vrb_to_prb_mapping=%d \n>>> mcs=%d\n>>> ndi=%d\n>>> rv=%d\n>>> harq_process_nbr=%d\n>>> dai=%d\n>>> scaling_factor_S=%d\n>>> tpc_pucch=%d\n>>> pucch_res_ind=%d\n>>> pdsch_to_harq_feedback_time_ind=%d\n",
+            LOG_D(MAC,"(nr_ue_procedures.c) vrb_to_prb_mapping=%d \n>>> mcs=%d\n>>> ndi=%d\n>>> rv=%d\n>>> harq_process_nbr=%d\n>>> dai=%d\n>>> scaling_factor_S=%f\n>>> tpc_pucch=%d\n>>> pucch_res_ind=%d\n>>> pdsch_to_harq_feedback_time_ind=%d\n",
                   dlsch_config_pdu_1_0->vrb_to_prb_mapping,
                   dlsch_config_pdu_1_0->mcs,
                   dlsch_config_pdu_1_0->ndi,
@@ -1767,17 +1776,11 @@ printf("\n>>> nr_ue_process_dci at MAC layer with dci_format=%d\n",dci_format);
                   dlsch_config_pdu_1_0->pdsch_to_harq_feedback_time_ind);
 
             dl_config->dl_config_list[dl_config->number_pdus].pdu_type = FAPI_NR_DL_CONFIG_TYPE_DLSCH;
-
-            printf(">>> (nr_ue_procedures.c) pdu_type=%d\n\n",dl_config->dl_config_list[dl_config->number_pdus].pdu_type);
+	    dl_config->dl_config_list[dl_config->number_pdus].dci_config_pdu.dci_config_rel15.N_RB_BWP = n_RB_DLBWP;
+	    
+            LOG_D(MAC,"(nr_ue_procedures.c) pdu_type=%d\n\n",dl_config->dl_config_list[dl_config->number_pdus].pdu_type);
             
-            if(mac->if_module != NULL && mac->if_module->dl_indication != NULL)
-              //printf(">>> mac->if_module->dl_indication(&mac->phy_config); \n");
-              //for (int k=0;k<1000;k++) printf(">>> %d ",k); 
-              //mac->if_module->dl_indication(&mac->dl_info);       
-              //mac->if_module->dl_indication(&mac->dl_config_request);       
-	      mac->if_module->dl_indication(&mac->phy_config);
-            
-
+            dl_config->number_pdus = dl_config->number_pdus + 1;
             break;
 
         case format1_1:        
@@ -1959,14 +1962,13 @@ printf("\n>>> nr_ue_process_dci at MAC layer with dci_format=%d\n",dci_format);
         /* DMRS_SEQ_INI */
             //FIXME!!!
 
-            dl_config->number_pdus = dl_config->number_pdus + 1;
-            
+	    dl_config->dl_config_list[dl_config->number_pdus].dci_config_pdu.dci_config_rel15.N_RB_BWP = n_RB_DLBWP;
+	    
             dl_config->dl_config_list[dl_config->number_pdus].pdu_type = FAPI_NR_DL_CONFIG_TYPE_DLSCH;
-            printf(">>> (nr_ue_procedures.c) pdu_type=%d\n\n",dl_config->dl_config_list[dl_config->number_pdus].pdu_type);
+            LOG_D(MAC,"(nr_ue_procedures.c) pdu_type=%d\n\n",dl_config->dl_config_list[dl_config->number_pdus].pdu_type);
             
-            if(mac->if_module != NULL && mac->if_module->dl_indication != NULL)
-		      mac->if_module->dl_indication(&mac->phy_config);
-		      
+            dl_config->number_pdus = dl_config->number_pdus + 1;
+
             break;
 
         case format2_0:        
@@ -1986,7 +1988,6 @@ printf("\n>>> nr_ue_process_dci at MAC layer with dci_format=%d\n",dci_format);
     }
 
 
-
     if(rnti == SI_RNTI){
 
     }else if(rnti == mac->ra_rnti){
diff --git a/openair2/LAYER2/NR_MAC_gNB/config.c b/openair2/LAYER2/NR_MAC_gNB/config.c
index 30917fd543..6954b9507d 100644
--- a/openair2/LAYER2/NR_MAC_gNB/config.c
+++ b/openair2/LAYER2/NR_MAC_gNB/config.c
@@ -49,110 +49,6 @@ extern RAN_CONTEXT_t RC;
 extern void mac_top_init_gNB(void);
 extern uint8_t nfapi_mode;
 
-int32_t **rxdata;
-int32_t **txdata;
-
-typedef struct nr_bandentry_s {
-  int16_t band;
-  uint64_t ul_min;
-  uint64_t ul_max;
-  uint64_t dl_min;
-  uint64_t dl_max;
-  uint64_t N_OFFs_DL;
-  uint64_t step_size;
-} nr_bandentry_t;
-
-typedef struct band_info_s {
-  int nbands;
-  nr_bandentry_t band_info[100];
-} nr_band_info_t;
-
-static const nr_bandentry_t nr_bandtable[] = {
-  {1,  1920000, 1980000, 2110000, 2170000, 20, 422000},
-  {2,  1850000, 1910000, 1930000, 1990000, 20, 386000},
-  {3,  1710000, 1785000, 1805000, 1880000, 20, 361000},
-  {5,   824000,  849000,  869000,  894000, 20, 173800},
-  {7,  2500000, 2570000, 2620000, 2690000, 20, 524000},
-  {8,   880000,  915000,  925000,  960000, 20, 185000},
-  {12,  698000,  716000,  728000,  746000, 20, 145800},
-  {20,  832000,  862000,  791000,  821000, 20, 158200},
-  {25, 1850000, 1915000, 1930000, 1995000, 20, 386000},
-  {28,  703000,  758000,  758000,  813000, 20, 151600},
-  {34, 2010000, 2025000, 2010000, 2025000, 20, 402000},
-  {38, 2570000, 2620000, 2570000, 2630000, 20, 514000},
-  {39, 1880000, 1920000, 1880000, 1920000, 20, 376000},
-  {40, 2300000, 2400000, 2300000, 2400000, 20, 460000},
-  {41, 2496000, 2690000, 2496000, 2690000,  3, 499200},
-  {50, 1432000, 1517000, 1432000, 1517000, 20, 286400},
-  {51, 1427000, 1432000, 1427000, 1432000, 20, 285400},
-  {66, 1710000, 1780000, 2110000, 2200000, 20, 422000},
-  {70, 1695000, 1710000, 1995000, 2020000, 20, 399000},
-  {71,  663000,  698000,  617000,  652000, 20, 123400},
-  {74, 1427000, 1470000, 1475000, 1518000, 20, 295000},
-  {75,     000,     000, 1432000, 1517000, 20, 286400},
-  {76,     000,     000, 1427000, 1432000, 20, 285400},
-  {77, 3300000, 4200000, 3300000, 4200000,  1, 620000},
-  {78, 3300000, 3800000, 3300000, 3800000,  1, 620000},
-  {79, 4400000, 5000000, 4400000, 5000000,  2, 693334},
-  {80, 1710000, 1785000,     000,     000, 20, 342000},
-  {81,  860000,  915000,     000,     000, 20, 176000},
-  {82,  832000,  862000,     000,     000, 20, 166400},
-  {83,  703000,  748000,     000,     000, 20, 140600},
-  {84, 1920000, 1980000,     000,     000, 20, 384000},
-  {86, 1710000, 1785000,     000,     000, 20, 342000}
-};
-
-
-uint32_t to_nrarfcn(int nr_bandP, uint64_t dl_CarrierFreq, uint32_t bw)
-{
-
-  uint64_t dl_CarrierFreq_by_1k = dl_CarrierFreq / 1000;
-  int bw_kHz = bw / 1000;
-
-  int i;
-
-  LOG_I(MAC,"Searching for nr band %d DL Carrier frequency %llu bw %u\n",nr_bandP,(long long unsigned int)dl_CarrierFreq,bw);
-  AssertFatal(nr_bandP < 86, "nr_band %d > 86\n", nr_bandP);
-  for (i = 0; i < 30 && nr_bandtable[i].band != nr_bandP; i++);
-
-  AssertFatal(dl_CarrierFreq_by_1k >= nr_bandtable[i].dl_min,
-        "Band %d, bw %u : DL carrier frequency %llu kHz < %llu\n",
-	      nr_bandP, bw, (long long unsigned int)dl_CarrierFreq_by_1k,
-	      (long long unsigned int)nr_bandtable[i].dl_min);
-  AssertFatal(dl_CarrierFreq_by_1k <=
-        (nr_bandtable[i].dl_max - bw_kHz),
-        "Band %d, dl_CarrierFreq %llu bw %u: DL carrier frequency %llu kHz > %llu\n",
-	      nr_bandP, (long long unsigned int)dl_CarrierFreq,bw, (long long unsigned int)dl_CarrierFreq_by_1k,
-	      (long long unsigned int)(nr_bandtable[i].dl_max - bw_kHz));
- 
-  int deltaFglobal;
-
-  if (dl_CarrierFreq < 3e9) deltaFglobal = 5;
-  else                      deltaFglobal = 15;
-
-  // This is equation before Table 5.4.2.1-1 in 38101-1-f30
-  // F_REF=F_REF_Offs + deltaF_Global(N_REF-NREF_REF_Offs)
-  return (((dl_CarrierFreq_by_1k - nr_bandtable[i].dl_min)/deltaFglobal) +
-	  nr_bandtable[i].N_OFFs_DL);
-}
-
-
-uint64_t from_nrarfcn(int nr_bandP, uint32_t dl_nrarfcn)
-{
-
-  int i;
-  int deltaFglobal;
-
-  if (nr_bandP < 77 || nr_bandP > 79) deltaFglobal = 5;
-  else                                deltaFglobal = 15;
-  
-  AssertFatal(nr_bandP < 87, "nr_band %d > 86\n", nr_bandP);
-  for (i = 0; i < 31 && nr_bandtable[i].band != nr_bandP; i++);
-  AssertFatal(dl_nrarfcn>=nr_bandtable[i].N_OFFs_DL,"dl_nrarfcn %u < N_OFFs_DL %llu\n",dl_nrarfcn, (long long unsigned int)nr_bandtable[i].N_OFFs_DL);
- 
-  return 1000*(nr_bandtable[i].dl_min + (dl_nrarfcn - nr_bandtable[i].N_OFFs_DL) * deltaFglobal);
-	  
-}
 
 void config_nr_mib(int Mod_idP, 
                 int CC_idP,
@@ -184,8 +80,10 @@ void config_nr_mib(int Mod_idP,
 
 void config_common(int Mod_idP, 
                    int CC_idP,
+		   int cellid,
                    int nr_bandP,
-                   uint64_t dl_CarrierFreqP,
+                   uint64_t ssb_pattern,
+		   uint64_t dl_CarrierFreqP,
                    uint32_t dl_BandwidthP
                   ){
 
@@ -193,6 +91,9 @@ void config_common(int Mod_idP,
 
   int mu = 1;
 
+  cfg->sch_config.physical_cell_id.value = cellid;
+  cfg->sch_config.ssb_scg_position_in_burst.value = ssb_pattern;
+
   // FDD
   cfg->subframe_config.duplex_mode.value                          = 1;
   cfg->subframe_config.duplex_mode.tl.tag = NFAPI_SUBFRAME_CONFIG_DUPLEX_MODE_TAG;
@@ -232,8 +133,10 @@ void config_common(int Mod_idP,
 
 int rrc_mac_config_req_gNB(module_id_t Mod_idP, 
                            int CC_idP,
+			   int cellid,
                            int p_gNB,
                            int nr_bandP,
+			   uint64_t ssb_pattern,
                            uint64_t dl_CarrierFreqP,
                            int dl_BandwidthP,
                            NR_BCCH_BCH_Message_t *mib,
@@ -258,10 +161,13 @@ int rrc_mac_config_req_gNB(module_id_t Mod_idP,
                );
   }// END if( mib != NULL )
 
+
   if( servingcellconfigcommon != NULL ){
     config_common(Mod_idP, 
                   CC_idP,
+		  cellid,
                   nr_bandP,
+		  ssb_pattern,
                   dl_CarrierFreqP,
                   dl_BandwidthP
                   );  
diff --git a/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler.c b/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler.c
index 0911cac62d..02c27930d3 100644
--- a/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler.c
+++ b/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler.c
@@ -48,6 +48,7 @@
 #include "pdcp.h"
 
 #include "openair1/PHY/defs_gNB.h"
+#include "openair1/PHY/NR_TRANSPORT/nr_dlsch.h"
 
 //Agent-related headers
 #include "flexran_agent_extern.h"
@@ -335,7 +336,7 @@ void gNB_dlsch_ulsch_scheduler(module_id_t module_idP,
 
       rnti = UE_RNTI(module_idP, i);
       CC_id = UE_PCCID(module_idP, i);
-      int spf = get_spf(cfg);
+      //int spf = get_spf(cfg);
   
       if (((frameP&127) == 0) && (slotP == 0)) {
         LOG_I(MAC,
@@ -385,18 +386,18 @@ void gNB_dlsch_ulsch_scheduler(module_id_t module_idP,
       
           // Note: This should not be done in the MAC!
           for (int ii=0; ii<MAX_MOBILES_PER_GNB; ii++) {
-            LTE_eNB_ULSCH_t *ulsch = RC.gNB[module_idP][CC_id]->ulsch[ii];       
+            NR_gNB_ULSCH_t *ulsch = RC.gNB[module_idP][CC_id]->ulsch[ii][0];       
             if((ulsch != NULL) && (ulsch->rnti == rnti)){
-              LOG_I(MAC, "clean_eNb_ulsch UE %x \n", rnti);
-              clean_eNb_ulsch(ulsch);
+              LOG_W(MAC, "TODO: clean_eNb_ulsch UE %x \n", rnti);
+              clean_gNB_ulsch(ulsch);
             }
           }
 
           for (int ii=0; ii<MAX_MOBILES_PER_GNB; ii++) {
             NR_gNB_DLSCH_t *dlsch = RC.gNB[module_idP][CC_id]->dlsch[ii][0];
             if((dlsch != NULL) && (dlsch->rnti == rnti)){
-              LOG_I(MAC, "clean_eNb_dlsch UE %x \n", rnti);
-              clean_eNb_dlsch(dlsch);
+              LOG_W(MAC, "TODO: clean_eNb_dlsch UE %x \n", rnti);
+              clean_gNB_dlsch(dlsch);
             }
           }
     
diff --git a/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_phytest.c b/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_phytest.c
index 5a57bc2846..ce18158f18 100644
--- a/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_phytest.c
+++ b/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_phytest.c
@@ -203,8 +203,8 @@ void nr_schedule_uss_dlsch_phytest(module_id_t   module_idP,
   int dl_carrier_bandwidth = cfg->rf_config.dl_carrier_bandwidth.value;
 
   // everything here is hard-coded to 30 kHz
-  int scs = get_dlscs(cfg);
-  int slots_per_frame = get_spf(cfg);
+  //int scs = get_dlscs(cfg);
+  //int slots_per_frame = get_spf(cfg);
   for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
     LOG_I(MAC, "Scheduling UE specific search space DCI type 1 for CC_id %d\n",CC_id);
 
diff --git a/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_primitives.c b/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_primitives.c
index 114ec60447..1f88e2a03c 100644
--- a/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_primitives.c
+++ b/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_primitives.c
@@ -462,6 +462,3 @@ int get_symbolsperslot(nfapi_nr_config_request_t *cfg) {
 
 }
 
-int nr_schedule_dci() {
-  
-}
diff --git a/openair2/LAYER2/NR_MAC_gNB/mac_proto.h b/openair2/LAYER2/NR_MAC_gNB/mac_proto.h
index c0ba26fb5d..9e70ae7025 100644
--- a/openair2/LAYER2/NR_MAC_gNB/mac_proto.h
+++ b/openair2/LAYER2/NR_MAC_gNB/mac_proto.h
@@ -36,10 +36,20 @@
 
 void mac_top_init_gNB(void);
 
+void config_common(int Mod_idP,
+                   int CC_idP,
+				   int Nid_cell,
+                   int nr_bandP,
+				   uint64_t ssb_pattern,
+                   uint64_t dl_CarrierFreqP,
+                   uint32_t dl_BandwidthP);
+
 int rrc_mac_config_req_gNB(module_id_t Mod_idP, 
                            int CC_id,
+						   int cellid,
                            int p_gNB,
                            int nr_bandP,
+                           uint64_t ssb_pattern,
                            uint64_t dl_CarrierFreqP,
                            int dl_BandwidthP,
                            NR_BCCH_BCH_Message_t *mib,
@@ -65,6 +75,10 @@ void nr_schedule_css_dlsch_phytest(module_id_t   module_idP,
                                    frame_t       frameP,
                                    sub_frame_t   subframeP);
 
+void nr_schedule_uss_dlsch_phytest(module_id_t   module_idP,
+                                   frame_t       frameP,
+                                   sub_frame_t   slotP);
+
 
 void nr_configure_css_dci_initial(nfapi_nr_dl_config_pdcch_parameters_rel15_t* pdcch_params,
 				  nr_scs_e scs_common,
@@ -100,4 +114,20 @@ int to_absslot(nfapi_nr_config_request_t *cfg,int frame,int slot);
 
 int get_symbolsperslot(nfapi_nr_config_request_t *cfg);
 
+void get_band(uint32_t downlink_frequency,   uint8_t *current_band,   int32_t *current_offset, lte_frame_type_t *current_type);
+
+uint64_t from_nrarfcn(int nr_bandP, uint32_t dl_nrarfcn);
+
+uint32_t to_nrarfcn(int nr_bandP, uint64_t dl_CarrierFreq, uint32_t bw);
+
+void config_nr_mib(int Mod_idP, 
+                int CC_idP,
+                int p_gNBP,
+                int subCarrierSpacingCommon, 
+                uint32_t ssb_SubcarrierOffset,
+                int dmrs_TypeA_Position,
+                uint32_t pdcch_ConfigSIB1,
+                int cellBarred,
+                int intraFreqReselection);
+
 #endif /*__LAYER2_NR_MAC_PROTO_H__*/
diff --git a/openair2/LAYER2/NR_MAC_gNB/nr_mac_common.c b/openair2/LAYER2/NR_MAC_gNB/nr_mac_common.c
new file mode 100644
index 0000000000..f2c2e437cc
--- /dev/null
+++ b/openair2/LAYER2/NR_MAC_gNB/nr_mac_common.c
@@ -0,0 +1,148 @@
+/*
+ * 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
+ */
+
+/*! \file nr_mac_common.c
+ * \brief Common MAC functions for NR UE and gNB
+ * \author  Florian Kaltenberger and Raymond Knopp
+ * \date 2019
+ * \version 0.1
+ * \company Eurecom, NTUST
+ * \email: florian.kalteberger@eurecom.fr, raymond.knopp@eurecom.fr
+ * @ingroup _mac
+
+ */
+
+#include "LAYER2/NR_MAC_gNB/mac_proto.h"
+
+nr_bandentry_t nr_bandtable[] = {
+  {1,  1920000, 1980000, 2110000, 2170000, 20, 422000},
+  {2,  1850000, 1910000, 1930000, 1990000, 20, 386000},
+  {3,  1710000, 1785000, 1805000, 1880000, 20, 361000},
+  {5,   824000,  849000,  869000,  894000, 20, 173800},
+  {7,  2500000, 2570000, 2620000, 2690000, 20, 524000},
+  {8,   880000,  915000,  925000,  960000, 20, 185000},
+  {12,  698000,  716000,  728000,  746000, 20, 145800},
+  {20,  832000,  862000,  791000,  821000, 20, 158200},
+  {25, 1850000, 1915000, 1930000, 1995000, 20, 386000},
+  {28,  703000,  758000,  758000,  813000, 20, 151600},
+  {34, 2010000, 2025000, 2010000, 2025000, 20, 402000},
+  {38, 2570000, 2620000, 2570000, 2630000, 20, 514000},
+  {39, 1880000, 1920000, 1880000, 1920000, 20, 376000},
+  {40, 2300000, 2400000, 2300000, 2400000, 20, 460000},
+  {41, 2496000, 2690000, 2496000, 2690000,  3, 499200},
+  {50, 1432000, 1517000, 1432000, 1517000, 20, 286400},
+  {51, 1427000, 1432000, 1427000, 1432000, 20, 285400},
+  {66, 1710000, 1780000, 2110000, 2200000, 20, 422000},
+  {70, 1695000, 1710000, 1995000, 2020000, 20, 399000},
+  {71,  663000,  698000,  617000,  652000, 20, 123400},
+  {74, 1427000, 1470000, 1475000, 1518000, 20, 295000},
+  {75,     000,     000, 1432000, 1517000, 20, 286400},
+  {76,     000,     000, 1427000, 1432000, 20, 285400},
+  {77, 3300000, 4200000, 3300000, 4200000,  1, 620000},
+  {78, 3300000, 3800000, 3300000, 3800000,  1, 620000},
+  {79, 4400000, 5000000, 4400000, 5000000,  2, 693334},
+  {80, 1710000, 1785000,     000,     000, 20, 342000},
+  {81,  860000,  915000,     000,     000, 20, 176000},
+  {82,  832000,  862000,     000,     000, 20, 166400},
+  {83,  703000,  748000,     000,     000, 20, 140600},
+  {84, 1920000, 1980000,     000,     000, 20, 384000},
+  {86, 1710000, 1785000,     000,     000, 20, 342000}
+};
+
+void get_band(uint32_t downlink_frequency,   uint8_t *current_band,   int32_t *current_offset, lte_frame_type_t *current_type) {
+
+    int ind;
+    int64_t dl_freq_khz = downlink_frequency/1000;
+    for ( ind=0;
+          ind < sizeof(nr_bandtable) / sizeof(nr_bandtable[0]);
+          ind++) {
+
+      *current_band = nr_bandtable[ind].band;
+      LOG_I(PHY, "Scanning band %d, dl_min %"PRIu64", ul_min %"PRIu64"\n", ind, nr_bandtable[ind].dl_min,nr_bandtable[ind].ul_min);
+
+      if ( nr_bandtable[ind].dl_min <= dl_freq_khz && nr_bandtable[ind].dl_max >= dl_freq_khz ) {
+	*current_offset = (nr_bandtable[ind].ul_min - nr_bandtable[ind].dl_min)*1000;
+	if (*current_offset == 0)
+	  *current_type = TDD;
+	else
+	  *current_type = FDD;
+
+	LOG_I( PHY, "DL frequency %"PRIu32": band %d, frame_type %d, UL frequency %"PRIu32"\n",
+	       downlink_frequency, *current_band, *current_type, downlink_frequency+*current_offset);
+        break;
+      }
+    }
+
+    AssertFatal(ind != (sizeof(nr_bandtable) / sizeof(nr_bandtable[0])),
+	    "Can't find EUTRA band for frequency %d\n", downlink_frequency);
+
+}
+
+uint32_t to_nrarfcn(int nr_bandP, uint64_t dl_CarrierFreq, uint32_t bw)
+{
+
+  uint64_t dl_CarrierFreq_by_1k = dl_CarrierFreq / 1000;
+  int bw_kHz = bw / 1000;
+
+  int i;
+
+  LOG_I(MAC,"Searching for nr band %d DL Carrier frequency %llu bw %u\n",nr_bandP,(long long unsigned int)dl_CarrierFreq,bw);
+  AssertFatal(nr_bandP < 86, "nr_band %d > 86\n", nr_bandP);
+  for (i = 0; i < 30 && nr_bandtable[i].band != nr_bandP; i++);
+
+  AssertFatal(dl_CarrierFreq_by_1k >= nr_bandtable[i].dl_min,
+        "Band %d, bw %u : DL carrier frequency %llu kHz < %llu\n",
+	      nr_bandP, bw, (long long unsigned int)dl_CarrierFreq_by_1k,
+	      (long long unsigned int)nr_bandtable[i].dl_min);
+  AssertFatal(dl_CarrierFreq_by_1k <=
+        (nr_bandtable[i].dl_max - bw_kHz),
+        "Band %d, dl_CarrierFreq %llu bw %u: DL carrier frequency %llu kHz > %llu\n",
+	      nr_bandP, (long long unsigned int)dl_CarrierFreq,bw, (long long unsigned int)dl_CarrierFreq_by_1k,
+	      (long long unsigned int)(nr_bandtable[i].dl_max - bw_kHz));
+ 
+  int deltaFglobal;
+
+  if (dl_CarrierFreq < 3e9) deltaFglobal = 5;
+  else                      deltaFglobal = 15;
+
+  // This is equation before Table 5.4.2.1-1 in 38101-1-f30
+  // F_REF=F_REF_Offs + deltaF_Global(N_REF-NREF_REF_Offs)
+  return (((dl_CarrierFreq_by_1k - nr_bandtable[i].dl_min)/deltaFglobal) +
+	  nr_bandtable[i].N_OFFs_DL);
+}
+
+
+uint64_t from_nrarfcn(int nr_bandP, uint32_t dl_nrarfcn)
+{
+
+  int i;
+  int deltaFglobal;
+
+  if (nr_bandP < 77 || nr_bandP > 79) deltaFglobal = 5;
+  else                                deltaFglobal = 15;
+  
+  AssertFatal(nr_bandP < 87, "nr_band %d > 86\n", nr_bandP);
+  for (i = 0; i < 31 && nr_bandtable[i].band != nr_bandP; i++);
+  AssertFatal(dl_nrarfcn>=nr_bandtable[i].N_OFFs_DL,"dl_nrarfcn %u < N_OFFs_DL %llu\n",dl_nrarfcn, (long long unsigned int)nr_bandtable[i].N_OFFs_DL);
+ 
+  return 1000*(nr_bandtable[i].dl_min + (dl_nrarfcn - nr_bandtable[i].N_OFFs_DL) * deltaFglobal);
+	  
+}
diff --git a/openair2/LAYER2/NR_MAC_gNB/nr_mac_gNB.h b/openair2/LAYER2/NR_MAC_gNB/nr_mac_gNB.h
index 6cd15fd32b..456f06a5ed 100644
--- a/openair2/LAYER2/NR_MAC_gNB/nr_mac_gNB.h
+++ b/openair2/LAYER2/NR_MAC_gNB/nr_mac_gNB.h
@@ -171,8 +171,4 @@ typedef struct gNB_MAC_INST_s {
   time_stats_t schedule_pch;
 } gNB_MAC_INST;
 
-void nr_schedule_css_dlsch_phytest(module_id_t   module_idP,
-                                   frame_t       frameP,
-                                   sub_frame_t   subframeP);
-
 #endif /*__LAYER2_NR_MAC_GNB_H__ */
diff --git a/openair2/LAYER2/PDCP_v10.1.0/pdcp.h b/openair2/LAYER2/PDCP_v10.1.0/pdcp.h
index 054bb5fac4..ab00abc0cf 100644
--- a/openair2/LAYER2/PDCP_v10.1.0/pdcp.h
+++ b/openair2/LAYER2/PDCP_v10.1.0/pdcp.h
@@ -53,7 +53,6 @@
 
 
 extern pthread_t       pdcp_thread;
-extern pthread_attr_t  pdcp_thread_attr;
 extern pthread_mutex_t pdcp_mutex;
 extern pthread_cond_t  pdcp_cond;
 extern int             pdcp_instance_cnt;
diff --git a/openair2/LAYER2/PDCP_v10.1.0/pdcp_netlink.c b/openair2/LAYER2/PDCP_v10.1.0/pdcp_netlink.c
index 472c46c94a..b77151f8a3 100644
--- a/openair2/LAYER2/PDCP_v10.1.0/pdcp_netlink.c
+++ b/openair2/LAYER2/PDCP_v10.1.0/pdcp_netlink.c
@@ -97,8 +97,6 @@ pdcp_netlink_init(
   int                i;
   int                nb_inst_enb;
   int                nb_inst_ue;
-  pthread_attr_t     attr;
-  struct sched_param sched_param;
 
   reset_meas(&ip_pdcp_stats_tmp);
   nb_inst_enb = 1;
@@ -141,28 +139,12 @@ pdcp_netlink_init(
   }
 
   if ((nb_inst_ue + nb_inst_enb) > 0) {
-    if (pthread_attr_init(&attr) != 0) {
-      LOG_E(PDCP, "[NETLINK]Failed to initialize pthread attribute for Netlink -> PDCP communication (%d:%s)\n",
-            errno, strerror(errno));
-      exit(EXIT_FAILURE);
-    }
-
-    sched_param.sched_priority = 10;
-
-    pthread_attr_setschedpolicy(&attr, SCHED_RR);
-    pthread_attr_setschedparam(&attr, &sched_param);
 
     /* Create one thread that fetchs packets from the netlink.
      * When the netlink fifo is full, packets are silently dropped, this behaviour
      * should be avoided if we want a reliable link.
      */
-    if (pthread_create(&pdcp_netlink_thread, &attr, pdcp_netlink_thread_fct, NULL) != 0) {
-      LOG_E(PDCP, "[NETLINK]Failed to create new thread for Netlink/PDCP communication (%d:%s)\n",
-            errno, strerror(errno));
-      exit(EXIT_FAILURE);
-    }
-
-    pthread_setname_np( pdcp_netlink_thread, "PDCP netlink" );
+    threadCreate(&pdcp_netlink_thread, pdcp_netlink_thread_fct,  "PDCP netlink", -1, OAI_PRIORITY_RT_LOW );
   }
 
   return 0;
diff --git a/openair2/LAYER2/PDCP_v10.1.0/pdcp_thread.c b/openair2/LAYER2/PDCP_v10.1.0/pdcp_thread.c
index 0b6be93d59..f1f6ebb794 100644
--- a/openair2/LAYER2/PDCP_v10.1.0/pdcp_thread.c
+++ b/openair2/LAYER2/PDCP_v10.1.0/pdcp_thread.c
@@ -45,7 +45,6 @@ extern int  oai_exit;
 extern char UE_flag;
 
 pthread_t       pdcp_thread;
-pthread_attr_t  pdcp_thread_attr;
 pthread_mutex_t pdcp_mutex;
 pthread_cond_t  pdcp_cond;
 int             pdcp_instance_cnt;
@@ -101,33 +100,12 @@ static void *pdcp_thread_main(void* param)
 int init_pdcp_thread(void)
 {
 
-  int    error_code;
-  struct sched_param p;
-
-  pthread_attr_init (&pdcp_thread_attr);
-  pthread_attr_setstacksize(&pdcp_thread_attr,OPENAIR_THREAD_STACK_SIZE);
-  //attr_dlsch_threads.priority = 1;
-
-  p.sched_priority = OPENAIR_THREAD_PRIORITY;
-  pthread_attr_setschedparam  (&pdcp_thread_attr, &p);
-  pthread_attr_setschedpolicy (&pdcp_thread_attr, SCHED_FIFO);
   pthread_mutex_init(&pdcp_mutex,NULL);
   pthread_cond_init(&pdcp_cond,NULL);
 
   pdcp_instance_cnt = -1;
   LOG_I(PDCP,"Allocating PDCP thread\n");
-  error_code = pthread_create(&pdcp_thread,
-                              &pdcp_thread_attr,
-                              pdcp_thread_main,
-                              (void*)NULL);
-
-  if (error_code!= 0) {
-    LOG_I(PDCP,"Could not allocate PDCP thread, error %d\n",error_code);
-    return(error_code);
-  } else {
-    LOG_I(PDCP,"Allocate PDCP thread successful\n");
-    pthread_setname_np( pdcp_thread, "PDCP" );
-  }
+  threadCreate(&pdcp_thread, pdcp_thread_main, (void*)NULL, "PDCP", -1, OAI_PRIORITY_RT);
 
   return(0);
 }
diff --git a/openair2/NR_UE_PHY_INTERFACE/NR_IF_Module.c b/openair2/NR_UE_PHY_INTERFACE/NR_IF_Module.c
index 840cb5b4cc..c9f393cf46 100644
--- a/openair2/NR_UE_PHY_INTERFACE/NR_IF_Module.c
+++ b/openair2/NR_UE_PHY_INTERFACE/NR_IF_Module.c
@@ -34,6 +34,7 @@
 #include "mac_proto.h"
 #include "assertions.h"
 #include "LAYER2/NR_MAC_UE/mac_extern.h"
+#include "SCHED_NR_UE/fapi_nr_ue_l1.h"
 
 #include <stdio.h>
 
@@ -42,9 +43,10 @@
 static nr_ue_if_module_t *nr_ue_if_module_inst[MAX_IF_MODULES];
 
 //  L2 Abstraction Layer
-int handle_bcch_bch(module_id_t module_id, int cc_id, unsigned int gNB_index, uint8_t *pduP, unsigned int additional_bits, uint32_t ssb_index, uint32_t ssb_length, uint16_t cell_id){
+int handle_bcch_bch(UE_nr_rxtx_proc_t *proc, module_id_t module_id, int cc_id, unsigned int gNB_index, uint8_t *pduP, unsigned int additional_bits, uint32_t ssb_index, uint32_t ssb_length, uint16_t cell_id){
 
-  return nr_ue_decode_mib( module_id,
+  return nr_ue_decode_mib( proc,
+		           module_id,
 			   cc_id,
 			   gNB_index,
 			   additional_bits,
@@ -63,7 +65,7 @@ int handle_bcch_dlsch(module_id_t module_id, int cc_id, unsigned int gNB_index,
 //  L2 Abstraction Layer
 int handle_dci(module_id_t module_id, int cc_id, unsigned int gNB_index, fapi_nr_dci_pdu_rel15_t *dci, uint16_t rnti, uint32_t dci_type){
 
-  printf("handle_dci: rnti %x,dci_type %d\n",rnti,dci_type);
+  //printf("handle_dci: rnti %x,dci_type %d\n",rnti,dci_type);
   return nr_ue_process_dci(module_id, cc_id, gNB_index, dci, rnti, dci_type);
 
 }
@@ -102,13 +104,13 @@ int nr_ue_ul_indication(nr_uplink_indication_t *ul_info){
 			0, 0); //  TODO check tx/rx frame/slot is need for NR version
 
   switch(ret){
-  case CONNECTION_OK:
+  case UE_CONNECTION_OK:
     break;
-  case CONNECTION_LOST:
+  case UE_CONNECTION_LOST:
     break;
-  case PHY_RESYNCH:
+  case UE_PHY_RESYNCH:
     break;
-  case PHY_HO_PRACH:
+  case UE_PHY_HO_PRACH:
     break;
   default:
     break;
@@ -126,16 +128,26 @@ int nr_ue_dl_indication(nr_downlink_indication_t *dl_info){
   uint32_t ret_mask = 0x0;
   module_id_t module_id = dl_info->module_id;
   NR_UE_MAC_INST_t *mac = get_mac_inst(module_id);
+  fapi_nr_dl_config_request_t *dl_config = &mac->dl_config_request;
+  fapi_nr_ul_config_request_t *ul_config = &mac->ul_config_request;
 
-  //  clean up scheduled_response structure
-
+  dl_config->number_pdus = 0;
+  ul_config->number_pdus = 0;
+  //hook up pointers
+  mac->scheduled_response.dl_config = dl_config;
+  mac->scheduled_response.ul_config = ul_config;
+  mac->scheduled_response.tx_request = &mac->tx_request;
+  mac->scheduled_response.module_id = dl_info->module_id;
+  mac->scheduled_response.CC_id = dl_info->cc_id;
+  mac->scheduled_response.frame = dl_info->frame;
+  mac->scheduled_response.slot = dl_info->slot;
 
   if(dl_info->dci_ind != NULL){
-    printf("[L2][IF MODULE][DL INDICATION][DCI_IND]\n");
+    LOG_D(MAC,"[L2][IF MODULE][DL INDICATION][DCI_IND]\n");
     for(i=0; i<dl_info->dci_ind->number_of_dcis; ++i){
-      printf(">>>NR_IF_Module i=%d, dl_info->dci_ind->number_of_dcis=%d\n",i,dl_info->dci_ind->number_of_dcis);
+      LOG_I(MAC,">>>NR_IF_Module i=%d, dl_info->dci_ind->number_of_dcis=%d\n",i,dl_info->dci_ind->number_of_dcis);
       fapi_nr_dci_pdu_rel15_t *dci = &dl_info->dci_ind->dci_list[i].dci;
-      /*
+
       ret_mask |= (handle_dci(
 			      dl_info->module_id,
 			      dl_info->cc_id,
@@ -143,7 +155,7 @@ int nr_ue_dl_indication(nr_downlink_indication_t *dl_info){
 			      dci, 
 			      (dl_info->dci_ind->dci_list+i)->rnti, 
 			      (dl_info->dci_ind->dci_list+i)->dci_format)) << FAPI_NR_DCI_IND;
-      */
+
 
       /*switch((dl_info->dci_ind->dci_list+i)->dci_type){
 	case FAPI_NR_DCI_TYPE_0_0:
@@ -193,11 +205,12 @@ int nr_ue_dl_indication(nr_downlink_indication_t *dl_info){
   }
 
   if(dl_info->rx_ind != NULL){
-    printf("[L2][IF MODULE][DL INDICATION][RX_IND]\n");
+    LOG_I(MAC,"[L2][IF MODULE][DL INDICATION][RX_IND]\n");
     for(i=0; i<dl_info->rx_ind->number_pdus; ++i){
       switch(dl_info->rx_ind->rx_indication_body[i].pdu_type){
       case FAPI_NR_RX_PDU_TYPE_MIB:
-	ret_mask |= (handle_bcch_bch(dl_info->module_id, dl_info->cc_id, dl_info->gNB_index,
+	ret_mask |= (handle_bcch_bch( dl_info->proc,
+				     dl_info->module_id, dl_info->cc_id, dl_info->gNB_index,
 				     (dl_info->rx_ind->rx_indication_body+i)->mib_pdu.pdu,
 				     (dl_info->rx_ind->rx_indication_body+i)->mib_pdu.additional_bits,
 				     (dl_info->rx_ind->rx_indication_body+i)->mib_pdu.ssb_index,
@@ -244,8 +257,8 @@ nr_ue_if_module_t *nr_ue_if_module_init(uint32_t module_id){
     nr_ue_if_module_inst[module_id]->cc_mask=0;
     nr_ue_if_module_inst[module_id]->current_frame = 0;
     nr_ue_if_module_inst[module_id]->current_slot = 0;
-    nr_ue_if_module_inst[module_id]->phy_config_request = NULL;
-    nr_ue_if_module_inst[module_id]->scheduled_response = NULL;
+    nr_ue_if_module_inst[module_id]->phy_config_request = nr_ue_phy_config_request;
+    nr_ue_if_module_inst[module_id]->scheduled_response = nr_ue_scheduled_response;
     nr_ue_if_module_inst[module_id]->dl_indication = nr_ue_dl_indication;
     nr_ue_if_module_inst[module_id]->ul_indication = nr_ue_ul_indication;
   }
@@ -264,6 +277,7 @@ int nr_ue_if_module_kill(uint32_t module_id) {
 int nr_ue_dcireq(nr_dcireq_t *dcireq) {
   
   fapi_nr_dl_config_request_t *dl_config=&dcireq->dl_config_req;
+  NR_UE_MAC_INST_t *UE_mac = get_mac_inst(0);
   
   //  Type0 PDCCH search space
   dl_config->number_pdus =  1;
@@ -305,7 +319,7 @@ int nr_ue_dcireq(nr_dcireq_t *dcireq) {
   dl_config->dl_config_list[0].dci_config_pdu.dci_config_rel15.duration = search_space_duration;
   dl_config->dl_config_list[0].dci_config_pdu.dci_config_rel15.monitoring_symbols_within_slot = (0x3fff << first_symbol_index) & (0x3fff >> (14-coreset_duration-first_symbol_index)) & 0x3fff;
 
-  dl_config->dl_config_list[0].dci_config_pdu.dci_config_rel15.N_RB_BWP = 106;
+  dl_config->dl_config_list[0].dci_config_pdu.dci_config_rel15.N_RB_BWP = UE_mac->initial_bwp_dl.N_RB;
 
   
   return 0;
diff --git a/openair2/NR_UE_PHY_INTERFACE/NR_IF_Module.h b/openair2/NR_UE_PHY_INTERFACE/NR_IF_Module.h
index 0ecba9736d..c1c8522749 100755
--- a/openair2/NR_UE_PHY_INTERFACE/NR_IF_Module.h
+++ b/openair2/NR_UE_PHY_INTERFACE/NR_IF_Module.h
@@ -34,6 +34,7 @@
 #define __NR_IF_MODULE_H__
 
 #include "platform_types.h"
+#include <openair1/PHY/thread_NR_UE.h>
 #include "fapi_nr_ue_interface.h"
 
 
@@ -64,6 +65,7 @@ typedef struct {
     frame_t frame;
     /// slot
     int slot;
+    UE_nr_rxtx_proc_t * proc;
 
     /// NR UE FAPI-like P7 message, direction: L1 to L2
     /// data reception indication structure
@@ -209,7 +211,7 @@ int nr_ue_dcireq(nr_dcireq_t *dcireq);
    \param ssb_index       SSB index within 0 - (L_ssb-1) corresponding to 38.331 ch.13 parameter i
    \param ssb_length      corresponding to L1 parameter L_ssb 
    \param cell_id         cell id */
-int handle_bcch_bch(module_id_t module_id, int cc_id, unsigned int gNB_index, uint8_t *pduP, unsigned int additional_bits, uint32_t ssb_index, uint32_t ssb_length, uint16_t cell_id);
+int handle_bcch_bch(UE_nr_rxtx_proc_t *proc, module_id_t module_id, int cc_id, unsigned int gNB_index, uint8_t *pduP, unsigned int additional_bits, uint32_t ssb_index, uint32_t ssb_length, uint16_t cell_id);
 
 //  TODO check
 /**\brief handle BCCH-DL-SCH message from dl_indication
diff --git a/openair2/PHY_INTERFACE/UE_MAC_interface.h b/openair2/PHY_INTERFACE/UE_MAC_interface.h
index d010109f99..cadaf621d6 100644
--- a/openair2/PHY_INTERFACE/UE_MAC_interface.h
+++ b/openair2/PHY_INTERFACE/UE_MAC_interface.h
@@ -38,7 +38,7 @@
 
 #include "nfapi_interface.h"
 #include "openair1/PHY/impl_defs_lte.h"
-#include "targets/COMMON/openairinterface5g_limits.h"
+#include "openairinterface5g_limits.h"
 
 
 
diff --git a/openair2/RRC/LTE/defs_NB_IoT.h b/openair2/RRC/LTE/defs_NB_IoT.h
index 0cc8a37bc0..422a5dcf9c 100644
--- a/openair2/RRC/LTE/defs_NB_IoT.h
+++ b/openair2/RRC/LTE/defs_NB_IoT.h
@@ -42,7 +42,7 @@
 #include "rrc_types_NB_IoT.h"
 #include "COMMON/platform_constants.h"
 #include "COMMON/platform_types.h"
-#include "targets/COMMON/openairinterface5g_limits.h"
+#include "openairinterface5g_limits.h"
 
 #include "COMMON/mac_rrc_primitives.h"
 
diff --git a/openair2/RRC/LTE/rrc_UE.c b/openair2/RRC/LTE/rrc_UE.c
index 42d1e04caa..ca4a565250 100644
--- a/openair2/RRC/LTE/rrc_UE.c
+++ b/openair2/RRC/LTE/rrc_UE.c
@@ -76,6 +76,7 @@
 #include "pdcp.h"
 #include "plmn_data.h"
 #include "msc.h"
+#include <common/utils/system.h>
 
 #if defined(ENABLE_ITTI)
 # include "intertask_interface.h"
@@ -5476,8 +5477,6 @@ rrc_ue_process_sidelink_radioResourceConfig(
 void rrc_control_socket_init(){
 
    struct sockaddr_in rrc_ctrl_socket_addr;
-   pthread_attr_t     attr;
-   struct sched_param sched_param;
    int optval; // flag value for setsockopt
    //int n; // message byte size
 
@@ -5505,27 +5504,10 @@ void rrc_control_socket_init(){
       LOG_E(RRC,"[rrc_control_socket_init] ERROR: Failed on binding the socket\n");
       exit(1);
    }
-   //create thread to listen to incoming packets
-   if (pthread_attr_init(&attr) != 0) {
-      LOG_E(RRC, "[rrc_control_socket_init]Failed to initialize pthread attribute for ProSe -> RRC communication (%d:%s)\n",
-            errno, strerror(errno));
-      exit(EXIT_FAILURE);
-   }
-
-   sched_param.sched_priority = 10;
-
-   pthread_attr_setschedpolicy(&attr, SCHED_RR);
-   pthread_attr_setschedparam(&attr, &sched_param);
 
    pthread_t rrc_control_socket_thread;
 
-   if (pthread_create(&rrc_control_socket_thread, &attr, rrc_control_socket_thread_fct, NULL) != 0) {
-      LOG_E(RRC, "[rrc_control_socket_init]Failed to create new thread for RRC/ProSeApp communication (%d:%s)\n",
-            errno, strerror(errno));
-      exit(EXIT_FAILURE);
-   }
-
-   pthread_setname_np( rrc_control_socket_thread, "RRC Control Socket" );
+   threadCreate(&rrc_control_socket_thread, rrc_control_socket_thread_fct, NULL, "RRC/ProSeApp", -1, OAI_PRIORITY_RT);
 
 }
 
diff --git a/openair2/RRC/LTE/rrc_extern.h b/openair2/RRC/LTE/rrc_extern.h
index 59200fb9cc..68c805dffe 100644
--- a/openair2/RRC/LTE/rrc_extern.h
+++ b/openair2/RRC/LTE/rrc_extern.h
@@ -44,17 +44,11 @@ extern LogicalChannelConfig_t SRB1_logicalChannelConfig_defaultValue;
 extern LogicalChannelConfig_t SRB2_logicalChannelConfig_defaultValue;
 
 
-#ifndef PHY_EMUL
-#ifndef PHYSIM
-//#define NB_INST 1
-#else
 extern unsigned char NB_INST;
-#endif
 extern unsigned char NB_eNB_INST;
 extern unsigned char NB_UE_INST;
 extern unsigned short NODE_ID[1];
 extern void* bigphys_malloc(int);
-#endif
 
 
 //CONSTANTS
diff --git a/openair2/RRC/NR/L2_nr_interface.c b/openair2/RRC/NR/L2_nr_interface.c
index 0dca3b80d2..c8cdfd336f 100644
--- a/openair2/RRC/NR/L2_nr_interface.c
+++ b/openair2/RRC/NR/L2_nr_interface.c
@@ -58,7 +58,6 @@ int8_t mac_rrc_nr_data_req(const module_id_t Mod_idP,
   uint8_t sfn_msb                     = (uint8_t)((frameP>>4)&0x3f);
   
 #ifdef DEBUG_RRC
-  int i;
   LOG_I(RRC,"[eNB %d] mac_rrc_data_req to SRB ID=%d\n",Mod_idP,Srb_id);
 #endif
 
diff --git a/openair2/RRC/NR/MESSAGES/asn1_msg.c b/openair2/RRC/NR/MESSAGES/asn1_msg.c
index df45ae5e05..1b3e367ec7 100644
--- a/openair2/RRC/NR/MESSAGES/asn1_msg.c
+++ b/openair2/RRC/NR/MESSAGES/asn1_msg.c
@@ -747,15 +747,21 @@ void do_SERVINGCELLCONFIGCOMMON(uint8_t Mod_id,
   //ssb_PositionsInBurst
   (*servingcellconfigcommon)->ssb_PositionsInBurst->present = configuration->ServingCellConfigCommon_ssb_PositionsInBurst_PR[CC_id];
 
-  if((*servingcellconfigcommon)->ssb_PositionsInBurst->present == NR_ServingCellConfigCommon__ssb_PositionsInBurst_PR_shortBitmap){
+  uint64_t t_freq;
+  if(configuration->nr_band[CC_id] == 41 || (configuration->nr_band[CC_id] > 76 && configuration->nr_band[CC_id] < 80))
+	t_freq = 2400000000;
+  else
+	t_freq = 3000000000;
+
+  if(configuration->downlink_frequency[CC_id]<t_freq){
     (*servingcellconfigcommon)->ssb_PositionsInBurst->choice.shortBitmap.size = 1;
     (*servingcellconfigcommon)->ssb_PositionsInBurst->choice.shortBitmap.bits_unused = 4;
-    (*servingcellconfigcommon)->ssb_PositionsInBurst->choice.shortBitmap.buf[0] = 0x0f;
-  }else if((*servingcellconfigcommon)->ssb_PositionsInBurst->present == NR_ServingCellConfigCommon__ssb_PositionsInBurst_PR_mediumBitmap){
+    (*servingcellconfigcommon)->ssb_PositionsInBurst->choice.shortBitmap.buf[0] = configuration->ServingCellConfigCommon_ssb_PositionsInBurst_PR[CC_id];
+  }else if(configuration->downlink_frequency[CC_id]<6000000000){
     (*servingcellconfigcommon)->ssb_PositionsInBurst->choice.mediumBitmap.size = 1;
     (*servingcellconfigcommon)->ssb_PositionsInBurst->choice.mediumBitmap.bits_unused = 0;
-    (*servingcellconfigcommon)->ssb_PositionsInBurst->choice.mediumBitmap.buf[0] = 0xff;
-  }else if((*servingcellconfigcommon)->ssb_PositionsInBurst->present == NR_ServingCellConfigCommon__ssb_PositionsInBurst_PR_longBitmap){
+    (*servingcellconfigcommon)->ssb_PositionsInBurst->choice.mediumBitmap.buf[0] = configuration->ServingCellConfigCommon_ssb_PositionsInBurst_PR[CC_id];
+  }else {
     (*servingcellconfigcommon)->ssb_PositionsInBurst->choice.longBitmap.size = 8;
     (*servingcellconfigcommon)->ssb_PositionsInBurst->choice.longBitmap.bits_unused = 0;
     (*servingcellconfigcommon)->ssb_PositionsInBurst->choice.longBitmap.buf[0] = 0xff;
@@ -768,6 +774,7 @@ void do_SERVINGCELLCONFIGCOMMON(uint8_t Mod_id,
     (*servingcellconfigcommon)->ssb_PositionsInBurst->choice.longBitmap.buf[7] = 0xff;
   }
 
+
   //ssb_periodicityServingCell
   *(*servingcellconfigcommon)->ssb_periodicityServingCell  = configuration->ServingCellConfigCommon_ssb_periodicityServingCell[CC_id];
   //dmrs_TypeA_Position
diff --git a/openair2/RRC/NR/nr_rrc_extern.h b/openair2/RRC/NR/nr_rrc_extern.h
index 7509dfc727..a9af422f02 100644
--- a/openair2/RRC/NR/nr_rrc_extern.h
+++ b/openair2/RRC/NR/nr_rrc_extern.h
@@ -43,17 +43,11 @@ extern LogicalChannelConfig_t SRB1_logicalChannelConfig_defaultValue;
 extern LogicalChannelConfig_t SRB2_logicalChannelConfig_defaultValue;
 
 
-#ifndef PHY_EMUL
-#ifndef PHYSIM
-//#define NB_INST 1
-#else
 extern unsigned char NB_INST;
-#endif
 extern unsigned char NB_eNB_INST;
 extern unsigned char NB_UE_INST;
 extern unsigned short NODE_ID[1];
 extern void* bigphys_malloc(int);
-#endif
 
 
 //CONSTANTS
diff --git a/openair2/RRC/NR/rrc_gNB.c b/openair2/RRC/NR/rrc_gNB.c
index 10fc6b6a4e..749320b357 100644
--- a/openair2/RRC/NR/rrc_gNB.c
+++ b/openair2/RRC/NR/rrc_gNB.c
@@ -116,10 +116,9 @@ mui_t                               rrc_gNB_mui = 0;
 
 void openair_nr_rrc_on(const protocol_ctxt_t* const ctxt_pP){
   
-  int            CC_id;
   LOG_I(NR_RRC, PROTOCOL_NR_RRC_CTXT_FMT" gNB:OPENAIR NR RRC IN....\n",PROTOCOL_NR_RRC_CTXT_ARGS(ctxt_pP));
 
-  for (CC_id = 0; CC_id < MAX_NUM_CCs; CC_id++) {
+  for (int CC_id = 0; CC_id < MAX_NUM_CCs; CC_id++) {
     rrc_config_nr_buffer (&RC.nrrrc[ctxt_pP->module_id]->carrier[CC_id].SI, BCCH, 1);
     RC.nrrrc[ctxt_pP->module_id]->carrier[CC_id].SI.Active = 1;
     rrc_config_nr_buffer (&RC.nrrrc[ctxt_pP->module_id]->carrier[CC_id].Srb0, CCCH, 1);
@@ -141,19 +140,18 @@ void rrc_gNB_process_SgNBAdditionRequest(
 
 void rrc_gNB_generate_SgNBAdditionRequestAcknowledge( 
      const protocol_ctxt_t  *const ctxt_pP,
-     rrc_gNB_ue_context_t   *const ue_context_pP
-     ){
-  
-  uint8_t size;
-  uint8_t buffer[100];
-  int     CC_id = ue_context_pP->ue_context.primaryCC_id;
-  OCTET_STRING_t                                      *secondaryCellGroup;
+     rrc_gNB_ue_context_t   *const ue_context_pP)
+{
+  //uint8_t size;
+  //uint8_t buffer[100];
+  //int     CC_id = ue_context_pP->ue_context.primaryCC_id;
+  //OCTET_STRING_t                                      *secondaryCellGroup;
   NR_CellGroupConfig_t                                *cellGroupconfig;
   struct NR_CellGroupConfig__rlc_BearerToAddModList   *rlc_BearerToAddModList;
   struct NR_MAC_CellGroupConfig                       *mac_CellGroupConfig;
   struct NR_PhysicalCellGroupConfig                   *physicalCellGroupConfig;
   struct NR_SpCellConfig                              *spCellConfig;
-  struct NR_CellGroupConfig__sCellToAddModList        *sCellToAddModList;
+  //struct NR_CellGroupConfig__sCellToAddModList        *sCellToAddModList;
 
   cellGroupconfig                           = CALLOC(1,sizeof(NR_CellGroupConfig_t));
   cellGroupconfig->rlc_BearerToAddModList   = CALLOC(1,sizeof(struct NR_CellGroupConfig__rlc_BearerToAddModList));
@@ -236,7 +234,7 @@ static void init_NR_SI(const protocol_ctxt_t* const ctxt_pP,
   RC.nrrrc[ctxt_pP->module_id]->carrier[CC_id].Ncp_UL          = configuration->UL_prefix_type[CC_id];
   RC.nrrrc[ctxt_pP->module_id]->carrier[CC_id].dl_CarrierFreq  = configuration->downlink_frequency[CC_id];
   RC.nrrrc[ctxt_pP->module_id]->carrier[CC_id].ul_CarrierFreq  = configuration->downlink_frequency[CC_id]+ configuration->uplink_frequency_offset[CC_id];
-  
+
   ///MIB
   RC.nrrrc[ctxt_pP->module_id]->carrier[CC_id].sizeof_MIB      = 0;
   RC.nrrrc[ctxt_pP->module_id]->carrier[CC_id].MIB             = (uint8_t*) malloc16(4);
@@ -261,11 +259,13 @@ static void init_NR_SI(const protocol_ctxt_t* const ctxt_pP,
   
   LOG_I(NR_RRC,"Done init_NR_SI\n");
   
-  
+
   rrc_mac_config_req_gNB(ctxt_pP->module_id,
                          CC_id,
+			 RC.nrrrc[ctxt_pP->module_id]->carrier[CC_id].physCellId,
                          RC.nrrrc[ctxt_pP->module_id]->carrier[CC_id].p_gNB,
                          configuration->nr_band[CC_id],
+			 configuration->ServingCellConfigCommon_ssb_PositionsInBurst_PR[CC_id],
                          RC.nrrrc[ctxt_pP->module_id]->carrier[CC_id].dl_CarrierFreq,
                          configuration->N_RB_DL[CC_id],
                          (NR_BCCH_BCH_Message_t *)&RC.nrrrc[ctxt_pP->module_id]->carrier[CC_id].mib,
diff --git a/openair2/UTIL/ASYNC_IF/link_manager.c b/openair2/UTIL/ASYNC_IF/link_manager.c
index c1ce742d0b..e67b7b0ec8 100644
--- a/openair2/UTIL/ASYNC_IF/link_manager.c
+++ b/openair2/UTIL/ASYNC_IF/link_manager.c
@@ -30,6 +30,8 @@
 
 #include "link_manager.h"
 #include "common/utils/LOG/log.h"
+#include <common/utils/assertions.h>
+#include <common/utils/system.h>
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -103,50 +105,21 @@ link_manager_t *create_link_manager(
 
   LOG_D(MAC, "create new link manager\n");
 
-  ret = calloc(1, sizeof(link_manager_t));
-  if (ret == NULL)
-    goto error;
+  AssertFatal( (ret=calloc(1, sizeof(link_manager_t))) != NULL,"");
 
   ret->send_queue = send_queue;
   ret->receive_queue = receive_queue;
   ret->socket_link = link;
   ret->run = 1;
 
-  if (pthread_attr_init(&attr))
-    goto error;
-
-  // Make the async interface threads real-time
-  //#ifndef LOWLATENCY
-  struct sched_param sched_param_recv_thread;
-
-  sched_param_recv_thread.sched_priority = sched_get_priority_max(SCHED_RR) - 1;
-  pthread_attr_setschedparam(&attr, &sched_param_recv_thread);
-  pthread_attr_setschedpolicy(&attr, SCHED_RR);
-  //#endif
-
-  if (pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED))
-    goto error;
-
-  if (pthread_create(&t, &attr, link_manager_sender_thread, ret))
-    goto error;
+  threadCreate(&t, link_manager_sender_thread, ret, "flexranSender", -1, OAI_PRIORITY_RT_LOW);
   ret->sender = t;
 
-  if (pthread_create(&t, &attr, link_manager_receiver_thread, ret))
-    /* we should destroy the other thread here */
-    goto error;
+  threadCreate(&t, link_manager_receiver_thread, ret, "flexranReceiver", -1, OAI_PRIORITY_RT_LOW);
   ret->receiver = t;
 
-  if (pthread_attr_destroy(&attr))
-    /* to be clean we should destroy the threads at this point,
-     * even if in practice we never reach it */
-    goto error;
-
   return ret;
 
-error:
-  LOG_E(MAC, "%s: an error occured\n", __FUNCTION__);
-  free(ret);
-  return NULL;
 }
 
 void destroy_link_manager(link_manager_t *manager)
diff --git a/openair2/UTIL/CLI/cli_server.c b/openair2/UTIL/CLI/cli_server.c
index d4f97f15ba..1994855b5d 100644
--- a/openair2/UTIL/CLI/cli_server.c
+++ b/openair2/UTIL/CLI/cli_server.c
@@ -90,10 +90,7 @@ int cli_server_init(cli_handler_t handler)
   }
 
   /* create telnet listener thread */
-  if (pthread_create(&cli_server_listener, NULL, cli_server_listen, NULL)) {
-    perror("thread");
-    return -1;
-  }
+  threadCreate(&cli_server_listener, cli_server_listen, NULL, "telnet", -1, OAI_PRIORITY_RT_LOW);
 
   return 0;
 }
diff --git a/openair2/UTIL/OPT/probe.c b/openair2/UTIL/OPT/probe.c
index a1e5367168..f2296017b8 100644
--- a/openair2/UTIL/OPT/probe.c
+++ b/openair2/UTIL/OPT/probe.c
@@ -90,6 +90,7 @@ what about the implementation
 
 #include <pthread.h>
 #include <stdint.h>
+#include <common/utils/system.h>
 
 #include "opt.h"
 
@@ -203,15 +204,7 @@ int opt_create_listener_socket(char *ip_address, uint16_t port)
     return -1;
   }
 
-  ret = pthread_create(&opt_listener.thread, NULL, opt_listener_thread, NULL);
-
-  if (ret != 0) {
-    LOG_E(OPT, "Failed to create thread for server socket: %s\n", strerror(errno));
-    opt_type = OPT_NONE;
-    close(opt_listener.sd);
-    opt_listener.sd = -1;
-    return -1;
-  }
+  threadCreate(&opt_listener.thread, opt_listener_thread, NULL, "flexran", -1, OAI_PRIORITY_RT_LOW);
 
   return 0;
 }
diff --git a/openair2/UTIL/OTG/otg_rx_socket.c b/openair2/UTIL/OTG/otg_rx_socket.c
index 88ecd3e904..9e9b6bf4a1 100644
--- a/openair2/UTIL/OTG/otg_rx_socket.c
+++ b/openair2/UTIL/OTG/otg_rx_socket.c
@@ -195,17 +195,7 @@ void server_socket_tcp_ip4()
 
 
               /* create  new thread for the new connection */
-              if (pthread_create(&id, NULL, (void *)recv_ip4_tcp, (void*)csock))
-                LOG_W(OTG,"SOCKET:: TCP-IP4 ::pthread_create OK!\n");
-
-              else
-                LOG_W(OTG,"SOCKET:: TCP-IP4 ::Error in pthread_create \n");
-
-              if (pthread_detach(id))
-                LOG_W(OTG,"SOCKET:: TCP-IP4 ::pthread_detach OK!\n");
-              else
-                LOG_W(OTG,"SOCKET:: TCP-IP4 ::Error in pthread_detach\n");
-
+              threadCreate(&id, (void *)recv_ip4_tcp, (void*)csock), "OTG", -1, OAI_PRIORITY_RT_LOW);
               LOG_I(OTG,"SOCKET:: TCP-IP4 :: Client n=%d finish transmission\n", cmpt_cl);
               cmpt_cl+=1;
             }
diff --git a/openair3/NAS/COMMON/UTIL/nas_timer.c b/openair3/NAS/COMMON/UTIL/nas_timer.c
index d92c48f483..7ddcb61d1d 100644
--- a/openair3/NAS/COMMON/UTIL/nas_timer.c
+++ b/openair3/NAS/COMMON/UTIL/nas_timer.c
@@ -397,24 +397,14 @@ static void _nas_timer_handler(int signal)
   /* Get the timer entry for which the system timer expired */
   nas_timer_entry_t *te = _nas_timer_db.head->entry;
 
-  /* Execute the callback function */
-  pthread_attr_t attr;
-  pthread_attr_init(&attr);
-  pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
-  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
-  int rc = pthread_create (&te->pid, &attr, te->cb, te->args);
-  pthread_attr_destroy(&attr);
+  threadCreate (&te->pid, te->cb, te->args, "nas-timer", -1, OAI_PRIORITY_RT_LOW);
 
-  /* Wait for the thread to terminate before releasing the timer entry */
-  if (rc == 0) {
     void *result = NULL;
     (void) pthread_join(te->pid, &result);
 
-    /* TODO: Check returned result ??? */
     if (result) {
       free(result);
     }
-  }
 }
 #endif
 
diff --git a/openair3/NAS/UE/UEprocess.c b/openair3/NAS/UE/UEprocess.c
index 6a70911e21..7fe1435960 100644
--- a/openair3/NAS/UE/UEprocess.c
+++ b/openair3/NAS/UE/UEprocess.c
@@ -150,39 +150,20 @@ int main(int argc, const char *argv[])
   (void) _nas_set_signal_handler (SIGINT, _nas_signal_handler);
   (void) _nas_set_signal_handler (SIGTERM, _nas_signal_handler);
 
-  pthread_attr_t attr;
-  pthread_attr_init (&attr);
-  pthread_attr_setscope (&attr, PTHREAD_SCOPE_SYSTEM);
-  pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
-
   /*
    * Start thread use to manage the user connection endpoint
    */
   pthread_t user_mngr;
 
-  if (pthread_create (&user_mngr, &attr, _nas_user_mngr, &user_fd) != 0) {
-    LOG_TRACE (ERROR, "UE-MAIN   - "
-               "Failed to create the user management thread");
-    user_api_close (user_api_id);
-    network_api_close (network_fd);
-    exit (EXIT_FAILURE);
-  }
+  threadCreate (&user_mngr, , _nas_user_mngr, &user_fd, "UE-nas", -1, OAI_PRIORITY_RT_LOW) ;
 
   /*
    * Start thread use to manage the network connection endpoint
    */
   pthread_t network_mngr;
 
-  if (pthread_create (&network_mngr, &attr, _nas_network_mngr,
-                      &network_fd) != 0) {
-    LOG_TRACE (ERROR, "UE-MAIN   - "
-               "Failed to create the network management thread");
-    user_api_close (user_api_id);
-    network_api_close (network_fd);
-    exit (EXIT_FAILURE);
-  }
-
-  pthread_attr_destroy (&attr);
+  threadCreate (&network_mngr,  _nas_network_mngr,
+                      &network_fd, "UE-nas-mgr", -1, OAI_PRIORITY_RT_LOW) ;
 
   /*
    * Suspend execution of the main process until all connection
diff --git a/openair3/SCTP/sctp_eNB_task.c b/openair3/SCTP/sctp_eNB_task.c
index e7265d66d6..60f233bc4a 100644
--- a/openair3/SCTP/sctp_eNB_task.c
+++ b/openair3/SCTP/sctp_eNB_task.c
@@ -40,6 +40,7 @@
 #include <arpa/inet.h>
 
 #include "assertions.h"
+#include "common/utils/system.h"
 #include "queue.h"
 
 #include "intertask_interface.h"
diff --git a/targets/ARCH/COMMON/common_lib.h b/targets/ARCH/COMMON/common_lib.h
index 685a628b26..5530a68f9b 100644
--- a/targets/ARCH/COMMON/common_lib.h
+++ b/targets/ARCH/COMMON/common_lib.h
@@ -19,8 +19,8 @@
  *      contact@openairinterface.org
  */
 
-/*! \file common_lib.h 
- * \brief common APIs for different RF frontend device 
+/*! \file common_lib.h
+ * \brief common APIs for different RF frontend device
  * \author HongliangXU, Navid Nikaein
  * \date 2015
  * \version 0.2
@@ -45,21 +45,16 @@
 #define RAU_REMOTE_RADIO_HEAD 1
 
 #ifndef MAX_CARDS
-#define MAX_CARDS 8
+  #define MAX_CARDS 8
 #endif
 
 typedef int64_t openair0_timestamp;
 typedef volatile int64_t openair0_vtimestamp;
 
- 
+
 /*!\brief structrue holds the parameters to configure USRP devices*/
 typedef struct openair0_device_t openair0_device;
 
-
-
-
-
-
 //#define USRP_GAIN_OFFSET (56.0)  // 86 calibrated for USRP B210 @ 2.6 GHz to get equivalent RS EPRE in OAI to SMBV100 output
 
 typedef enum {
@@ -80,9 +75,6 @@ typedef enum {
  */
 /*!\brief RF device types
  */
-#ifdef OCP_FRAMEWORK
-#include <enums.h>
-#else
 typedef enum {
   MIN_RF_DEV_TYPE = 0,
   /*!\brief device is ExpressMIMO */
@@ -104,7 +96,6 @@ typedef enum {
   MAX_RF_DEV_TYPE
 
 } dev_type_t;
-#endif
 
 /*!\brief transport protocol types
  */
@@ -122,16 +113,16 @@ typedef enum {
 /*!\brief  openair0 device host type */
 typedef enum {
   MIN_HOST_TYPE = 0,
- /*!\brief device functions within a RAU */
+  /*!\brief device functions within a RAU */
   RAU_HOST,
- /*!\brief device functions within a RRU */
+  /*!\brief device functions within a RRU */
   RRU_HOST,
   MAX_HOST_TYPE
 
-}host_type_t;
+} host_type_t;
 
 
-/*! \brief RF Gain clibration */ 
+/*! \brief RF Gain clibration */
 typedef struct {
   //! Frequency for which RX chain was calibrated
   double freq;
@@ -159,7 +150,7 @@ typedef struct {
   duplex_mode_t duplex_mode;
   //! number of downlink resource blocks
   int num_rb_dl;
-  //! number of samples per frame 
+  //! number of samples per frame
   unsigned int  samples_per_frame;
   //! the sample rate for both transmit and receive.
   double sample_rate;
@@ -174,9 +165,9 @@ typedef struct {
   //! number of TX channels (=TX antennas)
   int tx_num_channels;
   //! \brief RX base addresses for mmapped_dma
-  int32_t* rxbase[4];
+  int32_t *rxbase[4];
   //! \brief TX base addresses for mmapped_dma
-  int32_t* txbase[4];
+  int32_t *txbase[4];
   //! \brief Center frequency in Hz for RX.
   //! index: [0..rx_num_channels[
   double rx_freq[4];
@@ -187,7 +178,7 @@ typedef struct {
   //! \brief Pointer to Calibration table for RX gains
   rx_gain_calib_table_t *rx_gain_calib_table;
 
-  //! mode for rxgain (ExpressMIMO2) 
+  //! mode for rxgain (ExpressMIMO2)
   rx_gain_t rxg_mode[4];
   //! \brief Gain for RX in dB.
   //! index: [0..rx_num_channels]
@@ -201,15 +192,15 @@ typedef struct {
   double rx_bw;
   //! TX bandwidth in Hz
   double tx_bw;
-  //! clock source 
+  //! clock source
   clock_source_t clock_source;
   //! Manual SDR IP address
-//#if defined(EXMIMO) || defined(OAI_USRP) || defined(OAI_BLADERF) || defined(OAI_LMSSDR) 
+  //#if defined(EXMIMO) || defined(OAI_USRP) || defined(OAI_BLADERF) || defined(OAI_LMSSDR)
   char *sdr_addrs;
   //! Auto calibration flag
   int autocal[4];
   //! rf devices work with x bits iqs when oai have its own iq format
-  //! the two following parameters are used to convert iqs 
+  //! the two following parameters are used to convert iqs
   int iq_txshift;
   int iq_rxrescale;
   //! Configuration file for LMS7002M
@@ -230,7 +221,7 @@ typedef struct {
   unsigned int   sf_read_delay;     // read delay in replay mode
   unsigned int   sf_write_delay;    // write delay in replay mode
   unsigned int   eth_mtu;           // ethernet MTU
-#endif  
+#endif
 
   //! number of samples per tti
   unsigned int  samples_per_tti;
@@ -238,10 +229,12 @@ typedef struct {
   double rx_sample_rate;
   //! the sample rate for transmit.
   double tx_sample_rate;
+  //! check for threequarter sampling rate
+  int8_t threequarter_fs;
 
 } openair0_config_t;
 
-/*! \brief RF mapping */ 
+/*! \brief RF mapping */
 typedef struct {
   //! card id
   int card;
@@ -288,14 +281,14 @@ struct openair0_device_t {
 
   /*!brief Component Carrier ID of this device */
   int CC_id;
-  
+
   /*!brief Type of this device */
   dev_type_t type;
 
   /*!brief Transport protocol type that the device suppports (in case I/Q samples need to be transported) */
   transport_type_t transp_type;
 
-   /*!brief Type of the device's host (RAU/RRU) */
+  /*!brief Type of the device's host (RAU/RRU) */
   host_type_t host_type;
 
   /* !brief RF frontend parameters set by application */
@@ -317,25 +310,25 @@ struct openair0_device_t {
   /*! \brief Called to send a request message between RAU-RRU on control port
       @param device pointer to the device structure specific to the RF hardware target
       @param msg pointer to the message structure passed between RAU-RRU
-      @param msg_len length of the message  
-  */  
+      @param msg_len length of the message
+  */
   int (*trx_ctlsend_func)(openair0_device *device, void *msg, ssize_t msg_len);
 
   /*! \brief Called to receive a reply  message between RAU-RRU on control port
       @param device pointer to the device structure specific to the RF hardware target
       @param msg pointer to the message structure passed between RAU-RRU
-      @param msg_len length of the message  
-  */  
+      @param msg_len length of the message
+  */
   int (*trx_ctlrecv_func)(openair0_device *device, void *msg, ssize_t msg_len);
 
   /*! \brief Called to send samples to the RF target
       @param device pointer to the device structure specific to the RF hardware target
-      @param timestamp The timestamp at whicch the first sample MUST be sent 
+      @param timestamp The timestamp at whicch the first sample MUST be sent
       @param buff Buffer which holds the samples
       @param nsamps number of samples to be sent
       @param antenna_id index of the antenna if the device has multiple anteannas
       @param flags flags must be set to TRUE if timestamp parameter needs to be applied
-  */   
+  */
   int (*trx_write_func)(openair0_device *device, openair0_timestamp timestamp, void **buff, int nsamps,int antenna_id, int flags);
 
   /*! \brief Receive samples from hardware.
@@ -351,55 +344,80 @@ struct openair0_device_t {
    */
   int (*trx_read_func)(openair0_device *device, openair0_timestamp *ptimestamp, void **buff, int nsamps,int antenna_id);
 
-  /*! \brief print the device statistics  
+  /*! \brief print the device statistics
    * \param device the hardware to use
    * \returns  0 on success
    */
   int (*trx_get_stats_func)(openair0_device *device);
 
-  /*! \brief Reset device statistics  
+  /*! \brief Reset device statistics
    * \param device the hardware to use
-   * \returns 0 in success 
+   * \returns 0 in success
    */
   int (*trx_reset_stats_func)(openair0_device *device);
 
-  /*! \brief Terminate operation of the transceiver -- free all associated resources 
+  /*! \brief Terminate operation of the transceiver -- free all associated resources
    * \param device the hardware to use
    */
   void (*trx_end_func)(openair0_device *device);
 
-  /*! \brief Stop operation of the transceiver 
+  /*! \brief Stop operation of the transceiver
    */
   int (*trx_stop_func)(openair0_device *device);
 
   /* Functions API related to UE*/
 
-  /*! \brief Set RX feaquencies 
+  /*! \brief Set RX feaquencies
    * \param device the hardware to use
    * \param openair0_cfg RF frontend parameters set by application
-   * \param exmimo_dump_config  dump EXMIMO configuration 
-   * \returns 0 in success 
+   * \param exmimo_dump_config  dump EXMIMO configuration
+   * \returns 0 in success
    */
-  int (*trx_set_freq_func)(openair0_device* device, openair0_config_t *openair0_cfg,int exmimo_dump_config);
-  
+  int (*trx_set_freq_func)(openair0_device *device, openair0_config_t *openair0_cfg,int exmimo_dump_config);
+
   /*! \brief Set gains
    * \param device the hardware to use
    * \param openair0_cfg RF frontend parameters set by application
-   * \returns 0 in success 
+   * \returns 0 in success
    */
-  int (*trx_set_gains_func)(openair0_device* device, openair0_config_t *openair0_cfg);
+  int (*trx_set_gains_func)(openair0_device *device, openair0_config_t *openair0_cfg);
 
   /*! \brief RRU Configuration callback
    * \param idx RU index
    * \param arg pointer to capabilities or configuration
    */
-  void (*configure_rru)(int idx, void* arg);
+  void (*configure_rru)(int idx, void *arg);
 };
 
 /* type of device init function, implemented in shared lib */
 typedef int(*oai_device_initfunc_t)(openair0_device *device, openair0_config_t *openair0_cfg);
 /* type of transport init function, implemented in shared lib */
-typedef int(*oai_transport_initfunc_t)(openair0_device *device, openair0_config_t *openair0_cfg, eth_params_t * eth_params);
+typedef int(*oai_transport_initfunc_t)(openair0_device *device, openair0_config_t *openair0_cfg, eth_params_t *eth_params);
+#define UE_MAGICDL_FDD 0xA5A5A5A5A5A5A5A5  // UE DL FDD record
+#define UE_MAGICUL_FDD 0x5A5A5A5A5A5A5A5A  // UE UL FDD record
+#define UE_MAGICDL_TDD 0xA6A6A6A6A6A6A6A6  // UE DL TDD record
+#define UE_MAGICUL_TDD 0x6A6A6A6A6A6A6A6A  // UE UL TDD record
+
+#define ENB_MAGICDL_FDD 0xB5B5B5B5B5B5B5B5  // eNB DL FDD record
+#define ENB_MAGICUL_FDD 0x5B5B5B5B5B5B5B5B  // eNB UL FDD record
+#define ENB_MAGICDL_TDD 0xB6B6B6B6B6B6B6B6  // eNB DL TDD record
+#define ENB_MAGICUL_TDD 0x6B6B6B6B6B6B6B6B  // eNB UL TDD record
+
+#define OPTION_LZ4  0x00000001          // LZ4 compression (option_value is set to compressed size)
+
+#define sample_t uint32_t // 2*16 bits complex number
+
+typedef struct {
+  uint64_t magic;          // Magic value (see defines above)
+  uint32_t size;           // Number of samples per antenna to follow this header
+  uint32_t nbAnt;          // Total number of antennas following this header
+  // Samples per antenna follow this header,
+  // i.e. nbAnt = 2 => this header+samples_antenna_0+samples_antenna_1
+  // data following this header in bytes is nbAnt*size*sizeof(sample_t)
+  uint64_t timestamp;      // Timestamp value of first sample
+  uint32_t option_value;   // Option value
+  uint32_t option_flag;    // Option flag
+} samplesBlockHeader_t;
 
 #ifdef __cplusplus
 extern "C"
@@ -407,24 +425,24 @@ extern "C"
 #endif
 
 
-  /*! \brief Initialize openair RF target. It returns 0 if OK */
-  int openair0_device_load(openair0_device *device, openair0_config_t *openair0_cfg);  
-  /*! \brief Initialize transport protocol . It returns 0 if OK */
-  int openair0_transport_load(openair0_device *device, openair0_config_t *openair0_cfg, eth_params_t * eth_params);
+/*! \brief Initialize openair RF target. It returns 0 if OK */
+int openair0_device_load(openair0_device *device, openair0_config_t *openair0_cfg);
+/*! \brief Initialize transport protocol . It returns 0 if OK */
+int openair0_transport_load(openair0_device *device, openair0_config_t *openair0_cfg, eth_params_t *eth_params);
 
-  
- /*! \brief Get current timestamp of USRP
-  * \param device the hardware to use
-  */
-  openair0_timestamp get_usrp_time(openair0_device *device);
 
- /*! \brief Set RX frequencies 
-  * \param device the hardware to use
-  * \param openair0_cfg RF frontend parameters set by application
-  * \returns 0 in success 
-  */
-  int openair0_set_rx_frequencies(openair0_device* device, openair0_config_t *openair0_cfg);
+/*! \brief Get current timestamp of USRP
+ * \param device the hardware to use
+ */
+openair0_timestamp get_usrp_time(openair0_device *device);
 
+/*! \brief Set RX frequencies
+ * \param device the hardware to use
+ * \param openair0_cfg RF frontend parameters set by application
+ * \returns 0 in success
+ */
+int openair0_set_rx_frequencies(openair0_device *device, openair0_config_t *openair0_cfg);
+#define gettid() syscall(__NR_gettid)
 /*@}*/
 
 #ifdef __cplusplus
diff --git a/targets/ARCH/USRP/USERSPACE/LIB/usrp_lib.cpp b/targets/ARCH/USRP/USERSPACE/LIB/usrp_lib.cpp
index ffdec958a9..890561f385 100644
--- a/targets/ARCH/USRP/USERSPACE/LIB/usrp_lib.cpp
+++ b/targets/ARCH/USRP/USERSPACE/LIB/usrp_lib.cpp
@@ -299,6 +299,7 @@ static int trx_usrp_start(openair0_device *device) {
 
   if (u_sf_mode != 2) { // not replay mode
 #endif
+    uhd::set_thread_priority_safe(1.0);
     usrp_state_t *s = (usrp_state_t *)device->priv;
     // setup GPIO for TDD, GPIO(4) = ATR_RX
     //set data direction register (DDR) to output
@@ -597,10 +598,10 @@ static int trx_usrp_read(openair0_device *device, openair0_timestamp *ptimestamp
 
         for (int i=0; i<cc; i++) buff_ptrs.push_back(buff[i]);
 
-        samples_received = s->rx_stream->recv(buff_ptrs, nsamps, s->rx_md);
+        samples_received = s->rx_stream->recv(buff_ptrs, nsamps, s->rx_md,1.0);
       } else {
         // receive a single channel (e.g. from connector RF A)
-        samples_received = s->rx_stream->recv(buff[0], nsamps, s->rx_md);
+        samples_received = s->rx_stream->recv(buff[0], nsamps, s->rx_md,1.0);
       }
     }
 
@@ -1038,7 +1039,6 @@ extern "C" {
                 << use_mmap << std::endl;
     } else {
 #endif
-      uhd::set_thread_priority_safe(1.0);
       usrp_state_t *s = (usrp_state_t *)calloc(sizeof(usrp_state_t),1);
 
       if (openair0_cfg[0].clock_source==gpsdo)
@@ -1102,6 +1102,9 @@ extern "C" {
         device->type=USRP_X300_DEV;
         usrp_master_clock = 184.32e6;
         args += boost::str(boost::format(",master_clock_rate=%f") % usrp_master_clock);
+	// USRP recommended: https://files.ettus.com/manual/page_usrp_x3x0_config.html
+	if ( 0 != system("sysctl -w net.core.rmem_max=33554432 net.core.wmem_max=33554432") )
+		LOG_W(HW,"Can't set kernel paramters for X3xx\n");
       }
 
       s->usrp = uhd::usrp::multi_usrp::make(args);
@@ -1128,7 +1131,15 @@ extern "C" {
             openair0_cfg[0].rx_bw                 = 80e6;
             break;
 
-          case 61440000:
+          case 92160000:
+            // from usrp_time_offset
+            //openair0_cfg[0].samples_per_packet    = 2048;
+            openair0_cfg[0].tx_sample_advance     = 15; //to be checked
+            openair0_cfg[0].tx_bw                 = 80e6;
+            openair0_cfg[0].rx_bw                 = 80e6;
+            break;
+            
+	  case 61440000:
             // from usrp_time_offset
             //openair0_cfg[0].samples_per_packet    = 2048;
             openair0_cfg[0].tx_sample_advance     = 15;
diff --git a/targets/ARCH/rfsimulator/simulator.c b/targets/ARCH/rfsimulator/simulator.c
index a17327b03e..099e1c190a 100644
--- a/targets/ARCH/rfsimulator/simulator.c
+++ b/targets/ARCH/rfsimulator/simulator.c
@@ -27,22 +27,15 @@
 #define sample_t uint32_t // 2*16 bits complex number
 #define sampleToByte(a,b) ((a)*(b)*sizeof(sample_t))
 #define byteToSample(a,b) ((a)/(sizeof(sample_t)*(b)))
-#define MAGICeNB 0xA5A5A5A5A5A5A5A5
-#define MAGICUE  0x5A5A5A5A5A5A5A5A
 
-typedef struct {
-  uint64_t magic;
-  uint32_t size;
-  uint32_t nbAnt;
-  uint64_t timestamp;
-} transferHeader;
+#define sample_t uint32_t // 2*16 bits complex number
 
 typedef struct buffer_s {
   int conn_sock;
   bool alreadyRead;
   uint64_t lastReceivedTS;
   bool headerMode;
-  transferHeader th;
+  samplesBlockHeader_t th;
   char *transferPtr;
   uint64_t remainToTransfer;
   char *circularBufEnd;
@@ -53,8 +46,8 @@ typedef struct {
   int listen_sock, epollfd;
   uint64_t nextTimestamp;
   uint64_t typeStamp;
-  uint64_t initialAhead;
   char *ip;
+  int saveIQfile;
   buffer_t buf[FD_SETSIZE];
 } rfsimulator_state_t;
 
@@ -63,9 +56,11 @@ void allocCirBuf(rfsimulator_state_t *bridge, int sock) {
   AssertFatal ( (ptr->circularBuf=(sample_t *) malloc(sampleToByte(CirSize,1))) != NULL, "");
   ptr->circularBufEnd=((char *)ptr->circularBuf)+sampleToByte(CirSize,1);
   ptr->conn_sock=sock;
+  ptr->alreadyRead=false;
+  ptr->lastReceivedTS=0;
   ptr->headerMode=true;
   ptr->transferPtr=(char *)&ptr->th;
-  ptr->remainToTransfer=sizeof(transferHeader);
+  ptr->remainToTransfer=sizeof(samplesBlockHeader_t);
   int sendbuff=1000*1000*10;
   AssertFatal ( setsockopt(sock, SOL_SOCKET, SO_SNDBUF, &sendbuff, sizeof(sendbuff)) == 0, "");
   struct epoll_event ev= {0};
@@ -87,12 +82,11 @@ void socketError(rfsimulator_state_t *bridge, int sock) {
     LOG_W(HW,"Lost socket \n");
     removeCirBuf(bridge, sock);
 
-    if (bridge->typeStamp==MAGICUE)
+    if (bridge->typeStamp==UE_MAGICDL_FDD)
       exit(1);
   }
 }
 
-
 #define helpTxt "\
 \x1b[31m\
 rfsimulator: error: you have to run one UE and one eNB\n\
@@ -119,9 +113,17 @@ void setblocking(int sock, enum blocking_t active) {
 
 static bool flushInput(rfsimulator_state_t *t);
 
-void fullwrite(int fd, void *_buf, int count, rfsimulator_state_t *t) {
+void fullwrite(int fd, void *_buf, ssize_t count, rfsimulator_state_t *t) {
+  if (t->saveIQfile != -1) {
+    if (write(t->saveIQfile, _buf, count) != count )
+      LOG_E(HW,"write in save iq file failed (%s)\n",strerror(errno));
+  }
+
+  AssertFatal(fd>=0 && _buf && count >0 && t,
+	      "Bug: %d/%p/%zd/%p", fd, _buf, count, t);
+
   char *buf = _buf;
-  int l;
+  ssize_t l;
   setblocking(fd, notBlocking);
 
   while (count) {
@@ -145,7 +147,7 @@ void fullwrite(int fd, void *_buf, int count, rfsimulator_state_t *t) {
 
 int server_start(openair0_device *device) {
   rfsimulator_state_t *t = (rfsimulator_state_t *) device->priv;
-  t->typeStamp=MAGICeNB;
+  t->typeStamp=ENB_MAGICDL_FDD;
   AssertFatal((t->listen_sock = socket(AF_INET, SOCK_STREAM, 0)) >= 0, "");
   int enable = 1;
   AssertFatal(setsockopt(t->listen_sock, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(int)) == 0, "");
@@ -168,7 +170,7 @@ sin_addr:
 
 int start_ue(openair0_device *device) {
   rfsimulator_state_t *t = device->priv;
-  t->typeStamp=MAGICUE;
+  t->typeStamp=UE_MAGICDL_FDD;
   int sock;
   AssertFatal((sock = socket(AF_INET, SOCK_STREAM, 0)) >= 0, "");
   struct sockaddr_in addr = {
@@ -200,14 +202,16 @@ sin_addr:
   return 0;
 }
 
+uint64_t lastW=-1;
 int rfsimulator_write(openair0_device *device, openair0_timestamp timestamp, void **samplesVoid, int nsamps, int nbAnt, int flags) {
   rfsimulator_state_t *t = device->priv;
+  LOG_D(HW,"sending %d samples at time: %ld\n", nsamps, timestamp);
 
   for (int i=0; i<FD_SETSIZE; i++) {
     buffer_t *ptr=&t->buf[i];
 
     if (ptr->conn_sock >= 0 ) {
-      transferHeader header= {t->typeStamp, nsamps, nbAnt, timestamp};
+      samplesBlockHeader_t header= {t->typeStamp, nsamps, nbAnt, timestamp};
       fullwrite(ptr->conn_sock,&header, sizeof(header), t);
       sample_t tmpSamples[nsamps][nbAnt];
 
@@ -222,7 +226,7 @@ int rfsimulator_write(openair0_device *device, openair0_timestamp timestamp, voi
         fullwrite(ptr->conn_sock, (void *)tmpSamples, sampleToByte(nsamps,nbAnt), t);
     }
   }
-
+  lastW=timestamp;
   LOG_D(HW,"sent %d samples at time: %ld->%ld, energy in first antenna: %d\n",
         nsamps, timestamp, timestamp+nsamps, signal_energy(samplesVoid[0], nsamps) );
   return nsamps;
@@ -232,7 +236,7 @@ static bool flushInput(rfsimulator_state_t *t) {
   // Process all incoming events on sockets
   // store the data in lists
   struct epoll_event events[FD_SETSIZE]= {0};
-  int nfds = epoll_wait(t->epollfd, events, FD_SETSIZE, 200);
+  int nfds = epoll_wait(t->epollfd, events, FD_SETSIZE, 20);
 
   if ( nfds==-1 ) {
     if ( errno==EINTR || errno==EAGAIN )
@@ -263,7 +267,7 @@ static bool flushInput(rfsimulator_state_t *t) {
         continue;
       }
 
-      int blockSz;
+      ssize_t blockSz;
 
       if ( b->headerMode)
         blockSz=b->remainToTransfer;
@@ -272,7 +276,7 @@ static bool flushInput(rfsimulator_state_t *t) {
                  b->remainToTransfer :
                  b->circularBufEnd - 1 - b->transferPtr ;
 
-      int sz=recv(fd, b->transferPtr, blockSz, MSG_DONTWAIT);
+      ssize_t sz=recv(fd, b->transferPtr, blockSz, MSG_DONTWAIT);
 
       if ( sz < 0 ) {
         if ( errno != EAGAIN ) {
@@ -282,6 +286,7 @@ static bool flushInput(rfsimulator_state_t *t) {
       } else if ( sz == 0 )
         continue;
 
+      LOG_D(HW, "Socket rcv %zd bytes\n", sz);
       AssertFatal((b->remainToTransfer-=sz) >= 0, "");
       b->transferPtr+=sz;
 
@@ -290,8 +295,8 @@ static bool flushInput(rfsimulator_state_t *t) {
 
       // check the header and start block transfer
       if ( b->headerMode==true && b->remainToTransfer==0) {
-        AssertFatal( (t->typeStamp == MAGICUE  && b->th.magic==MAGICeNB) ||
-                     (t->typeStamp == MAGICeNB && b->th.magic==MAGICUE), "Socket Error in protocol");
+        AssertFatal( (t->typeStamp == UE_MAGICDL_FDD  && b->th.magic==ENB_MAGICDL_FDD) ||
+                     (t->typeStamp == ENB_MAGICDL_FDD && b->th.magic==UE_MAGICDL_FDD), "Socket Error in protocol");
         b->headerMode=false;
         b->alreadyRead=true;
 
@@ -306,23 +311,24 @@ static bool flushInput(rfsimulator_state_t *t) {
         }
 
         b->lastReceivedTS=b->th.timestamp;
+	AssertFatal(lastW == -1 || ( abs((double)lastW-b->lastReceivedTS) < (double)CirSize),
+	  "Tx/Rx shift too large Tx:%lu, Rx:%lu\n", lastW, b->lastReceivedTS);
         b->transferPtr=(char *)&b->circularBuf[b->lastReceivedTS%CirSize];
         b->remainToTransfer=sampleToByte(b->th.size, b->th.nbAnt);
       }
 
       if ( b->headerMode==false ) {
+	LOG_D(HW,"Set b->lastReceivedTS %ld\n", b->lastReceivedTS);
         b->lastReceivedTS=b->th.timestamp+b->th.size-byteToSample(b->remainToTransfer,b->th.nbAnt);
-
+	// First block in UE, resync with the eNB current TS
+	if ( t->nextTimestamp == 0 )
+	  t->nextTimestamp=b->lastReceivedTS-b->th.size;
+	
         if ( b->remainToTransfer==0) {
           LOG_D(HW,"Completed block reception: %ld\n", b->lastReceivedTS);
-
-          // First block in UE, resync with the eNB current TS
-          if ( t->nextTimestamp == 0 )
-            t->nextTimestamp=b->lastReceivedTS-b->th.size;
-
           b->headerMode=true;
           b->transferPtr=(char *)&b->th;
-          b->remainToTransfer=sizeof(transferHeader);
+          b->remainToTransfer=sizeof(samplesBlockHeader_t);
           b->th.magic=-1;
         }
       }
@@ -365,13 +371,14 @@ int rfsimulator_read(openair0_device *device, openair0_timestamp *ptimestamp, vo
     do {
       have_to_wait=false;
 
-      for ( int sock=0; sock<FD_SETSIZE; sock++)
-        if ( t->buf[sock].circularBuf &&
-             t->buf[sock].alreadyRead && //>= t->initialAhead &&
-             (t->nextTimestamp+nsamps) > t->buf[sock].lastReceivedTS ) {
-          have_to_wait=true;
-          break;
-        }
+      for ( int sock=0; sock<FD_SETSIZE; sock++) {
+        if ( t->buf[sock].circularBuf && t->buf[sock].alreadyRead )
+	  if ( t->buf[sock].lastReceivedTS == 0 ||
+	       (t->nextTimestamp+nsamps) > t->buf[sock].lastReceivedTS ) {
+	    have_to_wait=true;
+	    break;
+	  }
+      }
 
       if (have_to_wait)
         /*printf("Waiting on socket, current last ts: %ld, expected at least : %ld\n",
@@ -439,6 +446,7 @@ int rfsimulator_set_gains(openair0_device *device, openair0_config_t *openair0_c
 __attribute__((__visibility__("default")))
 int device_init(openair0_device *device, openair0_config_t *openair0_cfg) {
   //set_log(HW,OAILOG_DEBUG);
+  //set_log(PHY,OAILOG_DEBUG);
   rfsimulator_state_t *rfsimulator = (rfsimulator_state_t *)calloc(sizeof(rfsimulator_state_t),1);
 
   if ((rfsimulator->ip=getenv("RFSIMULATOR")) == NULL ) {
@@ -446,11 +454,26 @@ int device_init(openair0_device *device, openair0_config_t *openair0_cfg) {
     exit(1);
   }
 
-  rfsimulator->typeStamp = strncasecmp(rfsimulator->ip,"enb",3) == 0 ?
-                           MAGICeNB:
-                           MAGICUE;
-  LOG_I(HW,"rfsimulator: running as %s\n", rfsimulator-> typeStamp == MAGICeNB ? "eNB" : "UE");
-  device->trx_start_func       = rfsimulator->typeStamp == MAGICeNB ?
+  if ( strncasecmp(rfsimulator->ip,"enb",3) == 0 ||
+       strncasecmp(rfsimulator->ip,"server",3) == 0 )
+    rfsimulator->typeStamp = ENB_MAGICDL_FDD;
+  else
+    rfsimulator->typeStamp = UE_MAGICDL_FDD;
+  
+  LOG_I(HW,"rfsimulator: running as %s\n", rfsimulator-> typeStamp == ENB_MAGICDL_FDD ? "(eg)NB" : "UE");
+  char *saveF;
+
+  if ((saveF=getenv("saveIQfile")) != NULL) {
+    rfsimulator->saveIQfile=open(saveF,O_APPEND| O_CREAT|O_TRUNC | O_WRONLY, 0666);
+
+    if ( rfsimulator->saveIQfile != -1 )
+      LOG_I(HW,"rfsimulator: will save written IQ samples  in %s\n", saveF);
+    else
+      LOG_E(HW, "can't open %s for IQ saving (%s)\n", saveF, strerror(errno));
+  } else
+    rfsimulator->saveIQfile = -1;
+
+  device->trx_start_func       = rfsimulator->typeStamp == ENB_MAGICDL_FDD ?
                                  server_start :
                                  start_ue;
   device->trx_get_stats_func   = rfsimulator_get_stats;
@@ -470,6 +493,5 @@ int device_init(openair0_device *device, openair0_config_t *openair0_cfg) {
     rfsimulator->buf[i].conn_sock=-1;
 
   AssertFatal((rfsimulator->epollfd = epoll_create1(0)) != -1,"");
-  rfsimulator->initialAhead=openair0_cfg[0].sample_rate/1000; // One sub frame
   return 0;
 }
diff --git a/targets/ARCH/rfsimulator/stored_node.c b/targets/ARCH/rfsimulator/stored_node.c
new file mode 100644
index 0000000000..888b5f6de0
--- /dev/null
+++ b/targets/ARCH/rfsimulator/stored_node.c
@@ -0,0 +1,142 @@
+/*
+  Author: Laurent THOMAS, Open Cells
+  copyleft: OpenAirInterface Software Alliance and it's licence
+*/
+
+#include <common/utils/simple_executable.h>
+
+
+void fullwrite(int fd, void *_buf, int count) {
+  char *buf = _buf;
+  int l;
+
+  while (count) {
+    l = write(fd, buf, count);
+
+    if (l <= 0) {
+      if (errno==EINTR)
+        continue;
+
+      if(errno==EAGAIN) {
+        continue;
+      } else {
+        AssertFatal(false,"Lost socket\n");
+      }
+    } else {
+      count -= l;
+      buf += l;
+    }
+  }
+}
+
+int server_start(short port) {
+  int listen_sock;
+  AssertFatal((listen_sock = socket(AF_INET, SOCK_STREAM, 0)) >= 0, "");
+  int enable = 1;
+  AssertFatal(setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(int)) == 0, "");
+  struct sockaddr_in addr = {
+sin_family:
+    AF_INET,
+sin_port:
+    htons(port),
+sin_addr:
+    { s_addr: INADDR_ANY }
+  };
+  bind(listen_sock, (struct sockaddr *)&addr, sizeof(addr));
+  AssertFatal(listen(listen_sock, 5) == 0, "");
+  return accept(listen_sock,NULL,NULL);
+}
+
+int client_start(char *IP, short port) {
+  int sock;
+  AssertFatal((sock = socket(AF_INET, SOCK_STREAM, 0)) >= 0, "");
+  struct sockaddr_in addr = {
+sin_family:
+    AF_INET,
+sin_port:
+    htons(port),
+sin_addr:
+    { s_addr: INADDR_ANY }
+  };
+  addr.sin_addr.s_addr = inet_addr(IP);
+  bool connected=false;
+
+  while(!connected) {
+    LOG_I(HW,"rfsimulator: trying to connect to %s:%d\n", IP, port);
+
+    if (connect(sock, (struct sockaddr *)&addr, sizeof(addr)) == 0) {
+      LOG_I(HW,"rfsimulator: connection established\n");
+      connected=true;
+    }
+
+    perror("simulated node");
+    sleep(1);
+  }
+
+  return sock;
+}
+
+enum  blocking_t {
+  notBlocking,
+  blocking
+};
+
+void setblocking(int sock, enum blocking_t active) {
+  int opts;
+  AssertFatal( (opts = fcntl(sock, F_GETFL)) >= 0,"");
+
+  if (active==blocking)
+    opts = opts & ~O_NONBLOCK;
+  else
+    opts = opts | O_NONBLOCK;
+
+  AssertFatal(fcntl(sock, F_SETFL, opts) >= 0, "");
+}
+
+int main(int argc, char *argv[]) {
+  if(argc != 4) {
+    printf("Need parameters: source file, server or destination IP, TCP port\n");
+    exit(1);
+  }
+
+  int fd;
+  AssertFatal((fd=open(argv[1],O_RDONLY)) != -1, "file: %s", argv[1]);
+  off_t fileSize=lseek(fd, 0, SEEK_END);
+  int serviceSock;
+
+  if (strcmp(argv[2],"server")==0) {
+    serviceSock=server_start(atoi(argv[3]));
+  } else {
+    client_start(argv[2],atoi(argv[3]));
+  }
+
+  samplesBlockHeader_t header;
+  int bufSize=100000;
+  void *buff=malloc(bufSize);
+
+  while (1) {
+    //Rewind the file to loop on the samples
+    if ( lseek(fd, 0, SEEK_CUR) >= fileSize )
+      lseek(fd, 0, SEEK_SET);
+
+    // Read one block and send it
+    setblocking(serviceSock, blocking);
+    AssertFatal(read(fd,&header,sizeof(header)), "");
+    fullwrite(serviceSock, &header, sizeof(header));
+    int dataSize=sizeof(sample_t)*header.size*header.nbAnt;
+
+    if (dataSize>bufSize)
+      buff=realloc(buff,dataSize);
+
+    AssertFatal(read(fd,buff,dataSize) == dataSize, "");
+    fullwrite(serviceSock, buff, dataSize);
+    // Purge incoming samples
+    setblocking(serviceSock, notBlocking);
+
+    while(recv(serviceSock,buff, bufSize, MSG_DONTWAIT) > 0) {
+    }
+  }
+
+  return 0;
+}
+
diff --git a/targets/COMMON/openairinterface5g_limits.h b/targets/COMMON/openairinterface5g_limits.h
index d44f0c5601..9b4ee23dc8 100644
--- a/targets/COMMON/openairinterface5g_limits.h
+++ b/targets/COMMON/openairinterface5g_limits.h
@@ -1,22 +1,29 @@
 #ifndef OPENAIRINTERFACE5G_LIMITS_H_
 #define OPENAIRINTERFACE5G_LIMITS_H_
 
-#if defined(CBMIMO1) || defined(EXMIMO) || defined(OAI_USRP) || defined(OAI_LMSSDR) || defined(OAI_ADRV9371_ZC706)
+#if 1 /*defined(CBMIMO1) || defined(EXMIMO) || defined(OAI_USRP) || defined(OAI_LMSSDR) || defined(OAI_ADRV9371_ZC706)*/
 #        define NUMBER_OF_eNB_MAX 1
 #        define NUMBER_OF_gNB_MAX 1
 #        define NUMBER_OF_RU_MAX 2
 #        define NUMBER_OF_NR_RU_MAX 2
+#        ifndef PHYSIM
 #        ifndef UE_EXPANSION
-#                define NUMBER_OF_UE_MAX 16
-#                define NUMBER_OF_NR_UE_MAX 16
-#                define NUMBER_OF_CONNECTED_eNB_MAX 3
-#                define NUMBER_OF_CONNECTED_gNB_MAX 3
+#                define NUMBER_OF_UE_MAX 4
+#                define NUMBER_OF_NR_UE_MAX 4
+#                define NUMBER_OF_CONNECTED_eNB_MAX 1
+#                define NUMBER_OF_CONNECTED_gNB_MAX 1
 #        else
 #                define NUMBER_OF_UE_MAX 256
 #                define NUMBER_OF_NR_UE_MAX 256
 #                define NUMBER_OF_CONNECTED_eNB_MAX 1
 #                define NUMBER_OF_CONNECTED_gNB_MAX 1
 #        endif
+#        else
+#                define NUMBER_OF_UE_MAX 1
+#                define NUMBER_OF_NR_UE_MAX 1
+#                define NUMBER_OF_CONNECTED_eNB_MAX 1
+#                define NUMBER_OF_CONNECTED_gNB_MAX 1
+#        endif
 #else
 #        define NUMBER_OF_eNB_MAX 7
 #        define NUMBER_OF_gNB_MAX 7
diff --git a/targets/PROJECTS/GENERIC-LTE-EPC/CONF/gnb.band22.tm1.106PRB.adrv9371zc706.conf b/targets/PROJECTS/GENERIC-LTE-EPC/CONF/gnb.band22.tm1.106PRB.adrv9371zc706.conf
index 258d6c5f03..5fd4b465b3 100644
--- a/targets/PROJECTS/GENERIC-LTE-EPC/CONF/gnb.band22.tm1.106PRB.adrv9371zc706.conf
+++ b/targets/PROJECTS/GENERIC-LTE-EPC/CONF/gnb.band22.tm1.106PRB.adrv9371zc706.conf
@@ -26,10 +26,10 @@ gNBs =
       node_function                                                 = "3GPP_gNODEB";
       node_timing                                                   = "synch_to_ext_device";
       node_synch_ref                                                = 0;
-      frame_type                                                    = "FDD";
+      frame_type                                                    = "TDD";
       DL_prefix_type                                                = "NORMAL";
       UL_prefix_type                                                = "NORMAL";
-      eutra_band                                                    = 22;
+      eutra_band                                                    = 78;
       downlink_frequency                                            = 3510000000L;
       uplink_frequency_offset                                       = -120000000;
       Nid_cell                                                      = 0;
@@ -70,7 +70,7 @@ gNBs =
       UL_BWP_prefix_type                                            = "NORMAL";
       UL_timeAlignmentTimerCommon                                   = "infinity";
       ServingCellConfigCommon_n_TimingAdvanceOffset                 = "n0"
-      ServingCellConfigCommon_ssb_PositionsInBurst_PR               = "shortBitmap";
+      ServingCellConfigCommon_ssb_PositionsInBurst_PR               = 0x01;
       ServingCellConfigCommon_ssb_periodicityServingCell            = 10;
       ServingCellConfigCommon_dmrs_TypeA_Position                   = 2;
       NIA_SubcarrierSpacing                                         = "kHz15"; 
diff --git a/targets/PROJECTS/GENERIC-LTE-EPC/CONF/gnb.band78.tm1.106PRB.usrpn300.conf b/targets/PROJECTS/GENERIC-LTE-EPC/CONF/gnb.band78.tm1.106PRB.usrpn300.conf
index 3aaf0c5506..f22abf3112 100644
--- a/targets/PROJECTS/GENERIC-LTE-EPC/CONF/gnb.band78.tm1.106PRB.usrpn300.conf
+++ b/targets/PROJECTS/GENERIC-LTE-EPC/CONF/gnb.band78.tm1.106PRB.usrpn300.conf
@@ -26,10 +26,10 @@ gNBs =
       node_function                                                 = "3GPP_gNODEB";
       node_timing                                                   = "synch_to_ext_device";
       node_synch_ref                                                = 0;
-      frame_type                                                    = "FDD";
+      frame_type                                                    = "TDD";
       DL_prefix_type                                                = "NORMAL";
       UL_prefix_type                                                = "NORMAL";
-      eutra_band                                                    = 22;
+      eutra_band                                                    = 78;
       downlink_frequency                                            = 3510000000L;
       uplink_frequency_offset                                       = -120000000;
       Nid_cell                                                      = 0;
@@ -70,7 +70,7 @@ gNBs =
       UL_BWP_prefix_type                                            = "NORMAL";
       UL_timeAlignmentTimerCommon                                   = "infinity";
       ServingCellConfigCommon_n_TimingAdvanceOffset                 = "n0"
-      ServingCellConfigCommon_ssb_PositionsInBurst_PR               = "shortBitmap";
+      ServingCellConfigCommon_ssb_PositionsInBurst_PR               = 0x01;
       ServingCellConfigCommon_ssb_periodicityServingCell            = 10;
       ServingCellConfigCommon_dmrs_TypeA_Position                   = 2;
       NIA_SubcarrierSpacing                                         = "kHz15"; 
@@ -254,7 +254,7 @@ RUs = (
          max_pdschReferenceSignalPower = -27;
          max_rxgain                    = 114;
          eNB_instances  = [0];
-	 sdr_addrs = "addr=192.168.10.2,second_addr=192.168.20.2,mgmt_addr=192.168.100.8";
+	 sdr_addrs = "addr=192.168.10.2,second_addr=192.168.20.2,mgmt_addr=192.168.100.8,clock_source=external,time_source=external";
 
     }
 );  
diff --git a/targets/PROJECTS/GENERIC-LTE-EPC/CONF/gnb.band78.tm1.106PRB.usrpx300.conf b/targets/PROJECTS/GENERIC-LTE-EPC/CONF/gnb.band78.tm1.106PRB.usrpx300.conf
index d62b06aaa5..be98106d1e 100644
--- a/targets/PROJECTS/GENERIC-LTE-EPC/CONF/gnb.band78.tm1.106PRB.usrpx300.conf
+++ b/targets/PROJECTS/GENERIC-LTE-EPC/CONF/gnb.band78.tm1.106PRB.usrpx300.conf
@@ -26,10 +26,10 @@ gNBs =
       node_function                                                 = "3GPP_gNODEB";
       node_timing                                                   = "synch_to_ext_device";
       node_synch_ref                                                = 0;
-      frame_type                                                    = "FDD";
+      frame_type                                                    = "TDD";
       DL_prefix_type                                                = "NORMAL";
       UL_prefix_type                                                = "NORMAL";
-      eutra_band                                                    = 22;
+      eutra_band                                                    = 78;
       downlink_frequency                                            = 3510000000L;
       uplink_frequency_offset                                       = -120000000;
       Nid_cell                                                      = 0;
@@ -70,7 +70,7 @@ gNBs =
       UL_BWP_prefix_type                                            = "NORMAL";
       UL_timeAlignmentTimerCommon                                   = "infinity";
       ServingCellConfigCommon_n_TimingAdvanceOffset                 = "n0"
-      ServingCellConfigCommon_ssb_PositionsInBurst_PR               = "shortBitmap";
+      ServingCellConfigCommon_ssb_PositionsInBurst_PR               = 0x01;
       ServingCellConfigCommon_ssb_periodicityServingCell            = 10;
       ServingCellConfigCommon_dmrs_TypeA_Position                   = 2;
       NIA_SubcarrierSpacing                                         = "kHz15"; 
diff --git a/targets/PROJECTS/GENERIC-LTE-EPC/CONF/gnb.band78.tm1.217PRB.usrpn300.conf b/targets/PROJECTS/GENERIC-LTE-EPC/CONF/gnb.band78.tm1.217PRB.usrpn300.conf
index a604feabec..dbd937d61a 100644
--- a/targets/PROJECTS/GENERIC-LTE-EPC/CONF/gnb.band78.tm1.217PRB.usrpn300.conf
+++ b/targets/PROJECTS/GENERIC-LTE-EPC/CONF/gnb.band78.tm1.217PRB.usrpn300.conf
@@ -26,10 +26,10 @@ gNBs =
       node_function                                                 = "3GPP_gNODEB";
       node_timing                                                   = "synch_to_ext_device";
       node_synch_ref                                                = 0;
-      frame_type                                                    = "FDD";
+      frame_type                                                    = "TDD";
       DL_prefix_type                                                = "NORMAL";
       UL_prefix_type                                                = "NORMAL";
-      eutra_band                                                    = 22;
+      eutra_band                                                    = 78;
       downlink_frequency                                            = 3510000000L;
       uplink_frequency_offset                                       = -120000000;
       Nid_cell                                                      = 0;
@@ -70,7 +70,7 @@ gNBs =
       UL_BWP_prefix_type                                            = "NORMAL";
       UL_timeAlignmentTimerCommon                                   = "infinity";
       ServingCellConfigCommon_n_TimingAdvanceOffset                 = "n0"
-      ServingCellConfigCommon_ssb_PositionsInBurst_PR               = "shortBitmap";
+      ServingCellConfigCommon_ssb_PositionsInBurst_PR               = 0x01;
       ServingCellConfigCommon_ssb_periodicityServingCell            = 10;
       ServingCellConfigCommon_dmrs_TypeA_Position                   = 2;
       NIA_SubcarrierSpacing                                         = "kHz15"; 
diff --git a/targets/PROJECTS/GENERIC-LTE-EPC/CONF/gnb.band78.tm1.217PRB.usrpx300.conf b/targets/PROJECTS/GENERIC-LTE-EPC/CONF/gnb.band78.tm1.217PRB.usrpx300.conf
new file mode 100644
index 0000000000..51910091f7
--- /dev/null
+++ b/targets/PROJECTS/GENERIC-LTE-EPC/CONF/gnb.band78.tm1.217PRB.usrpx300.conf
@@ -0,0 +1,298 @@
+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 = 208; mnc = 93; mnc_length = 2;});	 
+
+    tr_s_preference     = "local_mac"
+
+    ////////// Physical parameters:
+
+    component_carriers = (
+      {
+      node_function                                                 = "3GPP_gNODEB";
+      node_timing                                                   = "synch_to_ext_device";
+      node_synch_ref                                                = 0;
+      frame_type                                                    = "TDD";
+      DL_prefix_type                                                = "NORMAL";
+      UL_prefix_type                                                = "NORMAL";
+      eutra_band                                                    = 78;
+      downlink_frequency                                            = 3510000000L;
+      uplink_frequency_offset                                       = -120000000;
+      Nid_cell                                                      = 0;
+      N_RB_DL                                                       = 217;
+      nb_antenna_ports                                              = 1;
+      nb_antennas_tx                                                = 1;
+      nb_antennas_rx                                                = 1;
+      tx_gain                                                       = 90;
+      rx_gain                                                       = 125;
+      MIB_subCarrierSpacingCommon                                   = 30;
+      MIB_ssb_SubcarrierOffset                                      = 0;
+      MIB_dmrs_TypeA_Position                                       = 2;
+      pdcch_ConfigSIB1                                              = 0;
+      SIB1_frequencyOffsetSSB                                       = "khz5";
+      SIB1_ssb_PeriodicityServingCell                               = 5;
+      SIB1_ss_PBCH_BlockPower                                       = -60;
+      absoluteFrequencySSB                                          = 0;
+      DL_FreqBandIndicatorNR                                        = 15;
+      DL_absoluteFrequencyPointA                                    = 15;
+      DL_offsetToCarrier                                            = 15;
+      DL_SCS_SubcarrierSpacing                                      = "kHz30";
+      DL_SCS_SpecificCarrier_k0                                     = 0;
+      DL_carrierBandwidth                                           = 15;
+      DL_locationAndBandwidth                                       = 15;
+      DL_BWP_SubcarrierSpacing                                      = "kHz30";
+      DL_BWP_prefix_type                                            = "NORMAL";
+      UL_FreqBandIndicatorNR                                        = 15;
+      UL_absoluteFrequencyPointA                                    = 13;
+      UL_additionalSpectrumEmission                                 = 3;
+      UL_p_Max                                                      = -1;
+      UL_frequencyShift7p5khz                                       = "TRUE";
+      UL_offsetToCarrier                                            = 10;
+      UL_SCS_SubcarrierSpacing                                      = "kHz30";
+      UL_SCS_SpecificCarrier_k0                                     = 0;
+      UL_carrierBandwidth                                           = 15;
+      UL_locationAndBandwidth                                       = 15;
+      UL_BWP_SubcarrierSpacing                                      = "kHz30";
+      UL_BWP_prefix_type                                            = "NORMAL";
+      UL_timeAlignmentTimerCommon                                   = "infinity";
+      ServingCellConfigCommon_n_TimingAdvanceOffset                 = "n0"
+      ServingCellConfigCommon_ssb_PositionsInBurst_PR               = 0x01;
+      ServingCellConfigCommon_ssb_periodicityServingCell            = 10;
+      ServingCellConfigCommon_dmrs_TypeA_Position                   = 2;
+      NIA_SubcarrierSpacing                                         = "kHz15"; 
+      ServingCellConfigCommon_ss_PBCH_BlockPower                    = -60;
+      referenceSubcarrierSpacing                                    = "kHz15";
+      dl_UL_TransmissionPeriodicity                                 = "ms0p5";
+      nrofDownlinkSlots                                             = 10;
+      nrofDownlinkSymbols                                           = 10;
+      nrofUplinkSlots                                               = 10;
+      nrofUplinkSymbols                                             = 10;
+      rach_totalNumberOfRA_Preambles                                = 63;
+      rach_ssb_perRACH_OccasionAndCB_PreamblesPerSSB_choice         = "oneEighth";
+      rach_ssb_perRACH_OccasionAndCB_PreamblesPerSSB_oneEighth      = 4;
+      rach_ssb_perRACH_OccasionAndCB_PreamblesPerSSB_oneFourth      = 8;
+      rach_ssb_perRACH_OccasionAndCB_PreamblesPerSSB_oneHalf        = 16;
+      rach_ssb_perRACH_OccasionAndCB_PreamblesPerSSB_one            = 24;
+      rach_ssb_perRACH_OccasionAndCB_PreamblesPerSSB_two            = 32;
+      rach_ssb_perRACH_OccasionAndCB_PreamblesPerSSB_four           = 8;
+      rach_ssb_perRACH_OccasionAndCB_PreamblesPerSSB_eight          = 4;
+      rach_ssb_perRACH_OccasionAndCB_PreamblesPerSSB_sixteen        = 2;
+      rach_groupBconfigured                                         = "ENABLE";
+      rach_ra_Msg3SizeGroupA                                        = 56;
+      rach_messagePowerOffsetGroupB                                 = "dB0";
+      rach_numberOfRA_PreamblesGroupA                               = 32;
+      rach_ra_ContentionResolutionTimer                             = 8;
+      rsrp_ThresholdSSB                                             = 64;
+      rsrp_ThresholdSSB_SUL                                         = 64;
+      prach_RootSequenceIndex_choice                                = "l839";
+      prach_RootSequenceIndex_l839                                  = 0;
+      prach_RootSequenceIndex_l139                                  = 0;
+      prach_msg1_SubcarrierSpacing                                  = "kHz30";
+      restrictedSetConfig                                           = "unrestrictedSet";
+      msg3_transformPrecoding                                       = "ENABLE";
+      prach_ConfigurationIndex                                      = 10;
+      prach_msg1_FDM                                                = "one";
+      prach_msg1_FrequencyStart                                     = 10;
+      zeroCorrelationZoneConfig                                     = 10;
+      preambleReceivedTargetPower                                   = -150;
+      preambleTransMax                                              = 6;
+      powerRampingStep                                              = "dB0";
+      ra_ResponseWindow                                             = 8;
+      groupHoppingEnabledTransformPrecoding                         = "ENABLE";
+      msg3_DeltaPreamble                                            = 0;
+      p0_NominalWithGrant                                           = 0;
+      PUSCH_TimeDomainResourceAllocation_k2                         = 0;
+      PUSCH_TimeDomainResourceAllocation_mappingType                = "typeA";
+      PUSCH_TimeDomainResourceAllocation_startSymbolAndLength       = 0;
+      pucch_ResourceCommon                                          = 0;
+      pucch_GroupHopping                                            = "neither";
+      hoppingId                                                     = 0;
+      p0_nominal                                                    = -30;
+      PDSCH_TimeDomainResourceAllocation_k0                         = 2;
+      PDSCH_TimeDomainResourceAllocation_mappingType                = "typeA";
+      PDSCH_TimeDomainResourceAllocation_startSymbolAndLength       = 0;
+      rateMatchPatternId                                            = 0;
+      RateMatchPattern_patternType                                  = "bitmaps";
+      symbolsInResourceBlock                                        = "oneSlot";
+      periodicityAndPattern                                         = 2;
+      RateMatchPattern_controlResourceSet                           = 5;
+      RateMatchPattern_subcarrierSpacing                            = "kHz30";
+      RateMatchPattern_mode                                         = "dynamic";
+      controlResourceSetZero                                        = 0;
+      searchSpaceZero                                               = 0;
+      searchSpaceSIB1                                               = 10;
+      searchSpaceOtherSystemInformation                             = 10;
+      pagingSearchSpace                                             = 10;
+      ra_SearchSpace                                                = 10;
+      PDCCH_common_controlResourceSetId                             = 5;
+      PDCCH_common_ControlResourceSet_duration                      = 2;
+      PDCCH_cce_REG_MappingType                                     = "nonInterleaved";
+      PDCCH_reg_BundleSize                                          = 3;
+      PDCCH_interleaverSize                                         = 3;
+      PDCCH_shiftIndex                                              = 10;  
+      PDCCH_precoderGranularity                                     = "sameAsREG-bundle";
+      PDCCH_TCI_StateId                                             = 32;
+      tci_PresentInDCI                                              = "ENABLE";
+      PDCCH_DMRS_ScramblingID                                       = 0;
+      SearchSpaceId                                                 = 10;
+      commonSearchSpaces_controlResourceSetId                       = 5;
+      SearchSpace_monitoringSlotPeriodicityAndOffset_choice         = "sl1";
+      SearchSpace_monitoringSlotPeriodicityAndOffset_value          = 0;
+      SearchSpace_duration                                          = 2;
+      SearchSpace_nrofCandidates_aggregationLevel1                  = 0;
+      SearchSpace_nrofCandidates_aggregationLevel2                  = 0;
+      SearchSpace_nrofCandidates_aggregationLevel4                  = 0;
+      SearchSpace_nrofCandidates_aggregationLevel8                  = 0;
+      SearchSpace_nrofCandidates_aggregationLevel16                 = 0;
+      SearchSpace_searchSpaceType                                   = "common";
+      Common_dci_Format2_0_nrofCandidates_SFI_aggregationLevel1     = 1;
+      Common_dci_Format2_0_nrofCandidates_SFI_aggregationLevel2     = 1;
+      Common_dci_Format2_0_nrofCandidates_SFI_aggregationLevel4     = 1;
+      Common_dci_Format2_0_nrofCandidates_SFI_aggregationLevel8     = 1;
+      Common_dci_Format2_0_nrofCandidates_SFI_aggregationLevel16    = 1; 
+      Common_dci_Format2_3_monitoringPeriodicity                    = 1;
+      Common_dci_Format2_3_nrofPDCCH_Candidates                     = 1;
+      ue_Specific__dci_Formats                                      = "formats0-0-And-1-0";
+      RateMatchPatternLTE_CRS_carrierFreqDL                         = 6;
+      RateMatchPatternLTE_CRS_carrierBandwidthDL                    = 6;
+      RateMatchPatternLTE_CRS_nrofCRS_Ports                         = 1;
+      RateMatchPatternLTE_CRS_v_Shift                               = 0;
+      RateMatchPatternLTE_CRS_radioframeAllocationPeriod            = 1;
+      RateMatchPatternLTE_CRS_radioframeAllocationOffset            = 0;
+      RateMatchPatternLTE_CRS_subframeAllocation_choice             = "oneFrame";
+      }
+    );
+
+
+    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;
+    };
+
+
+    ////////// MME parameters:
+    mme_ip_address      = ( { ipv4       = "192.168.12.26";
+                              ipv6       = "192:168:30::17";
+                              active     = "yes";
+                              preference = "ipv4";
+                            }
+                          );
+
+    NETWORK_INTERFACES :
+    {
+
+        GNB_INTERFACE_NAME_FOR_S1_MME            = "eth0";
+        GNB_IPV4_ADDRESS_FOR_S1_MME              = "192.168.12.111/24";
+        GNB_INTERFACE_NAME_FOR_S1U               = "eth0";
+        GNB_IPV4_ADDRESS_FOR_S1U                 = "192.168.12.111/24";
+        GNB_PORT_FOR_S1U                         = 2152; # Spec 2152
+    };
+  }
+);
+
+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];
+	 sdr_addrs = "addr=192.168.30.2";
+
+    }
+);  
+
+THREAD_STRUCT = (
+  {
+    #three config for level of parallelism "PARALLEL_SINGLE_THREAD", "PARALLEL_RU_L1_SPLIT", or "PARALLEL_RU_L1_TRX_SPLIT"
+    parallel_config    = "PARALLEL_SINGLE_THREAD";
+    #two option for worker "WORKER_DISABLE" or "WORKER_ENABLE"
+    worker_config      = "WORKER_DISABLE";
+  }
+);
+
+NETWORK_CONTROLLER :
+{
+    FLEXRAN_ENABLED        = "no";
+    FLEXRAN_INTERFACE_NAME = "lo";
+    FLEXRAN_IPV4_ADDRESS   = "127.0.0.1";
+    FLEXRAN_PORT           = 2210;
+    FLEXRAN_CACHE          = "/mnt/oai_agent_cache";
+    FLEXRAN_AWAIT_RECONF   = "no";
+};
+
+     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";
+    };
+
diff --git a/targets/RT/USER/lte-uesoftmodem.c b/targets/RT/USER/lte-uesoftmodem.c
index 617756e722..e14abe4f57 100644
--- a/targets/RT/USER/lte-uesoftmodem.c
+++ b/targets/RT/USER/lte-uesoftmodem.c
@@ -431,6 +431,7 @@ static void *scope_thread(void *arg) {
 		   PHY_vars_UE_g[0][0],
 		   0,
 		   0,7);
+       usleep(10000);
 
   //  printf("%s",stats_buffer);
     }
@@ -1004,7 +1005,7 @@ printf("~~~~~~~~~~~~~~~~~~~~successfully get the parallel config[%d], worker con
   
   
   
-#ifndef DEADLINE_SCHEDULER
+#if 0 // #ifndef DEADLINE_SCHEDULER
   
   printf("NO deadline scheduler\n");
   /* Currently we set affinity for UHD to CPU 0 for eNB/UE and only if number of CPUS >2 */
diff --git a/targets/RT/USER/nr-softmodem.c b/targets/RT/USER/nr-softmodem.c
index 5561258694..40d4758847 100644
--- a/targets/RT/USER/nr-softmodem.c
+++ b/targets/RT/USER/nr-softmodem.c
@@ -961,6 +961,7 @@ int main( int argc, char **argv )
       fprintf(stderr,"Getting configuration failed\n");
       exit(-1);
   }
+  openair0_cfg[0].threequarter_fs = threequarter_fs;
 
 
 #if T_TRACER
@@ -1237,6 +1238,8 @@ int main( int argc, char **argv )
 
   // wait for end of program
   printf("TYPE <CTRL-C> TO TERMINATE\n");
+  fflush(stdout);
+  fflush(stderr);
   //getchar();
 
 #if defined(ENABLE_ITTI)
diff --git a/targets/RT/USER/nr-ue.c b/targets/RT/USER/nr-ue.c
deleted file mode 100644
index 4ab0781787..0000000000
--- a/targets/RT/USER/nr-ue.c
+++ /dev/null
@@ -1,1251 +0,0 @@
-/*
- * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The OpenAirInterface Software Alliance licenses this file to You under
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
- * except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.openairinterface.org/?page_id=698
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *-------------------------------------------------------------------------------
- * For more information about the OpenAirInterface (OAI) Software Alliance:
- *      contact@openairinterface.org
- */
-
-/*! \file lte-ue.c
- * \brief threads and support functions for real-time LTE UE target
- * \author R. Knopp, F. Kaltenberger, Navid Nikaein
- * \date 2015
- * \version 0.1
- * \company Eurecom
- * \email: knopp@eurecom.fr,florian.kaltenberger@eurecom.fr, navid.nikaein@eurecom.fr
- * \note
- * \warning
- */
-#include "nr-uesoftmodem.h"
-
-#include "rt_wrapper.h"
-
-#include "LAYER2/NR_MAC_UE/mac.h"
-//#include "RRC/LTE/rrc_extern.h"
-#include "PHY_INTERFACE/phy_interface_extern.h"
-
-#undef MALLOC //there are two conflicting definitions, so we better make sure we don't use it at all
-//#undef FRAME_LENGTH_COMPLEX_SAMPLES //there are two conflicting definitions, so we better make sure we don't use it at all
-
-#include "fapi_nr_ue_l1.h"
-#include "PHY/phy_extern_nr_ue.h"
-#include "PHY/INIT/phy_init.h"
-#include "PHY/MODULATION/modulation_UE.h"
-#include "LAYER2/NR_MAC_UE/mac_proto.h"
-#include "RRC/NR_UE/rrc_proto.h"
-
-//#ifndef NO_RAT_NR
-#include "SCHED_NR/phy_frame_config_nr.h"
-//#endif
-#include "SCHED_NR_UE/defs.h"
-
-#include "PHY/NR_UE_TRANSPORT/nr_transport_proto_ue.h"
-
-#include "common/utils/LOG/log.h"
-#include "common/utils/LOG/vcd_signal_dumper.h"
-
-#include "T.h"
-
-#ifdef XFORMS
-  #include "PHY/TOOLS/nr_phy_scope.h"
-
-  extern char do_forms;
-#endif
-
-
-extern double cpuf;
-//static  nfapi_nr_config_request_t config_t;
-//static  nfapi_nr_config_request_t* config =&config_t;
-
-/*
- *  NR SLOT PROCESSING SEQUENCE
- *
- *  Processing occurs with following steps for connected mode:
- *
- *  - Rx samples for a slot are received,
- *  - PDCCH processing (including DCI extraction for downlink and uplink),
- *  - PDSCH processing (including transport blocks decoding),
- *  - PUCCH/PUSCH (transmission of acknowledgements, CSI, ... or data).
- *
- *  Time between reception of the slot and related transmission depends on UE processing performance.
- *  It is defined by the value NR_UE_CAPABILITY_SLOT_RX_TO_TX.
- *
- *  In NR, network gives the duration between Rx slot and Tx slot in the DCI:
- *  - for reception of a PDSCH and its associated acknowledgment slot (with a PUCCH or a PUSCH),
- *  - for reception of an uplink grant and its associated PUSCH slot.
- *
- *  So duration between reception and it associated transmission depends on its transmission slot given in the DCI.
- *  NR_UE_CAPABILITY_SLOT_RX_TO_TX means the minimum duration but higher duration can be given by the network because UE can support it.
- *
-*                                                                                                    Slot k
-*                                                                                  -------+------------+--------
-*                Frame                                                                    | Tx samples |
-*                Subframe                                                                 |   buffer   |
-*                Slot n                                                            -------+------------+--------
-*       ------ +------------+--------                                                     |
-*              | Rx samples |                                                             |
-*              |   buffer   |                                                             |
-*       -------+------------+--------                                                     |
-*                           |                                                             |
-*                           V                                                             |
-*                           +------------+                                                |
-*                           |   PDCCH    |                                                |
-*                           | processing |                                                |
-*                           +------------+                                                |
-*                           |            |                                                |
-*                           |            v                                                |
-*                           |            +------------+                                   |
-*                           |            |   PDSCH    |                                   |
-*                           |            | processing | decoding result                   |
-*                           |            +------------+    -> ACK/NACK of PDSCH           |
-*                           |                         |                                   |
-*                           |                         v                                   |
-*                           |                         +-------------+------------+        |
-*                           |                         | PUCCH/PUSCH | Tx samples |        |
-*                           |                         |  processing | transfer   |        |
-*                           |                         +-------------+------------+        |
-*                           |                                                             |
-*                           |/___________________________________________________________\|
-*                            \  duration between reception and associated transmission   /
-*
-* Remark: processing is done slot by slot, it can be distribute on different threads which are executed in parallel.
-* This is an architecture optimization in order to cope with real time constraints.
-* By example, for LTE, subframe processing is spread over 4 different threads.
-*
- */
-
-#ifndef NO_RAT_NR
-  #define DURATION_RX_TO_TX           (NR_UE_CAPABILITY_SLOT_RX_TO_TX)  /* for NR this will certainly depends to such UE capability which is not yet defined */
-#else
-  #define DURATION_RX_TO_TX           (4)   /* For LTE, this duration is fixed to 4 and it is linked to LTE standard for both modes FDD/TDD */
-#endif
-
-#define FRAME_PERIOD    100000000ULL
-#define DAQ_PERIOD      66667ULL
-#define FIFO_PRIORITY   40
-
-typedef enum {
-  pss=0,
-  pbch=1,
-  si=2
-} sync_mode_t;
-
-void init_UE_threads(PHY_VARS_NR_UE *UE);
-void *UE_thread(void *arg);
-void init_UE(int nb_inst);
-
-int32_t **rxdata;
-int32_t **txdata;
-
-#define KHz (1000UL)
-#define MHz (1000*KHz)
-#define SAIF_ENABLED
-
-#ifdef SAIF_ENABLED
-  uint64_t  g_ue_rx_thread_busy = 0;
-#endif
-
-typedef struct eutra_band_s {
-  int16_t band;
-  uint32_t ul_min;
-  uint32_t ul_max;
-  uint32_t dl_min;
-  uint32_t dl_max;
-  lte_frame_type_t frame_type;
-} eutra_band_t;
-
-typedef struct band_info_s {
-  int nbands;
-  eutra_band_t band_info[100];
-} band_info_t;
-
-band_info_t bands_to_scan;
-
-static const eutra_band_t eutra_bands[] = {
-  { 1, 1920    * MHz, 1980    * MHz, 2110    * MHz, 2170    * MHz, FDD},
-  { 2, 1850    * MHz, 1910    * MHz, 1930    * MHz, 1990    * MHz, FDD},
-  { 3, 1710    * MHz, 1785    * MHz, 1805    * MHz, 1880    * MHz, FDD},
-  { 4, 1710    * MHz, 1755    * MHz, 2110    * MHz, 2155    * MHz, FDD},
-  { 5,  824    * MHz,  849    * MHz,  869    * MHz,  894    * MHz, FDD},
-  { 6,  830    * MHz,  840    * MHz,  875    * MHz,  885    * MHz, FDD},
-  { 7, 2500    * MHz, 2570    * MHz, 2620    * MHz, 2690    * MHz, FDD},
-  { 8,  880    * MHz,  915    * MHz,  925    * MHz,  960    * MHz, FDD},
-  { 9, 1749900 * KHz, 1784900 * KHz, 1844900 * KHz, 1879900 * KHz, FDD},
-  {10, 1710    * MHz, 1770    * MHz, 2110    * MHz, 2170    * MHz, FDD},
-  {11, 1427900 * KHz, 1452900 * KHz, 1475900 * KHz, 1500900 * KHz, FDD},
-  {12,  698    * MHz,  716    * MHz,  728    * MHz,  746    * MHz, FDD},
-  {13,  777    * MHz,  787    * MHz,  746    * MHz,  756    * MHz, FDD},
-  {14,  788    * MHz,  798    * MHz,  758    * MHz,  768    * MHz, FDD},
-  {17,  704    * MHz,  716    * MHz,  734    * MHz,  746    * MHz, FDD},
-  {20,  832    * MHz,  862    * MHz,  791    * MHz,  821    * MHz, FDD},
-  {22, 3510    * MHz, 3590    * MHz, 3410    * MHz, 3490    * MHz, FDD},
-  {33, 1900    * MHz, 1920    * MHz, 1900    * MHz, 1920    * MHz, TDD},
-  {34, 2010    * MHz, 2025    * MHz, 2010    * MHz, 2025    * MHz, TDD},
-  {35, 1850    * MHz, 1910    * MHz, 1850    * MHz, 1910    * MHz, TDD},
-  {36, 1930    * MHz, 1990    * MHz, 1930    * MHz, 1990    * MHz, TDD},
-  {37, 1910    * MHz, 1930    * MHz, 1910    * MHz, 1930    * MHz, TDD},
-  {38, 2570    * MHz, 2620    * MHz, 2570    * MHz, 2630    * MHz, TDD},
-  {39, 1880    * MHz, 1920    * MHz, 1880    * MHz, 1920    * MHz, TDD},
-  {40, 2300    * MHz, 2400    * MHz, 2300    * MHz, 2400    * MHz, TDD},
-  {41, 2496    * MHz, 2690    * MHz, 2496    * MHz, 2690    * MHz, TDD},
-  {42, 3400    * MHz, 3600    * MHz, 3400    * MHz, 3600    * MHz, TDD},
-  {43, 3600    * MHz, 3800    * MHz, 3600    * MHz, 3800    * MHz, TDD},
-  {44, 703    * MHz, 803    * MHz, 703    * MHz, 803    * MHz, TDD},
-};
-
-PHY_VARS_NR_UE *init_nr_ue_vars(NR_DL_FRAME_PARMS *frame_parms,
-                                uint8_t UE_id,
-                                uint8_t abstraction_flag)
-
-{
-  PHY_VARS_NR_UE *ue;
-
-  if (frame_parms!=(NR_DL_FRAME_PARMS *)NULL) { // if we want to give initial frame parms, allocate the PHY_VARS_UE structure and put them in
-    ue = (PHY_VARS_NR_UE *)malloc(sizeof(PHY_VARS_NR_UE));
-    memset(ue,0,sizeof(PHY_VARS_NR_UE));
-    memcpy(&(ue->frame_parms), frame_parms, sizeof(NR_DL_FRAME_PARMS));
-  } else ue = PHY_vars_UE_g[UE_id][0];
-
-  ue->Mod_id      = UE_id;
-  ue->mac_enabled = 1;
-  // initialize all signal buffers
-  init_nr_ue_signal(ue,1,abstraction_flag);
-  // intialize transport
-  init_nr_ue_transport(ue,abstraction_flag);
-  return(ue);
-}
-
-void init_thread(int sched_runtime, int sched_deadline, int sched_fifo, cpu_set_t *cpuset, char *name) {
-#ifdef DEADLINE_SCHEDULER
-
-  if (sched_runtime!=0) {
-    struct sched_attr attr= {0};
-    attr.size = sizeof(attr);
-    attr.sched_policy = SCHED_DEADLINE;
-    attr.sched_runtime  = sched_runtime;
-    attr.sched_deadline = sched_deadline;
-    attr.sched_period   = 0;
-    AssertFatal(sched_setattr(0, &attr, 0) == 0,
-                "[SCHED] %s thread: sched_setattr failed %s \n", name, strerror(errno));
-    LOG_I(HW,"[SCHED][eNB] %s deadline thread %lu started on CPU %d\n",
-          name, (unsigned long)gettid(), sched_getcpu());
-  }
-
-#else
-
-  if (CPU_COUNT(cpuset) > 0)
-    AssertFatal( 0 == pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), cpuset), "");
-
-  struct sched_param sp;
-  sp.sched_priority = sched_fifo;
-  AssertFatal(pthread_setschedparam(pthread_self(),SCHED_FIFO,&sp)==0,
-              "Can't set thread priority, Are you root?\n");
-  /* Check the actual affinity mask assigned to the thread */
-  cpu_set_t *cset=CPU_ALLOC(CPU_SETSIZE);
-
-  if (0 == pthread_getaffinity_np(pthread_self(), CPU_ALLOC_SIZE(CPU_SETSIZE), cset)) {
-    char txt[512]= {0};
-
-    for (int j = 0; j < CPU_SETSIZE; j++)
-      if (CPU_ISSET(j, cset))
-        sprintf(txt+strlen(txt), " %d ", j);
-
-    printf("CPU Affinity of thread %s is %s\n", name, txt);
-  }
-
-  CPU_FREE(cset);
-#endif
-  // Lock memory from swapping. This is a process wide call (not constraint to this thread).
-  mlockall(MCL_CURRENT | MCL_FUTURE);
-  pthread_setname_np( pthread_self(), name );
-  // LTS: this sync stuff should be wrong
-  printf("waiting for sync (%s)\n",name);
-  pthread_mutex_lock(&sync_mutex);
-  printf("Locked sync_mutex, waiting (%s)\n",name);
-
-  while (sync_var<0)
-    pthread_cond_wait(&sync_cond, &sync_mutex);
-
-  pthread_mutex_unlock(&sync_mutex);
-  printf("started %s as PID: %ld\n",name, gettid());
-}
-
-void init_UE(int nb_inst) {
-  int inst;
-  NR_UE_MAC_INST_t *mac_inst;
-
-  for (inst=0; inst < nb_inst; inst++) {
-    //    UE->rfdevice.type      = NONE_DEV;
-    //PHY_VARS_NR_UE *UE = PHY_vars_UE_g[inst][0];
-    LOG_I(PHY,"Initializing memory for UE instance %d (%p)\n",inst,PHY_vars_UE_g[inst]);
-    PHY_vars_UE_g[inst][0] = init_nr_ue_vars(NULL,inst,0);
-    PHY_VARS_NR_UE *UE = PHY_vars_UE_g[inst][0];
-    AssertFatal((UE->if_inst = nr_ue_if_module_init(inst)) != NULL, "can not initial IF module\n");
-    nr_l3_init_ue();
-    nr_l2_init_ue();
-    mac_inst = get_mac_inst(0);
-    mac_inst->if_module = UE->if_inst;
-    UE->if_inst->scheduled_response = nr_ue_scheduled_response;
-    UE->if_inst->phy_config_request = nr_ue_phy_config_request;
-    LOG_I(PHY,"Intializing UE Threads for instance %d (%p,%p)...\n",inst,PHY_vars_UE_g[inst],PHY_vars_UE_g[inst][0]);
-    //init_UE_threads(inst);
-    //UE = PHY_vars_UE_g[inst][0];
-    AssertFatal(0 == pthread_create(&UE->proc.pthread_ue,
-                                    &UE->proc.attr_ue,
-                                    UE_thread,
-                                    (void *)UE), "");
-  }
-
-  printf("UE threads created by %ld\n", gettid());
-#if 0
-#if defined(ENABLE_USE_MME)
-  extern volatile int start_UE;
-
-  while (start_UE == 0) {
-    sleep(1);
-  }
-
-#endif
-#endif
-}
-
-/*!
- * \brief This is the UE synchronize thread.
- * It performs band scanning and synchonization.
- * \param arg is a pointer to a \ref PHY_VARS_NR_UE structure.
- * \returns a pointer to an int. The storage is not on the heap and must not be freed.
- */
-static void *UE_thread_synch(void *arg) {
-  static int __thread UE_thread_synch_retval;
-  int i, hw_slot_offset;
-  PHY_VARS_NR_UE *UE = (PHY_VARS_NR_UE *) arg;
-  int current_band = 0;
-  int current_offset = 0;
-  sync_mode_t sync_mode = pbch;
-  int CC_id = UE->CC_id;
-  int freq_offset=0;
-  char threadname[128];
-  cpu_set_t cpuset;
-  CPU_ZERO(&cpuset);
-
-  if ( threads.sync != -1 )
-    CPU_SET(threads.sync, &cpuset);
-
-  // this thread priority must be lower that the main acquisition thread
-  sprintf(threadname, "sync UE %d", UE->Mod_id);
-  init_thread(100000, 500000, FIFO_PRIORITY-1, &cpuset, threadname);
-  UE->is_synchronized = 0;
-
-  if (UE->UE_scan == 0) {
-    int ind;
-
-    for ( ind=0;
-          ind < sizeof(eutra_bands) / sizeof(eutra_bands[0]);
-          ind++) {
-      current_band = eutra_bands[ind].band;
-      LOG_D(PHY, "Scanning band %d, dl_min %"PRIu32", ul_min %"PRIu32"\n", current_band, eutra_bands[ind].dl_min,eutra_bands[ind].ul_min);
-
-      if ( eutra_bands[ind].dl_min <= downlink_frequency[0][0] && eutra_bands[ind].dl_max >= downlink_frequency[0][0] ) {
-        for (i=0; i<4; i++)
-          uplink_frequency_offset[CC_id][i] = eutra_bands[ind].ul_min - eutra_bands[ind].dl_min;
-
-        break;
-      }
-    }
-
-    AssertFatal( ind < sizeof(eutra_bands) / sizeof(eutra_bands[0]), "Can't find EUTRA band for frequency");
-    LOG_I( PHY, "[SCHED][UE] Check absolute frequency DL %"PRIu32", UL %"PRIu32" (oai_exit %d, rx_num_channels %d)\n",
-           downlink_frequency[0][0], downlink_frequency[0][0]+uplink_frequency_offset[0][0],
-           oai_exit, openair0_cfg[0].rx_num_channels);
-
-    for (i=0; i<openair0_cfg[UE->rf_map.card].rx_num_channels; i++) {
-      openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i];
-      openair0_cfg[UE->rf_map.card].tx_freq[UE->rf_map.chain+i] =
-        downlink_frequency[CC_id][i]+uplink_frequency_offset[CC_id][i];
-      openair0_cfg[UE->rf_map.card].autocal[UE->rf_map.chain+i] = 1;
-
-      if (uplink_frequency_offset[CC_id][i] != 0) //
-        openair0_cfg[UE->rf_map.card].duplex_mode = duplex_mode_FDD;
-      else //FDD
-        openair0_cfg[UE->rf_map.card].duplex_mode = duplex_mode_TDD;
-    }
-
-    sync_mode = pbch;
-  } else {
-    current_band=0;
-
-    for (i=0; i<openair0_cfg[UE->rf_map.card].rx_num_channels; i++) {
-      downlink_frequency[UE->rf_map.card][UE->rf_map.chain+i] = bands_to_scan.band_info[CC_id].dl_min;
-      uplink_frequency_offset[UE->rf_map.card][UE->rf_map.chain+i] =
-        bands_to_scan.band_info[CC_id].ul_min-bands_to_scan.band_info[CC_id].dl_min;
-      openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i];
-      openair0_cfg[UE->rf_map.card].tx_freq[UE->rf_map.chain+i] =
-        downlink_frequency[CC_id][i]+uplink_frequency_offset[CC_id][i];
-      openair0_cfg[UE->rf_map.card].rx_gain[UE->rf_map.chain+i] = UE->rx_total_gain_dB;
-    }
-  }
-
-  //    AssertFatal(UE->rfdevice.trx_start_func(&UE->rfdevice) == 0, "Could not start the device\n");
-
-  while (oai_exit==0) {
-    AssertFatal ( 0== pthread_mutex_lock(&UE->proc.mutex_synch), "");
-
-    while (UE->proc.instance_cnt_synch < 0)
-      // the thread waits here most of the time
-      pthread_cond_wait( &UE->proc.cond_synch, &UE->proc.mutex_synch );
-
-    AssertFatal ( 0== pthread_mutex_unlock(&UE->proc.mutex_synch), "");
-
-    switch (sync_mode) {
-      case pss:
-        LOG_I(PHY,"[SCHED][UE] Scanning band %d (%d), freq %u\n",bands_to_scan.band_info[current_band].band, current_band,bands_to_scan.band_info[current_band].dl_min+current_offset);
-        //lte_sync_timefreq(UE,current_band,bands_to_scan.band_info[current_band].dl_min+current_offset);
-        current_offset += 20000000; // increase by 20 MHz
-
-        if (current_offset > bands_to_scan.band_info[current_band].dl_max-bands_to_scan.band_info[current_band].dl_min) {
-          current_band++;
-          current_offset=0;
-        }
-
-        if (current_band==bands_to_scan.nbands) {
-          current_band=0;
-          oai_exit=1;
-        }
-
-        for (i=0; i<openair0_cfg[UE->rf_map.card].rx_num_channels; i++) {
-          downlink_frequency[UE->rf_map.card][UE->rf_map.chain+i] = bands_to_scan.band_info[current_band].dl_min+current_offset;
-          uplink_frequency_offset[UE->rf_map.card][UE->rf_map.chain+i] = bands_to_scan.band_info[current_band].ul_min-bands_to_scan.band_info[0].dl_min + current_offset;
-          openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i];
-          openair0_cfg[UE->rf_map.card].tx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i]+uplink_frequency_offset[CC_id][i];
-          openair0_cfg[UE->rf_map.card].rx_gain[UE->rf_map.chain+i] = UE->rx_total_gain_dB;
-
-          if (UE->UE_scan_carrier) {
-            openair0_cfg[UE->rf_map.card].autocal[UE->rf_map.chain+i] = 1;
-          }
-        }
-
-        break;
-
-      case pbch:
-#if DISABLE_LOG_X
-        printf("[UE thread Synch] Running Initial Synch (mode %d)\n",UE->mode);
-#else
-        LOG_I(PHY, "[UE thread Synch] Running Initial Synch (mode %d)\n",UE->mode);
-#endif
-
-        if (nr_initial_sync( UE, UE->mode ) == 0) {
-          //write_output("txdata_sym.m", "txdata_sym", UE->common_vars.rxdata[0], (10*UE->frame_parms.samples_per_slot), 1, 1);
-          freq_offset = UE->common_vars.freq_offset; // frequency offset computed with pss in initial sync
-          hw_slot_offset = (UE->rx_offset<<1) / UE->frame_parms.samples_per_slot;
-          printf("Got synch: hw_slot_offset %d, carrier off %d Hz, rxgain %d (DL %u, UL %u), UE_scan_carrier %d\n",
-                 hw_slot_offset,
-                 freq_offset,
-                 UE->rx_total_gain_dB,
-                 downlink_frequency[0][0]+freq_offset,
-                 downlink_frequency[0][0]+uplink_frequency_offset[0][0]+freq_offset,
-                 UE->UE_scan_carrier );
-
-          // rerun with new cell parameters and frequency-offset
-          for (i=0; i<openair0_cfg[UE->rf_map.card].rx_num_channels; i++) {
-            openair0_cfg[UE->rf_map.card].rx_gain[UE->rf_map.chain+i] = UE->rx_total_gain_dB;//-USRP_GAIN_OFFSET;
-
-            if (freq_offset >= 0)
-              openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] += abs(freq_offset);
-            else
-              openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] -= abs(freq_offset);
-
-            openair0_cfg[UE->rf_map.card].tx_freq[UE->rf_map.chain+i] =
-              openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i]+uplink_frequency_offset[CC_id][i];
-            downlink_frequency[CC_id][i] = openair0_cfg[CC_id].rx_freq[i];
-          }
-
-          // reconfigure for potentially different bandwidth
-          switch(UE->frame_parms.N_RB_DL) {
-            case 6:
-              openair0_cfg[UE->rf_map.card].sample_rate =1.92e6;
-              openair0_cfg[UE->rf_map.card].rx_bw          =.96e6;
-              openair0_cfg[UE->rf_map.card].tx_bw          =.96e6;
-              //            openair0_cfg[0].rx_gain[0] -= 12;
-              break;
-
-            case 25:
-              openair0_cfg[UE->rf_map.card].sample_rate =7.68e6;
-              openair0_cfg[UE->rf_map.card].rx_bw          =2.5e6;
-              openair0_cfg[UE->rf_map.card].tx_bw          =2.5e6;
-              //            openair0_cfg[0].rx_gain[0] -= 6;
-              break;
-
-            case 50:
-              openair0_cfg[UE->rf_map.card].sample_rate =15.36e6;
-              openair0_cfg[UE->rf_map.card].rx_bw          =5.0e6;
-              openair0_cfg[UE->rf_map.card].tx_bw          =5.0e6;
-              //            openair0_cfg[0].rx_gain[0] -= 3;
-              break;
-
-            case 100:
-              openair0_cfg[UE->rf_map.card].sample_rate=30.72e6;
-              openair0_cfg[UE->rf_map.card].rx_bw=10.0e6;
-              openair0_cfg[UE->rf_map.card].tx_bw=10.0e6;
-              //            openair0_cfg[0].rx_gain[0] -= 0;
-              break;
-          }
-
-          if (UE->mode != loop_through_memory) {
-            UE->rfdevice.trx_set_freq_func(&UE->rfdevice,&openair0_cfg[0],0);
-            //UE->rfdevice.trx_set_gains_func(&openair0,&openair0_cfg[0]);
-            //UE->rfdevice.trx_stop_func(&UE->rfdevice);
-            // sleep(1);
-            //nr_init_frame_parms_ue(&UE->frame_parms);
-            /*if (UE->rfdevice.trx_start_func(&UE->rfdevice) != 0 ) {
-              LOG_E(HW,"Could not start the device\n");
-              oai_exit=1;
-                        }*/
-          }
-
-          if (UE->UE_scan_carrier == 1) {
-            UE->UE_scan_carrier = 0;
-          } else {
-            AssertFatal ( 0== pthread_mutex_lock(&UE->proc.mutex_synch), "");
-            UE->is_synchronized = 1;
-            AssertFatal ( 0== pthread_mutex_unlock(&UE->proc.mutex_synch), "");
-
-            if( UE->mode == rx_dump_frame ) {
-              FILE *fd;
-
-              if ((UE->proc.proc_rxtx[0].frame_rx&1) == 0) {  // this guarantees SIB1 is present
-                if ((fd = fopen("rxsig_frame0.dat","w")) != NULL) {
-                  fwrite((void *)&UE->common_vars.rxdata[0][0],
-                         sizeof(int32_t),
-                         10*UE->frame_parms.samples_per_subframe,
-                         fd);
-                  LOG_I(PHY,"Dummping Frame ... bye bye \n");
-                  fclose(fd);
-                  exit(0);
-                } else {
-                  LOG_E(PHY,"Cannot open file for writing\n");
-                  exit(0);
-                }
-              } else {
-                AssertFatal ( 0== pthread_mutex_lock(&UE->proc.mutex_synch), "");
-                UE->is_synchronized = 0;
-                AssertFatal ( 0== pthread_mutex_unlock(&UE->proc.mutex_synch), "");
-              }
-            }
-          }
-        } else {
-          // initial sync failed
-          // calculate new offset and try again
-          if (UE->UE_scan_carrier == 1) {
-            if (freq_offset >= 0)
-              freq_offset += 100;
-
-            freq_offset *= -1;
-
-            if (abs(freq_offset) > 7500) {
-              LOG_I( PHY, "[initial_sync] No cell synchronization found, abandoning\n" );
-              FILE *fd;
-
-              if ((fd = fopen("rxsig_frame0.dat","w"))!=NULL) {
-                fwrite((void *)&UE->common_vars.rxdata[0][0],
-                       sizeof(int32_t),
-                       10*UE->frame_parms.samples_per_subframe,
-                       fd);
-                LOG_I(PHY,"Dummping Frame ... bye bye \n");
-                fclose(fd);
-                exit(0);
-              }
-
-              //mac_xface->macphy_exit("No cell synchronization found, abandoning"); new mac
-              return &UE_thread_synch_retval; // not reached
-            }
-          }
-
-#if DISABLE_LOG_X
-          printf("[initial_sync] trying carrier off %d Hz, rxgain %d (DL %u, UL %u)\n",
-                 freq_offset,
-                 UE->rx_total_gain_dB,
-                 downlink_frequency[0][0]+freq_offset,
-                 downlink_frequency[0][0]+uplink_frequency_offset[0][0]+freq_offset );
-#else
-          LOG_I(PHY, "[initial_sync] trying carrier off %d Hz, rxgain %d (DL %u, UL %u)\n",
-                freq_offset,
-                UE->rx_total_gain_dB,
-                downlink_frequency[0][0]+freq_offset,
-                downlink_frequency[0][0]+uplink_frequency_offset[0][0]+freq_offset );
-#endif
-
-          for (i=0; i<openair0_cfg[UE->rf_map.card].rx_num_channels; i++) {
-            openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i]+freq_offset;
-            openair0_cfg[UE->rf_map.card].tx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i]+uplink_frequency_offset[CC_id][i]+freq_offset;
-            openair0_cfg[UE->rf_map.card].rx_gain[UE->rf_map.chain+i] = UE->rx_total_gain_dB;//-USRP_GAIN_OFFSET;
-
-            if (UE->UE_scan_carrier==1)
-              openair0_cfg[UE->rf_map.card].autocal[UE->rf_map.chain+i] = 1;
-          }
-
-          if (UE->mode != loop_through_memory)
-            UE->rfdevice.trx_set_freq_func(&UE->rfdevice,&openair0_cfg[0],0);
-        }// initial_sync=0
-
-        break;
-
-      case si:
-      default:
-        break;
-    }
-
-#if 0 //defined XFORMS
-
-    if (do_forms) {
-      extern FD_lte_phy_scope_ue  *form_ue[NUMBER_OF_UE_MAX];
-      phy_scope_UE(form_ue[0],
-                   PHY_vars_UE_g[0][0],
-                   0,0,1);
-    }
-
-#endif
-    AssertFatal ( 0== pthread_mutex_lock(&UE->proc.mutex_synch), "");
-    // indicate readiness
-    UE->proc.instance_cnt_synch--;
-    AssertFatal ( 0== pthread_mutex_unlock(&UE->proc.mutex_synch), "");
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_UE_THREAD_SYNCH, 0 );
-  }  // while !oai_exit
-
-  return &UE_thread_synch_retval;
-}
-
-void processSubframeRX( PHY_VARS_NR_UE *UE, UE_nr_rxtx_proc_t *proc) {
-  // Process Rx data for one sub-frame
-  if (slot_select_nr(&UE->frame_parms, proc->frame_tx, proc->nr_tti_tx) & NR_DOWNLINK_SLOT) {
-    //clean previous FAPI MESSAGE
-    UE->rx_ind.number_pdus = 0;
-    UE->dci_ind.number_of_dcis = 0;
-    //clean previous FAPI MESSAGE
-    // call L2 for DL_CONFIG (DCI)
-    UE->dcireq.module_id = UE->Mod_id;
-    UE->dcireq.gNB_index = 0;
-    UE->dcireq.cc_id     = 0;
-    UE->dcireq.frame     = proc->frame_rx;
-    UE->dcireq.slot      = proc->nr_tti_rx;
-    nr_ue_dcireq(&UE->dcireq); //to be replaced with function pointer later
-    NR_UE_MAC_INST_t *UE_mac = get_mac_inst(0);
-    UE_mac->scheduled_response.dl_config = &UE->dcireq.dl_config_req;
-    UE_mac->scheduled_response.slot = proc->nr_tti_rx;
-    nr_ue_scheduled_response(&UE_mac->scheduled_response);
-    //write_output("uerxdata_frame.m", "uerxdata_frame", UE->common_vars.rxdata[0], UE->frame_parms.samples_per_frame, 1, 1);
-    printf("Processing slot %d\n",proc->nr_tti_rx);
-#ifdef UE_SLOT_PARALLELISATION
-    phy_procedures_slot_parallelization_nrUE_RX( UE, proc, 0, 0, 1, UE->mode, no_relay, NULL );
-#else
-    phy_procedures_nrUE_RX( UE, proc, 0, 1, UE->mode);
-    //            printf(">>> nr_ue_pdcch_procedures ended\n");
-#endif
-  }
-
-  if (UE->mac_enabled==1) {
-    //  trigger L2 to run ue_scheduler thru IF module
-    //  [TODO] mapping right after NR initial sync
-    if(UE->if_inst != NULL && UE->if_inst->ul_indication != NULL) {
-      UE->ul_indication.module_id = 0;
-      UE->ul_indication.gNB_index = 0;
-      UE->ul_indication.cc_id = 0;
-      UE->ul_indication.frame = proc->frame_rx;
-      UE->ul_indication.slot = proc->nr_tti_rx;
-      UE->if_inst->ul_indication(&UE->ul_indication);
-    }
-  }
-}
-
-/*!
- * \brief This is the UE thread for RX subframe n and TX subframe n+4.
- * This thread performs the phy_procedures_UE_RX() on every received slot.
- * then, if TX is enabled it performs TX for n+4.
- * \param arg is a pointer to a \ref PHY_VARS_NR_UE structure.
- * \returns a pointer to an int. The storage is not on the heap and must not be freed.
- */
-
-static void *UE_thread_rxn_txnp4(void *arg) {
-  struct nr_rxtx_thread_data *rtd = arg;
-  UE_nr_rxtx_proc_t *proc = rtd->proc;
-  PHY_VARS_NR_UE    *UE   = rtd->UE;
-  //proc->counter_decoder = 0;
-  proc->instance_cnt_rxtx=-1;
-  proc->subframe_rx=proc->sub_frame_start;
-  proc->dci_err_cnt=0;
-  char threadname[256];
-  sprintf(threadname,"UE_%d_proc_%d", UE->Mod_id, proc->sub_frame_start);
-  cpu_set_t cpuset;
-  CPU_ZERO(&cpuset);
-  char timing_proc_name[256];
-  sprintf(timing_proc_name,"Delay to process sub-frame proc %d",proc->sub_frame_start);
-
-  if ( (proc->sub_frame_start+1)%RX_NB_TH == 0 && threads.one != -1 )
-    CPU_SET(threads.one, &cpuset);
-
-  if ( (proc->sub_frame_start+1)%RX_NB_TH == 1 && threads.two != -1 )
-    CPU_SET(threads.two, &cpuset);
-
-  if ( (proc->sub_frame_start+1)%RX_NB_TH == 2 && threads.three != -1 )
-    CPU_SET(threads.three, &cpuset);
-
-  //CPU_SET(threads.three, &cpuset);
-  init_thread(900000,1000000, FIFO_PRIORITY-1, &cpuset,
-              threadname);
-
-  while (!oai_exit) {
-    AssertFatal( 0 == pthread_mutex_lock(&proc->mutex_rxtx), "[SCHED][UE] error locking mutex for UE RXTX\n" );
-
-    while (proc->instance_cnt_rxtx < 0) {
-      // most of the time, the thread is waiting here
-      pthread_cond_wait( &proc->cond_rxtx, &proc->mutex_rxtx );
-    }
-
-    AssertFatal ( 0== pthread_mutex_unlock(&proc->mutex_rxtx), "[SCHED][UE] error unlocking mutex for UE RXn_TXnp4\n" );
-    processSubframeRX(UE, proc);
-    //printf(">>> mac ended\n");
-    // Prepare the future Tx data
-#if 0
-#ifndef NO_RAT_NR
-
-    if (slot_select_nr(&UE->frame_parms, proc->frame_tx, proc->nr_tti_tx) & NR_UPLINK_SLOT)
-#else
-    if ((subframe_select( &UE->frame_parms, proc->subframe_tx) == SF_UL) ||
-        (UE->frame_parms.frame_type == FDD) )
-#endif
-      if (UE->mode != loop_through_memory)
-        phy_procedures_nrUE_TX(UE,proc,0,0,UE->mode,no_relay);
-
-    //phy_procedures_UE_TX(UE,proc,0,0,UE->mode,no_relay);
-#endif
-#if 0
-
-    if ((subframe_select( &UE->frame_parms, proc->subframe_tx) == SF_S) &&
-        (UE->frame_parms.frame_type == TDD))
-      if (UE->mode != loop_through_memory)
-        //phy_procedures_UE_S_TX(UE,0,0,no_relay);
-        updateTimes(current, &t3, 10000, timing_proc_name);
-
-#endif
-    AssertFatal( 0 == pthread_mutex_lock(&proc->mutex_rxtx), "[SCHED][UE] error locking mutex for UE RXTX\n" );
-    proc->instance_cnt_rxtx--;
-#if BASIC_SIMULATOR
-
-    if (pthread_cond_signal(&proc->cond_rxtx) != 0) abort();
-
-#endif
-    AssertFatal (0 == pthread_mutex_unlock(&proc->mutex_rxtx), "[SCHED][UE] error unlocking mutex for UE RXTX\n" );
-  }
-
-  // thread finished
-  free(arg);
-  return NULL;
-}
-
-void readFrame(PHY_VARS_NR_UE *UE,  openair0_timestamp *timestamp) {
-  void *rxp[NB_ANTENNAS_RX];
-  void *dummy_tx[UE->frame_parms.nb_antennas_tx];
-
-  for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
-    dummy_tx[i]=malloc16_clear(UE->frame_parms.samples_per_subframe*4);
-
-  for(int x=0; x<10; x++) {
-    for (int i=0; i<UE->frame_parms.nb_antennas_rx; i++)
-      rxp[i] = ((void *)&UE->common_vars.rxdata[i][0]) + 4*x*UE->frame_parms.samples_per_subframe;
-
-    AssertFatal( UE->frame_parms.samples_per_subframe ==
-                 UE->rfdevice.trx_read_func(&UE->rfdevice,
-                                            timestamp,
-                                            rxp,
-                                            UE->frame_parms.samples_per_subframe,
-                                            UE->frame_parms.nb_antennas_rx), "");
-  }
-
-  for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
-    free(dummy_tx[i]);
-}
-
-void trashFrame(PHY_VARS_NR_UE *UE, openair0_timestamp *timestamp) {
-  void *dummy_tx[UE->frame_parms.nb_antennas_tx];
-
-  for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
-    dummy_tx[i]=malloc16_clear(UE->frame_parms.samples_per_subframe*4);
-
-  void *dummy_rx[UE->frame_parms.nb_antennas_rx];
-
-  for (int i=0; i<UE->frame_parms.nb_antennas_rx; i++)
-    dummy_rx[i]=malloc16(UE->frame_parms.samples_per_subframe*4);
-
-  for (int sf=0; sf<NR_NUMBER_OF_SUBFRAMES_PER_FRAME; sf++) {
-    //      printf("Reading dummy sf %d\n",sf);
-    UE->rfdevice.trx_read_func(&UE->rfdevice,
-                               timestamp,
-                               dummy_rx,
-                               UE->frame_parms.samples_per_subframe,
-                               UE->frame_parms.nb_antennas_rx);
-    usleep(500); // this sleep improves in the case of simulated RF and doesn't harm with true radio
-  }
-
-  for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
-    free(dummy_tx[i]);
-
-  for (int i=0; i<UE->frame_parms.nb_antennas_rx; i++)
-    free(dummy_rx[i]);
-}
-
-void syncInFrame(PHY_VARS_NR_UE *UE, openair0_timestamp *timestamp) {
-  if (UE->no_timing_correction==0) {
-    LOG_I(PHY,"Resynchronizing RX by %d samples (mode = %d)\n",UE->rx_offset,UE->mode);
-    void *dummy_tx[UE->frame_parms.nb_antennas_tx];
-
-    for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
-      dummy_tx[i]=malloc16_clear(UE->frame_parms.samples_per_subframe*4);
-
-    for ( int size=UE->rx_offset ; size > 0 ; size -= UE->frame_parms.samples_per_subframe ) {
-      int unitTransfer=size>UE->frame_parms.samples_per_subframe ? UE->frame_parms.samples_per_subframe : size ;
-      AssertFatal(unitTransfer ==
-                  UE->rfdevice.trx_read_func(&UE->rfdevice,
-                                             timestamp,
-                                             (void **)UE->common_vars.rxdata,
-                                             unitTransfer,
-                                             UE->frame_parms.nb_antennas_rx),"");
-    }
-
-    for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
-      free(dummy_tx[i]);
-  }
-}
-
-int computeSamplesShift(PHY_VARS_NR_UE *UE) {
-  if ( getenv("RFSIMULATOR") != 0) {
-    LOG_E(PHY,"SET rx_offset %d \n",UE->rx_offset);
-    //UE->rx_offset_diff=0;
-    return 0;
-  }
-
-  // compute TO compensation that should be applied for this frame
-  if ( UE->rx_offset < 5*UE->frame_parms.samples_per_slot  &&
-       UE->rx_offset > 0 )
-    return -1 ;
-
-  if ( UE->rx_offset > 5*UE->frame_parms.samples_per_slot &&
-       UE->rx_offset < 10*UE->frame_parms.samples_per_slot )
-    return 1;
-
-  return 0;
-}
-
-/*!
- * \brief This is the main UE thread.
- * This thread controls the other three UE threads:
- * - UE_thread_rxn_txnp4 (even subframes)
- * - UE_thread_rxn_txnp4 (odd subframes)
- * - UE_thread_synch
- * \param arg unused
- * \returns a pointer to an int. The storage is not on the heap and must not be freed.
- */
-
-void *UE_thread(void *arg) {
-  PHY_VARS_NR_UE *UE = (PHY_VARS_NR_UE *) arg;
-  //  int tx_enabled = 0;
-  openair0_timestamp timestamp;
-  void *rxp[NB_ANTENNAS_RX], *txp[NB_ANTENNAS_TX];
-  int start_rx_stream = 0;
-  int i;
-  char threadname[128];
-  int th_id;
-  const uint16_t table_sf_slot[20] = {0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9};
-
-  for (int i=0; i<  RX_NB_TH_MAX; i++ )
-    UE->proc.proc_rxtx[i].counter_decoder = 0;
-
-  static uint8_t thread_idx = 0;
-  cpu_set_t cpuset;
-  CPU_ZERO(&cpuset);
-
-  if ( threads.main != -1 )
-    CPU_SET(threads.main, &cpuset);
-
-  sprintf(threadname, "Main UE %d", UE->Mod_id);
-  init_thread(100000, 500000, FIFO_PRIORITY, &cpuset,threadname);
-
-  if ((oaisim_flag == 0) && (UE->mode !=loop_through_memory))
-    AssertFatal(0== openair0_device_load(&(UE->rfdevice), &openair0_cfg[0]), "");
-
-  UE->rfdevice.host_type = RAU_HOST;
-  init_UE_threads(UE);
-#ifdef NAS_UE
-  //MessageDef *message_p;
-  //message_p = itti_alloc_new_message(TASK_NAS_UE, INITIALIZE_MESSAGE);
-  //itti_send_msg_to_task (TASK_NAS_UE, UE->Mod_id + NB_eNB_INST, message_p);
-#endif
-  int nb_slot_frame = 10*UE->frame_parms.slots_per_subframe;
-  int slot_nr=-1;
-
-  //int cumulated_shift=0;
-  if ((oaisim_flag == 0) && (UE->mode != loop_through_memory))
-    AssertFatal(UE->rfdevice.trx_start_func(&UE->rfdevice) == 0, "Could not start the device\n");
-
-  while (!oai_exit) {
-    AssertFatal ( 0== pthread_mutex_lock(&UE->proc.mutex_synch), "");
-    int instance_cnt_synch = UE->proc.instance_cnt_synch;
-    int is_synchronized    = UE->is_synchronized;
-    AssertFatal ( 0== pthread_mutex_unlock(&UE->proc.mutex_synch), "");
-
-    if (is_synchronized == 0) {
-#if BASIC_SIMULATOR
-
-      while (!((instance_cnt_synch = UE->proc.instance_cnt_synch) < 0)) {
-        printf("ue sync not ready\n");
-        usleep(500*1000);
-      }
-
-#endif
-
-      if (UE->mode != loop_through_memory) {
-        if (instance_cnt_synch < 0) {  // we can invoke the synch
-          // grab 10 ms of signal and wakeup synch thread
-          readFrame(UE, &timestamp);
-          AssertFatal( 0 == pthread_mutex_lock(&UE->proc.mutex_synch), "");
-          AssertFatal( 0 == ++UE->proc.instance_cnt_synch, "[SCHED][UE] UE sync thread busy!!\n" );
-          AssertFatal( 0 == pthread_cond_signal(&UE->proc.cond_synch), "");
-          AssertFatal( 0 == pthread_mutex_unlock(&UE->proc.mutex_synch), "");
-        } else {
-          // grab 10 ms of signal into dummy buffer to wait result of sync detection
-          trashFrame(UE, &timestamp);
-        }
-      }
-
-      continue;
-    }
-
-    if (start_rx_stream==0) {
-      start_rx_stream=1;
-
-      if (UE->mode != loop_through_memory) {
-        syncInFrame(UE, &timestamp);
-        UE->rx_offset=0;
-        UE->time_sync_cell=0;
-        UE->proc.proc_rxtx[0].frame_rx++;
-
-        //UE->proc.proc_rxtx[1].frame_rx++;
-        for (th_id=1; th_id < RX_NB_TH; th_id++) {
-          UE->proc.proc_rxtx[th_id].frame_rx = UE->proc.proc_rxtx[0].frame_rx;
-        }
-
-        //printf("first stream frame rx %d\n",UE->proc.proc_rxtx[0].frame_rx);
-        // read in first symbol
-        AssertFatal (UE->frame_parms.ofdm_symbol_size+UE->frame_parms.nb_prefix_samples0 ==
-                     UE->rfdevice.trx_read_func(&UE->rfdevice,
-                                                &timestamp,
-                                                (void **)UE->common_vars.rxdata,
-                                                UE->frame_parms.ofdm_symbol_size+UE->frame_parms.nb_prefix_samples0,
-                                                UE->frame_parms.nb_antennas_rx),"");
-        //write_output("txdata_sym.m", "txdata_sym", UE->common_vars.rxdata[0], (UE->frame_parms.ofdm_symbol_size+UE->frame_parms.nb_prefix_samples0), 1, 1);
-        //nr_slot_fep(UE,0, 0, 0, 1, 1, NR_PDCCH_EST);
-      } //UE->mode != loop_through_memory
-      else
-        rt_sleep_ns(1000*1000);
-
-      continue;
-    }
-
-    thread_idx++;
-    thread_idx%=RX_NB_TH;
-    //printf("slot_nr %d nb slot frame %d\n",slot_nr, nb_slot_frame);
-    slot_nr++;
-    slot_nr %= nb_slot_frame;
-    UE_nr_rxtx_proc_t *proc = &UE->proc.proc_rxtx[thread_idx];
-    // update thread index for received subframe
-    UE->current_thread_id[slot_nr] = thread_idx;
-#if BASIC_SIMULATOR
-
-    for (int t = 0; t < RX_NB_TH; t++) {
-      UE_rxtx_proc_t *proc = &UE->proc.proc_rxtx[t];
-      pthread_mutex_lock(&proc->mutex_rxtx);
-
-      while (proc->instance_cnt_rxtx >= 0) pthread_cond_wait( &proc->cond_rxtx, &proc->mutex_rxtx );
-
-      pthread_mutex_unlock(&proc->mutex_rxtx);
-    }
-
-#endif
-    LOG_D(PHY,"Process slot %d thread Idx %d \n", slot_nr, UE->current_thread_id[slot_nr]);
-    proc->nr_tti_rx=slot_nr;
-    proc->subframe_rx=table_sf_slot[slot_nr];
-    proc->frame_tx = proc->frame_rx;
-    proc->nr_tti_tx= slot_nr + DURATION_RX_TO_TX;
-
-    if (proc->nr_tti_tx > nb_slot_frame) {
-      proc->frame_tx = (proc->frame_tx + 1)%MAX_FRAME_NUMBER;
-      proc->nr_tti_tx %= nb_slot_frame;
-    }
-
-    if(slot_nr == 0) {
-      UE->proc.proc_rxtx[0].frame_rx++;
-
-      //UE->proc.proc_rxtx[1].frame_rx++;
-      for (th_id=1; th_id < RX_NB_TH; th_id++) {
-        UE->proc.proc_rxtx[th_id].frame_rx = UE->proc.proc_rxtx[0].frame_rx;
-      }
-    }
-
-    if (UE->mode != loop_through_memory) {
-      for (i=0; i<UE->frame_parms.nb_antennas_rx; i++)
-        rxp[i] = (void *)&UE->common_vars.rxdata[i][UE->frame_parms.ofdm_symbol_size+
-                 UE->frame_parms.nb_prefix_samples0+
-                 slot_nr*UE->frame_parms.samples_per_slot];
-
-      for (i=0; i<UE->frame_parms.nb_antennas_tx; i++)
-        txp[i] = (void *)&UE->common_vars.txdata[i][((slot_nr+2)%NR_NUMBER_OF_SUBFRAMES_PER_FRAME)*UE->frame_parms.samples_per_slot];
-
-      int readBlockSize, writeBlockSize;
-
-      if (slot_nr<(nb_slot_frame - 1)) {
-        readBlockSize=UE->frame_parms.samples_per_slot;
-        writeBlockSize=UE->frame_parms.samples_per_slot;
-      } else {
-        UE->rx_offset_diff = computeSamplesShift(UE);
-        readBlockSize=UE->frame_parms.samples_per_slot -
-                      UE->frame_parms.ofdm_symbol_size -
-                      UE->frame_parms.nb_prefix_samples0 -
-                      UE->rx_offset_diff;
-        writeBlockSize=UE->frame_parms.samples_per_slot -
-                       UE->rx_offset_diff;
-      }
-
-      AssertFatal(readBlockSize ==
-                  UE->rfdevice.trx_read_func(&UE->rfdevice,
-                                             &timestamp,
-                                             rxp,
-                                             readBlockSize,
-                                             UE->frame_parms.nb_antennas_rx),"");
-      AssertFatal( writeBlockSize ==
-                   UE->rfdevice.trx_write_func(&UE->rfdevice,
-                       timestamp+
-                       (2*UE->frame_parms.samples_per_slot) -
-                       UE->frame_parms.ofdm_symbol_size-UE->frame_parms.nb_prefix_samples0 -
-                       openair0_cfg[0].tx_sample_advance,
-                       txp,
-                       writeBlockSize,
-                       UE->frame_parms.nb_antennas_tx,
-                       1),"");
-
-      if( slot_nr==(nb_slot_frame-1)) {
-        // read in first symbol of next frame and adjust for timing drift
-        int first_symbols=writeBlockSize-readBlockSize;
-
-        if ( first_symbols > 0 )
-          AssertFatal(first_symbols ==
-                      UE->rfdevice.trx_read_func(&UE->rfdevice,
-                                                 &timestamp,
-                                                 (void **)UE->common_vars.rxdata,
-                                                 first_symbols,
-                                                 UE->frame_parms.nb_antennas_rx),"");
-        else
-          LOG_E(PHY,"can't compensate: diff =%d\n", first_symbols);
-      }
-
-      pickTime(gotIQs);
-      // operate on thread sf mod 2
-      AssertFatal(pthread_mutex_lock(&proc->mutex_rxtx) ==0,"");
-#ifdef SAIF_ENABLED
-
-      if (!(proc->frame_rx%4000)) {
-        printf("frame_rx=%d rx_thread_busy=%ld - rate %8.3f\n",
-               proc->frame_rx, g_ue_rx_thread_busy,
-               (float)g_ue_rx_thread_busy/(proc->frame_rx*10+1)*100.0);
-        fflush(stdout);
-      }
-
-#endif
-
-      //UE->proc.proc_rxtx[0].gotIQs=readTime(gotIQs);
-      //UE->proc.proc_rxtx[1].gotIQs=readTime(gotIQs);
-      for (th_id=0; th_id < RX_NB_TH; th_id++) {
-        UE->proc.proc_rxtx[th_id].gotIQs=readTime(gotIQs);
-      }
-
-      proc->subframe_tx=proc->nr_tti_rx;
-      proc->timestamp_tx = timestamp+
-                           (DURATION_RX_TO_TX*UE->frame_parms.samples_per_slot)-
-                           UE->frame_parms.ofdm_symbol_size-UE->frame_parms.nb_prefix_samples0;
-      proc->instance_cnt_rxtx++;
-      LOG_D( PHY, "[SCHED][UE %d] UE RX instance_cnt_rxtx %d subframe %d !!\n", UE->Mod_id, proc->instance_cnt_rxtx,proc->subframe_rx);
-
-      if (proc->instance_cnt_rxtx != 0) {
-#ifdef SAIF_ENABLED
-        g_ue_rx_thread_busy++;
-#endif
-
-        if ( getenv("RFSIMULATOR") != NULL ) {
-          do {
-            AssertFatal (pthread_mutex_unlock(&proc->mutex_rxtx) == 0, "");
-            usleep(100);
-            AssertFatal (pthread_mutex_lock(&proc->mutex_rxtx) == 0, "");
-          } while ( proc->instance_cnt_rxtx >= 0);
-        } else
-          LOG_E( PHY, "[SCHED][UE %d] !! UE RX thread busy (IC %d)!!\n", UE->Mod_id, proc->instance_cnt_rxtx);
-
-        AssertFatal( proc->instance_cnt_rxtx <= 4, "[SCHED][UE %d] !!! UE instance_cnt_rxtx > 2 (IC %d) (Proc %d)!!",
-                     UE->Mod_id, proc->instance_cnt_rxtx,
-                     UE->current_thread_id[slot_nr]);
-      }
-
-      AssertFatal (pthread_cond_signal(&proc->cond_rxtx) ==0,"");
-      AssertFatal (pthread_mutex_unlock(&proc->mutex_rxtx) ==0,"");
-      //                    initRefTimes(t1);
-      //                    initStaticTime(lastTime);
-      //                    updateTimes(lastTime, &t1, 20000, "Delay between two IQ acquisitions (case 1)");
-      //                    pickStaticTime(lastTime);
-    } //UE->mode != loop_through_memory
-    else {
-      processSubframeRX(UE,proc);
-      getchar();
-    } // else loop_through_memory
-  } // while !oai_exit
-
-  return NULL;
-}
-
-/*!
- * \brief Initialize the UE theads.
- * Creates the UE threads:
- * - UE_thread_rxtx0
- * - UE_thread_rxtx1
- * - UE_thread_synch
- * - UE_thread_fep_slot0
- * - UE_thread_fep_slot1
- * - UE_thread_dlsch_proc_slot0
- * - UE_thread_dlsch_proc_slot1
- * and the locking between them.
- */
-void init_UE_threads(PHY_VARS_NR_UE *UE) {
-  struct nr_rxtx_thread_data *rtd;
-  pthread_attr_init (&UE->proc.attr_ue);
-  pthread_attr_setstacksize(&UE->proc.attr_ue,8192);//5*PTHREAD_STACK_MIN);
-  pthread_mutex_init(&UE->proc.mutex_synch,NULL);
-  pthread_cond_init(&UE->proc.cond_synch,NULL);
-  UE->proc.instance_cnt_synch = -1;
-
-  // the threads are not yet active, therefore access is allowed without locking
-  for (int i=0; i<RX_NB_TH; i++) {
-    rtd = calloc(1, sizeof(struct nr_rxtx_thread_data));
-
-    if (rtd == NULL) abort();
-
-    rtd->UE = UE;
-    rtd->proc = &UE->proc.proc_rxtx[i];
-    pthread_mutex_init(&UE->proc.proc_rxtx[i].mutex_rxtx,NULL);
-    pthread_cond_init(&UE->proc.proc_rxtx[i].cond_rxtx,NULL);
-    UE->proc.proc_rxtx[i].sub_frame_start=i;
-    UE->proc.proc_rxtx[i].sub_frame_step=RX_NB_TH;
-    printf("Init_UE_threads rtd %d proc %d nb_threads %d i %d\n",rtd->proc->sub_frame_start, UE->proc.proc_rxtx[i].sub_frame_start,RX_NB_TH, i);
-    pthread_create(&UE->proc.proc_rxtx[i].pthread_rxtx, NULL, UE_thread_rxn_txnp4, rtd);
-#ifdef UE_DLSCH_PARALLELISATION
-    pthread_mutex_init(&UE->proc.proc_rxtx[i].mutex_dlsch_td,NULL);
-    pthread_cond_init(&UE->proc.proc_rxtx[i].cond_dlsch_td,NULL);
-    pthread_create(&UE->proc.proc_rxtx[i].pthread_dlsch_td,NULL,nr_dlsch_decoding_2thread0, rtd);
-    //thread 2
-    pthread_mutex_init(&UE->proc.proc_rxtx[i].mutex_dlsch_td1,NULL);
-    pthread_cond_init(&UE->proc.proc_rxtx[i].cond_dlsch_td1,NULL);
-    pthread_create(&UE->proc.proc_rxtx[i].pthread_dlsch_td1,NULL,nr_dlsch_decoding_2thread1, rtd);
-#endif
-#ifdef UE_SLOT_PARALLELISATION
-    //pthread_mutex_init(&UE->proc.proc_rxtx[i].mutex_slot0_dl_processing,NULL);
-    //pthread_cond_init(&UE->proc.proc_rxtx[i].cond_slot0_dl_processing,NULL);
-    //pthread_create(&UE->proc.proc_rxtx[i].pthread_slot0_dl_processing,NULL,UE_thread_slot0_dl_processing, rtd);
-    pthread_mutex_init(&UE->proc.proc_rxtx[i].mutex_slot1_dl_processing,NULL);
-    pthread_cond_init(&UE->proc.proc_rxtx[i].cond_slot1_dl_processing,NULL);
-    pthread_create(&UE->proc.proc_rxtx[i].pthread_slot1_dl_processing,NULL,UE_thread_slot1_dl_processing, rtd);
-#endif
-  }
-
-  pthread_create(&UE->proc.pthread_synch,NULL,UE_thread_synch,(void *)UE);
-}
-
-
-#ifdef OPENAIR2
-  /*
-  void fill_ue_band_info(void) {
-
-  UE_EUTRA_Capability_t *UE_EUTRA_Capability = UE_rrc_inst[0].UECap->UE_EUTRA_Capability;
-  int i,j;
-
-  bands_to_scan.nbands = UE_EUTRA_Capability->rf_Parameters.supportedBandListEUTRA.list.count;
-
-  for (i=0; i<bands_to_scan.nbands; i++) {
-
-  for (j=0; j<sizeof (eutra_bands) / sizeof (eutra_bands[0]); j++)
-  if (eutra_bands[j].band == UE_EUTRA_Capability->rf_Parameters.supportedBandListEUTRA.list.array[i]->bandEUTRA) {
-  memcpy(&bands_to_scan.band_info[i],
-  &eutra_bands[j],
-  sizeof(eutra_band_t));
-
-  printf("Band %d (%lu) : DL %u..%u Hz, UL %u..%u Hz, Duplex %s \n",
-  bands_to_scan.band_info[i].band,
-  UE_EUTRA_Capability->rf_Parameters.supportedBandListEUTRA.list.array[i]->bandEUTRA,
-  bands_to_scan.band_info[i].dl_min,
-  bands_to_scan.band_info[i].dl_max,
-  bands_to_scan.band_info[i].ul_min,
-  bands_to_scan.band_info[i].ul_max,
-  (bands_to_scan.band_info[i].frame_type==FDD) ? "FDD" : "TDD");
-  break;
-  }
-  }
-  }*/
-#endif
-
-/*
-int setup_ue_buffers(PHY_VARS_NR_UE **phy_vars_ue, openair0_config_t *openair0_cfg) {
-
-    int i, CC_id;
-    NR_DL_FRAME_PARMS *frame_parms;
-    openair0_rf_map *rf_map;
-
-    for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
-        rf_map = &phy_vars_ue[CC_id]->rf_map;
-
-        AssertFatal( phy_vars_ue[CC_id] !=0, "");
-        frame_parms = &(phy_vars_ue[CC_id]->frame_parms);
-
-        // replace RX signal buffers with mmaped HW versions
-        rxdata = (int32_t**)malloc16( frame_parms->nb_antennas_rx*sizeof(int32_t*) );
-        txdata = (int32_t**)malloc16( frame_parms->nb_antennas_tx*sizeof(int32_t*) );
-
-        for (i=0; i<frame_parms->nb_antennas_rx; i++) {
-            LOG_I(PHY, "Mapping UE CC_id %d, rx_ant %d, freq %u on card %d, chain %d\n",
-                  CC_id, i, downlink_frequency[CC_id][i], rf_map->card, rf_map->chain+i );
-            free( phy_vars_ue[CC_id]->common_vars.rxdata[i] );
-            rxdata[i] = (int32_t*)malloc16_clear( 307200*sizeof(int32_t) );
-            phy_vars_ue[CC_id]->common_vars.rxdata[i] = rxdata[i]; // what about the "-N_TA_offset" ? // N_TA offset for TDD
-        }
-
-        for (i=0; i<frame_parms->nb_antennas_tx; i++) {
-            LOG_I(PHY, "Mapping UE CC_id %d, tx_ant %d, freq %u on card %d, chain %d\n",
-                  CC_id, i, downlink_frequency[CC_id][i], rf_map->card, rf_map->chain+i );
-            free( phy_vars_ue[CC_id]->common_vars.txdata[i] );
-            txdata[i] = (int32_t*)malloc16_clear( 307200*sizeof(int32_t) );
-            phy_vars_ue[CC_id]->common_vars.txdata[i] = txdata[i];
-        }
-
-        // rxdata[x] points now to the same memory region as phy_vars_ue[CC_id]->common_vars.rxdata[x]
-        // txdata[x] points now to the same memory region as phy_vars_ue[CC_id]->common_vars.txdata[x]
-        // be careful when releasing memory!
-        // because no "release_ue_buffers"-function is available, at least rxdata and txdata memory will leak (only some bytes)
-    }
-    return 0;
-}
-*/
diff --git a/targets/RT/USER/nr-uesoftmodem.c b/targets/RT/USER/nr-uesoftmodem.c
deleted file mode 100644
index 4cd2ea06df..0000000000
--- a/targets/RT/USER/nr-uesoftmodem.c
+++ /dev/null
@@ -1,1262 +0,0 @@
-/*
- * 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
- */
-
-
-#define _GNU_SOURCE             /* See feature_test_macros(7) */
-#include <sched.h>
-
-#include "T.h"
-#include "rt_wrapper.h"
-
-#undef MALLOC //there are two conflicting definitions, so we better make sure we don't use it at all
-
-#include "assertions.h"
-#include "msc.h"
-
-#include "PHY/types.h"
-#include "PHY/defs_nr_UE.h"
-#include "common/ran_context.h"
-#include "common/config/config_userapi.h"
-#include "common/utils/load_module_shlib.h"
-#undef MALLOC //there are two conflicting definitions, so we better make sure we don't use it at all
-//#undef FRAME_LENGTH_COMPLEX_SAMPLES //there are two conflicting definitions, so we better make sure we don't use it at all
-
-#include "../../ARCH/COMMON/common_lib.h"
-#include "../../ARCH/ETHERNET/USERSPACE/LIB/if_defs.h"
-
-//#undef FRAME_LENGTH_COMPLEX_SAMPLES //there are two conflicting definitions, so we better make sure we don't use it at all
-
-#include "PHY/phy_vars_nr_ue.h"
-#include "PHY/LTE_TRANSPORT/transport_vars.h"
-#include "SCHED/sched_common_vars.h"
-#include "PHY/MODULATION/modulation_vars.h"
-//#include "../../SIMU/USER/init_lte.h"
-
-#include "LAYER2/MAC/mac.h"
-#include "LAYER2/MAC/mac_vars.h"
-#include "LAYER2/MAC/mac_proto.h"
-#include "RRC/LTE/rrc_vars.h"
-#include "PHY_INTERFACE/phy_interface_vars.h"
-
-#ifdef SMBV
-#include "PHY/TOOLS/smbv.h"
-unsigned short config_frames[4] = {2,9,11,13};
-#endif
-#include "common/utils/LOG/log.h"
-#include "common/utils/LOG/vcd_signal_dumper.h"
-
-#include "UTIL/OPT/opt.h"
-#include "enb_config.h"
-//#include "PHY/TOOLS/time_meas.h"
-
-#ifndef OPENAIR2
-#include "UTIL/OTG/otg_vars.h"
-#endif
-
-#if defined(ENABLE_ITTI)
-#include "intertask_interface.h"
-#include "create_tasks.h"
-#endif
-
-#include "PHY/INIT/phy_init.h"
-#include "system.h"
-#include "stats.h"
-#ifdef XFORMS
-#include "PHY/TOOLS/nr_phy_scope.h"
-//#include "stats.h"
-// current status is that every UE has a DL scope for a SINGLE eNB (eNB_id=0)
-// at eNB 0, an UL scope for every UE
-FD_lte_phy_scope_ue  *form_ue[NUMBER_OF_UE_MAX];
-//FD_lte_phy_scope_enb *form_enb[MAX_NUM_CCs][NUMBER_OF_UE_MAX];
-//FD_stats_form                  *form_stats=NULL,*form_stats_l2=NULL;
-char title[255];
-//unsigned char                   scope_enb_num_ue = 2;
-static pthread_t                forms_thread; //xforms
-#endif //XFORMS
-#include "nr-uesoftmodem.h"
-
-RAN_CONTEXT_t RC;
-
-pthread_cond_t sync_cond;
-pthread_mutex_t sync_mutex;
-int sync_var=-1; //!< protected by mutex \ref sync_mutex.
-
-uint16_t runtime_phy_rx[29][6]; // SISO [MCS 0-28][RBs 0-5 : 6, 15, 25, 50, 75, 100]
-uint16_t runtime_phy_tx[29][6]; // SISO [MCS 0-28][RBs 0-5 : 6, 15, 25, 50, 75, 100]
-
-#if defined(ENABLE_ITTI)
-volatile int             start_eNB = 0;
-volatile int             start_UE = 0;
-#endif
-volatile int             oai_exit = 0;
-
-static clock_source_t clock_source = internal;
-static int wait_for_sync = 0;
-
-unsigned int             mmapped_dma=0;
-int                      single_thread_flag=1;
-
-int                      threequarter_fs=0;
-
-uint32_t                 downlink_frequency[MAX_NUM_CCs][4];
-int32_t                  uplink_frequency_offset[MAX_NUM_CCs][4];
-
-extern int16_t nr_dlsch_demod_shift;
-
-
-//static char                    *conf_config_file_name = NULL;
-
-#if defined(ENABLE_ITTI)
-static char                    *itti_dump_file = NULL;
-#endif
-
-int UE_scan = 0;
-int UE_scan_carrier = 0;
-int UE_fo_compensation = 0;
-runmode_t mode = normal_txrx;
-
-FILE *input_fd=NULL;
-
-
-#if MAX_NUM_CCs == 1
-rx_gain_t                rx_gain_mode[MAX_NUM_CCs][4] = {{max_gain,max_gain,max_gain,max_gain}};
-double tx_gain[MAX_NUM_CCs][4] = {{20,0,0,0}};
-double rx_gain[MAX_NUM_CCs][4] = {{110,0,0,0}};
-#else
-rx_gain_t                rx_gain_mode[MAX_NUM_CCs][4] = {{max_gain,max_gain,max_gain,max_gain},{max_gain,max_gain,max_gain,max_gain}};
-double tx_gain[MAX_NUM_CCs][4] = {{20,0,0,0},{20,0,0,0}};
-double rx_gain[MAX_NUM_CCs][4] = {{110,0,0,0},{20,0,0,0}};
-#endif
-
-double rx_gain_off = 0.0;
-
-double sample_rate=30.72e6;
-double bw = 10.0e6;
-
-static int  tx_max_power[MAX_NUM_CCs] = {0};
-
-char   rf_config_file[1024];
-
-int chain_offset=0;
-int phy_test = 0;
-uint8_t usim_test = 0;
-
-uint8_t dci_Format = 0;
-uint8_t agregation_Level =0xFF;
-
-uint8_t nb_antenna_tx = 1;
-uint8_t nb_antenna_rx = 1;
-
-char ref[128] = "internal";
-char channels[128] = "0";
-
-char *parallel_config = NULL;
-char *worker_config = NULL;
-
-static THREAD_STRUCT thread_struct;
-void set_parallel_conf(char *parallel_conf)
-{
-  if(strcmp(parallel_conf,"PARALLEL_SINGLE_THREAD")==0)           thread_struct.parallel_conf = PARALLEL_SINGLE_THREAD;
-  else if(strcmp(parallel_conf,"PARALLEL_RU_L1_SPLIT")==0)        thread_struct.parallel_conf = PARALLEL_RU_L1_SPLIT;
-  else if(strcmp(parallel_conf,"PARALLEL_RU_L1_TRX_SPLIT")==0)    thread_struct.parallel_conf = PARALLEL_RU_L1_TRX_SPLIT;
-  printf("[CONFIG] parallel conf is set to %d\n",thread_struct.parallel_conf);
-} 
-void set_worker_conf(char *worker_conf)
-{
-  if(strcmp(worker_conf,"WORKER_DISABLE")==0)                     thread_struct.worker_conf = WORKER_DISABLE;
-  else if(strcmp(worker_conf,"WORKER_ENABLE")==0)                 thread_struct.worker_conf = WORKER_ENABLE;
-  printf("[CONFIG] worker conf is set to %d\n",thread_struct.worker_conf);
-} 
-PARALLEL_CONF_t get_thread_parallel_conf(void)
-{
-  return thread_struct.parallel_conf;
-} 
-WORKER_CONF_t get_thread_worker_conf(void)
-{
-  return thread_struct.worker_conf;
-} 
-int                      		rx_input_level_dBm;
-
-//static int                      online_log_messages=0;
-
-#ifdef XFORMS
-extern int                      otg_enabled;
-int                             do_forms=0;
-#else
-int                             otg_enabled;
-#endif
-//int                             number_of_cards =   1;
-
-static NR_DL_FRAME_PARMS      *frame_parms[MAX_NUM_CCs];
-static nfapi_nr_config_request_t *config[MAX_NUM_CCs];
-int16_t   node_synch_ref[MAX_NUM_CCs];
-
-uint32_t target_dl_mcs = 28; //maximum allowed mcs
-uint32_t target_ul_mcs = 20;
-uint32_t timing_advance = 0;
-uint8_t exit_missed_slots=1;
-uint64_t num_missed_slots=0; // counter for the number of missed slots
-
-extern PHY_VARS_NR_UE* init_nr_ue_vars(NR_DL_FRAME_PARMS *frame_parms,
-			  uint8_t UE_id,
-			  uint8_t abstraction_flag);
-
-int transmission_mode=1;
-int numerology = 0;
-
-/*
-int16_t           glog_level         = LOG_INFO;
-int16_t           glog_verbosity     = LOG_MED;
-int16_t           hw_log_level       = LOG_INFO;
-int16_t           hw_log_verbosity   = LOG_MED;
-int16_t           phy_log_level      = LOG_INFO;
-int16_t           phy_log_verbosity  = LOG_MED;
-int16_t           mac_log_level      = LOG_INFO;
-int16_t           mac_log_verbosity  = LOG_MED;
-int16_t           rlc_log_level      = LOG_INFO;
-int16_t           rlc_log_verbosity  = LOG_MED;
-int16_t           pdcp_log_level     = LOG_INFO;
-int16_t           pdcp_log_verbosity = LOG_MED;
-int16_t           rrc_log_level      = LOG_INFO;
-int16_t           rrc_log_verbosity  = LOG_MED;
-int16_t           opt_log_level      = LOG_INFO;
-int16_t           opt_log_verbosity  = LOG_MED;
-
-# if defined(ENABLE_USE_MME)
-int16_t           gtpu_log_level     = LOG_DEBUG;
-int16_t           gtpu_log_verbosity = LOG_MED;
-int16_t           udp_log_level      = LOG_DEBUG;
-int16_t           udp_log_verbosity  = LOG_MED;
-#endif
-#if defined (ENABLE_SECURITY)
-int16_t           osa_log_level      = LOG_INFO;
-int16_t           osa_log_verbosity  = LOG_MED;
-#endif
-*/
-
-char *rrh_UE_ip = "127.0.0.1";
-int rrh_UE_port = 51000;
-
-/* flag set by eNB conf file to specify if the radio head is local or remote (default option is local) */
-//uint8_t local_remote_radio = BBU_LOCAL_RADIO_HEAD;
-/* struct for ethernet specific parameters given in eNB conf file */
-//eth_params_t *eth_params;
-
-openair0_config_t openair0_cfg[MAX_CARDS];
-
-double cpuf;
-
-char uecap_xer[1024],uecap_xer_in=0;
-
-int oaisim_flag=0;
-int emulate_rf = 0;
-
-threads_t threads = {-1,-1,-1,-1,-1,-1,-1,-1};
-int threads_offset = 0;
-
-char* usrp_args=NULL;
-char* usrp_clksrc=NULL;
-
-/* forward declarations */
-void set_default_frame_parms(NR_DL_FRAME_PARMS *frame_parms[MAX_NUM_CCs]);
-
-
-/* see file openair2/LAYER2/MAC/main.c for why abstraction_flag is needed
- * this is very hackish - find a proper solution
- */
-uint8_t abstraction_flag=0;
-
-/*---------------------BMC: timespec helpers -----------------------------*/
-
-struct timespec min_diff_time = { .tv_sec = 0, .tv_nsec = 0 };
-struct timespec max_diff_time = { .tv_sec = 0, .tv_nsec = 0 };
-
-struct timespec clock_difftime(struct timespec start, struct timespec end) {
-    struct timespec temp;
-    if ((end.tv_nsec-start.tv_nsec)<0) {
-        temp.tv_sec = end.tv_sec-start.tv_sec-1;
-        temp.tv_nsec = 1000000000+end.tv_nsec-start.tv_nsec;
-    } else {
-        temp.tv_sec = end.tv_sec-start.tv_sec;
-        temp.tv_nsec = end.tv_nsec-start.tv_nsec;
-    }
-    return temp;
-}
-
-void print_difftimes(void) {
-#ifdef DEBUG
-    printf("difftimes min = %lu ns ; max = %lu ns\n", min_diff_time.tv_nsec, max_diff_time.tv_nsec);
-#else
-    LOG_I(HW,"difftimes min = %lu ns ; max = %lu ns\n", min_diff_time.tv_nsec, max_diff_time.tv_nsec);
-#endif
-}
-
-void update_difftimes(struct timespec start, struct timespec end) {
-    struct timespec diff_time = { .tv_sec = 0, .tv_nsec = 0 };
-    int             changed = 0;
-    diff_time = clock_difftime(start, end);
-    if ((min_diff_time.tv_nsec == 0) || (diff_time.tv_nsec < min_diff_time.tv_nsec)) {
-        min_diff_time.tv_nsec = diff_time.tv_nsec;
-        changed = 1;
-    }
-    if ((max_diff_time.tv_nsec == 0) || (diff_time.tv_nsec > max_diff_time.tv_nsec)) {
-        max_diff_time.tv_nsec = diff_time.tv_nsec;
-        changed = 1;
-    }
-#if 1
-    if (changed) print_difftimes();
-#endif
-}
-
-/*------------------------------------------------------------------------*/
-
-unsigned int build_rflocal(int txi, int txq, int rxi, int rxq) {
-    return (txi + (txq<<6) + (rxi<<12) + (rxq<<18));
-}
-unsigned int build_rfdc(int dcoff_i_rxfe, int dcoff_q_rxfe) {
-    return (dcoff_i_rxfe + (dcoff_q_rxfe<<8));
-}
-
-#if !defined(ENABLE_ITTI)
-void signal_handler(int sig) {
-    void *array[10];
-    size_t size;
-
-    if (sig==SIGSEGV) {
-        // get void*'s for all entries on the stack
-        size = backtrace(array, 10);
-
-        // print out all the frames to stderr
-        fprintf(stderr, "Error: signal %d:\n", sig);
-        backtrace_symbols_fd(array, size, 2);
-        exit(-1);
-    } else {
-        printf("trying to exit gracefully...\n");
-        oai_exit = 1;
-    }
-}
-#endif
-#define KNRM  "\x1B[0m"
-#define KRED  "\x1B[31m"
-#define KGRN  "\x1B[32m"
-#define KBLU  "\x1B[34m"
-#define RESET "\033[0m"
-
-
-void exit_function(const char* file, const char* function, const int line, const char* s)
-{
-
-  int CC_id;
-
-  if (s != NULL) {
-    printf("%s:%d %s() Exiting OAI softmodem: %s\n",file,line, function, s);
-  }
-
-    oai_exit = 1;
-
-    if (PHY_vars_UE_g && PHY_vars_UE_g[0]) {
-      for(CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
-	if (PHY_vars_UE_g[0][CC_id] && PHY_vars_UE_g[0][CC_id]->rfdevice.trx_end_func)
-	  PHY_vars_UE_g[0][CC_id]->rfdevice.trx_end_func(&PHY_vars_UE_g[0][CC_id]->rfdevice);
-      }
-    }
-
-#if defined(ENABLE_ITTI)
-    sleep(1); //allow lte-softmodem threads to exit first
-    itti_terminate_tasks (TASK_UNKNOWN);
-#endif
-}
-
-#ifdef XFORMS
-
-
-void reset_stats(FL_OBJECT *button, long arg) {
-    //int i,j,k;
-    /*PHY_VARS_eNB *phy_vars_eNB = PHY_vars_eNB_g[0][0];
-
-    for (i=0; i<NUMBER_OF_UE_MAX; i++) {
-        for (k=0; k<8; k++) { //harq_processes
-            for (j=0; j<phy_vars_eNB->dlsch[i][0]->Mlimit; j++) {
-                phy_vars_eNB->UE_stats[i].dlsch_NAK[k][j]=0;
-                phy_vars_eNB->UE_stats[i].dlsch_ACK[k][j]=0;
-                phy_vars_eNB->UE_stats[i].dlsch_trials[k][j]=0;
-            }
-
-            phy_vars_eNB->UE_stats[i].dlsch_l2_errors[k]=0;
-            phy_vars_eNB->UE_stats[i].ulsch_errors[k]=0;
-            phy_vars_eNB->UE_stats[i].ulsch_consecutive_errors=0;
-
-            for (j=0; j<phy_vars_eNB->ulsch[i]->Mlimit; j++) {
-                phy_vars_eNB->UE_stats[i].ulsch_decoding_attempts[k][j]=0;
-                phy_vars_eNB->UE_stats[i].ulsch_decoding_attempts_last[k][j]=0;
-                phy_vars_eNB->UE_stats[i].ulsch_round_errors[k][j]=0;
-                phy_vars_eNB->UE_stats[i].ulsch_round_fer[k][j]=0;
-            }
-        }
-
-        phy_vars_eNB->UE_stats[i].dlsch_sliding_cnt=0;
-        phy_vars_eNB->UE_stats[i].dlsch_NAK_round0=0;
-        phy_vars_eNB->UE_stats[i].dlsch_mcs_offset=0;
-    }*/
-}
-
-static void *scope_thread(void *arg) {
-    char stats_buffer[16384];
-# ifdef ENABLE_XFORMS_WRITE_STATS
-    FILE *UE_stats, *eNB_stats;
-# endif
-    //int len = 0;
-    struct sched_param sched_param;
-    //int UE_id, CC_id;
-    //int ue_cnt=0;
-
-    sched_param.sched_priority = sched_get_priority_min(SCHED_FIFO)+1;
-    sched_setscheduler(0, SCHED_FIFO,&sched_param);
-
-    printf("Scope thread has priority %d\n",sched_param.sched_priority);
-
-# ifdef ENABLE_XFORMS_WRITE_STATS
-
-  UE_stats  = fopen("UE_stats.txt", "w");
-
-#endif
-
-  while (!oai_exit) {
-      //len = dump_ue_stats (PHY_vars_UE_g[0][0], &PHY_vars_UE_g[0][0]->proc.proc_rxtx[0],stats_buffer, 0, mode,rx_input_level_dBm);
-      //fl_set_object_label(form_stats->stats_text, stats_buffer);
-      //fl_clear_browser(form_stats->stats_text);
-      //fl_add_browser_line(form_stats->stats_text, stats_buffer);
-      
-      //if (PHY_vars_UE_g[0][0]->is_synchronized == 1)
-	phy_scope_UE(form_ue[0],
-		     PHY_vars_UE_g[0][0],
-		     0,0,1);
-      //else it is done in the synch thread
-      
-      //printf("doing forms\n");
-      //usleep(100000); // 100 ms
-      sleep(0.1);
-    }
-
-    //  printf("%s",stats_buffer);
-
-# ifdef ENABLE_XFORMS_WRITE_STATS
-
-        if (UE_stats) {
-            rewind (UE_stats);
-            fwrite (stats_buffer, 1, len, UE_stats);
-            fclose (UE_stats);
-        }
-
-# endif
-
-    pthread_exit((void*)arg);
-}
-#endif
-
-
-
-
-#if defined(ENABLE_ITTI)
-void *l2l1_task(void *arg) {
-    MessageDef *message_p = NULL;
-    int         result;
-
-    itti_set_task_real_time(TASK_L2L1);
-    itti_mark_task_ready(TASK_L2L1);
-
-
-  do {
-    // Wait for a message
-    itti_receive_msg (TASK_L2L1, &message_p);
-
-    switch (ITTI_MSG_ID(message_p)) {
-    case TERMINATE_MESSAGE:
-            oai_exit=1;
-            itti_exit_task ();
-            break;
-
-        case ACTIVATE_MESSAGE:
-            start_UE = 1;
-            break;
-
-        case DEACTIVATE_MESSAGE:
-            start_UE = 0;
-            break;
-
-        case MESSAGE_TEST:
-            LOG_I(EMU, "Received %s\n", ITTI_MSG_NAME(message_p));
-            break;
-
-        default:
-            LOG_E(EMU, "Received unexpected message %s\n", ITTI_MSG_NAME(message_p));
-            break;
-        }
-
-        result = itti_free (ITTI_MSG_ORIGIN_ID(message_p), message_p);
-        AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result);
-    } while(!oai_exit);
-
-    return NULL;
-}
-#endif
-
-int16_t dlsch_demod_shift;
-
-static void get_options(void) {
-  int CC_id;
-  int tddflag, nonbiotflag;
-  char *loopfile=NULL;
-  int dumpframe=0;
-  uint32_t online_log_messages;
-  uint32_t glog_level, glog_verbosity;
-  uint32_t start_telnetsrv;
-
-  paramdef_t cmdline_params[] =CMDLINE_PARAMS_DESC ;
-  paramdef_t cmdline_logparams[] =CMDLINE_LOGPARAMS_DESC ;
-
-  config_process_cmdline( cmdline_params,sizeof(cmdline_params)/sizeof(paramdef_t),NULL); 
-
-  if (strlen(in_path) > 0) {
-      opt_type = OPT_PCAP;
-      opt_enabled=1;
-      printf("Enabling OPT for PCAP  with the following file %s \n",in_path);
-  }
-  if (strlen(in_ip) > 0) {
-      opt_enabled=1;
-      opt_type = OPT_WIRESHARK;
-      printf("Enabling OPT for wireshark for local interface");
-  }
-
-  config_process_cmdline( cmdline_logparams,sizeof(cmdline_logparams)/sizeof(paramdef_t),NULL);
-  if(config_isparamset(cmdline_logparams,CMDLINE_ONLINELOG_IDX)) {
-      set_glog_onlinelog(online_log_messages);
-  }
-  if(config_isparamset(cmdline_logparams,CMDLINE_GLOGLEVEL_IDX)) {
-    set_glog(glog_level);
-  }
-
-  if (start_telnetsrv) {
-    load_module_shlib("telnetsrv",NULL,0,NULL);
-  }
-
-  paramdef_t cmdline_uemodeparams[] =CMDLINE_UEMODEPARAMS_DESC;
-  paramdef_t cmdline_ueparams[] =CMDLINE_UEPARAMS_DESC;
-
-
-  config_process_cmdline( cmdline_uemodeparams,sizeof(cmdline_uemodeparams)/sizeof(paramdef_t),NULL);
-  config_process_cmdline( cmdline_ueparams,sizeof(cmdline_ueparams)/sizeof(paramdef_t),NULL);
-  if (loopfile != NULL) {
-      printf("Input file for hardware emulation: %s\n",loopfile);
-      mode=loop_through_memory;
-      input_fd = fopen(loopfile,"r");
-      AssertFatal(input_fd != NULL,"Please provide a valid input file\n");
-  }
-
-  if ( (cmdline_uemodeparams[CMDLINE_CALIBUERX_IDX].paramflags &  PARAMFLAG_PARAMSET) != 0) mode = rx_calib_ue;
-  if ( (cmdline_uemodeparams[CMDLINE_CALIBUERXMED_IDX].paramflags &  PARAMFLAG_PARAMSET) != 0) mode = rx_calib_ue_med;
-  if ( (cmdline_uemodeparams[CMDLINE_CALIBUERXBYP_IDX].paramflags &  PARAMFLAG_PARAMSET) != 0) mode = rx_calib_ue_byp;
-  if (cmdline_uemodeparams[CMDLINE_DEBUGUEPRACH_IDX].uptr)
-      if ( *(cmdline_uemodeparams[CMDLINE_DEBUGUEPRACH_IDX].uptr) > 0) mode = debug_prach;
-  if (cmdline_uemodeparams[CMDLINE_NOL2CONNECT_IDX].uptr)
-      if ( *(cmdline_uemodeparams[CMDLINE_NOL2CONNECT_IDX].uptr) > 0)  mode = no_L2_connect;
-  if (cmdline_uemodeparams[CMDLINE_CALIBPRACHTX_IDX].uptr) 
-      if ( *(cmdline_uemodeparams[CMDLINE_CALIBPRACHTX_IDX].uptr) > 0) mode = calib_prach_tx; 
-  if (dumpframe  > 0)  mode = rx_dump_frame;
-  
-  for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
-    frame_parms[CC_id]->dl_CarrierFreq = downlink_frequency[0][0];
-  }
-  UE_scan=0;
-   
-
-  if (tddflag > 0) {
-     for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) 
-    	 frame_parms[CC_id]->frame_type = TDD;
-  }
-
-  /*if (frame_parms[0]->N_RB_DL !=0) {
-      if ( frame_parms[0]->N_RB_DL < 6 ) {
-    	 frame_parms[0]->N_RB_DL = 6;
-    	 printf ( "%i: Invalid number of ressource blocks, adjusted to 6\n",frame_parms[0]->N_RB_DL);
-      }
-      if ( frame_parms[0]->N_RB_DL > 100 ) {
-    	 frame_parms[0]->N_RB_DL = 100;
-    	 printf ( "%i: Invalid number of ressource blocks, adjusted to 100\n",frame_parms[0]->N_RB_DL);
-      }
-      if ( frame_parms[0]->N_RB_DL > 50 && frame_parms[0]->N_RB_DL < 100 ) {
-    	 frame_parms[0]->N_RB_DL = 50;
-    	 printf ( "%i: Invalid number of ressource blocks, adjusted to 50\n",frame_parms[0]->N_RB_DL);
-      }
-      if ( frame_parms[0]->N_RB_DL > 25 && frame_parms[0]->N_RB_DL < 50 ) {
-    	 frame_parms[0]->N_RB_DL = 25;
-    	 printf ( "%i: Invalid number of ressource blocks, adjusted to 25\n",frame_parms[0]->N_RB_DL);
-      }
-      UE_scan = 0;
-      frame_parms[0]->N_RB_UL=frame_parms[0]->N_RB_DL;
-      for (CC_id=1; CC_id<MAX_NUM_CCs; CC_id++) {
-    	  frame_parms[CC_id]->N_RB_DL=frame_parms[0]->N_RB_DL;
-    	  frame_parms[CC_id]->N_RB_UL=frame_parms[0]->N_RB_UL;
-      }
-  }*/
-
-
-  for (CC_id=1;CC_id<MAX_NUM_CCs;CC_id++) {
-    	tx_max_power[CC_id]=tx_max_power[0];
-    	rx_gain[0][CC_id] = rx_gain[0][0];
-    	tx_gain[0][CC_id] = tx_gain[0][0];
-  }
-
-#if T_TRACER
-  paramdef_t cmdline_ttraceparams[] =CMDLINE_TTRACEPARAMS_DESC ;
-  config_process_cmdline( cmdline_ttraceparams,sizeof(cmdline_ttraceparams)/sizeof(paramdef_t),NULL);   
-#endif
-
-  if ( !(CONFIG_ISFLAGSET(CONFIG_ABORT))  && (!(CONFIG_ISFLAGSET(CONFIG_NOOOPT))) ) {
-    // Here the configuration file is the XER encoded UE capabilities
-    // Read it in and store in asn1c data structures
-    sprintf(uecap_xer,"%stargets/PROJECTS/GENERIC-LTE-EPC/CONF/UE_config.xml",getenv("OPENAIR_HOME"));
-    printf("%s\n",uecap_xer);
-    uecap_xer_in=1;
-  } /* UE with config file  */
-
-}
-
-#if T_TRACER
-int T_nowait = 0;       /* by default we wait for the tracer */
-int T_port = 2021;    /* default port to listen to to wait for the tracer */
-int T_dont_fork = 0;  /* default is to fork, see 'T_init' to understand */
-#endif
-
-void set_default_frame_parms(NR_DL_FRAME_PARMS *frame_parms[MAX_NUM_CCs]) {
-
-  int CC_id;
-
-  for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
-        frame_parms[CC_id] = (NR_DL_FRAME_PARMS*) malloc(sizeof(NR_DL_FRAME_PARMS));
-        /* Set some default values that may be overwritten while reading options */
-        frame_parms[CC_id] = (NR_DL_FRAME_PARMS*) malloc(sizeof(NR_DL_FRAME_PARMS));
-        config[CC_id] = (nfapi_nr_config_request_t*) malloc(sizeof(nfapi_nr_config_request_t));
-        config[CC_id]->subframe_config.numerology_index_mu.value =1;
-        config[CC_id]->subframe_config.duplex_mode.value = 1; //FDD
-        config[CC_id]->subframe_config.dl_cyclic_prefix_type.value = 0; //NORMAL
-        config[CC_id]->rf_config.dl_carrier_bandwidth.value = 106;
-        config[CC_id]->rf_config.ul_carrier_bandwidth.value = 106;
-        config[CC_id]->sch_config.physical_cell_id.value = 0;
-
-        frame_parms[CC_id]->frame_type          = FDD;
-        frame_parms[CC_id]->tdd_config          = 3;
-        //frame_parms[CC_id]->tdd_config_S        = 0;
-        frame_parms[CC_id]->N_RB_DL             = 106;
-        frame_parms[CC_id]->N_RB_UL             = 106;
-        frame_parms[CC_id]->Ncp                 = NORMAL;
-        //frame_parms[CC_id]->Ncp_UL              = NORMAL;
-        frame_parms[CC_id]->Nid_cell            = 0;
-        //frame_parms[CC_id]->num_MBSFN_config    = 0;
-        frame_parms[CC_id]->nb_antenna_ports_eNB  = 1;
-        frame_parms[CC_id]->nb_antennas_tx      = 1;
-        frame_parms[CC_id]->nb_antennas_rx      = 1;
-
-        //frame_parms[CC_id]->nushift             = 0;
-
-        ///frame_parms[CC_id]->phich_config_common.phich_resource = oneSixth;
-        //frame_parms[CC_id]->phich_config_common.phich_duration = normal;
-
-	// UL RS Config
-        /*frame_parms[CC_id]->pusch_config_common.ul_ReferenceSignalsPUSCH.cyclicShift = 1;//n_DMRS1 set to 0
-        frame_parms[CC_id]->pusch_config_common.ul_ReferenceSignalsPUSCH.groupHoppingEnabled = 1;
-        frame_parms[CC_id]->pusch_config_common.ul_ReferenceSignalsPUSCH.sequenceHoppingEnabled = 0;
-        frame_parms[CC_id]->pusch_config_common.ul_ReferenceSignalsPUSCH.groupAssignmentPUSCH = 0;
-
-	frame_parms[CC_id]->pusch_config_common.n_SB = 1;
-	frame_parms[CC_id]->pusch_config_common.hoppingMode = 0;
-	frame_parms[CC_id]->pusch_config_common.pusch_HoppingOffset = 0;
-	frame_parms[CC_id]->pusch_config_common.enable64QAM = 0;
-		
-        frame_parms[CC_id]->prach_config_common.rootSequenceIndex=22;
-        frame_parms[CC_id]->prach_config_common.prach_ConfigInfo.zeroCorrelationZoneConfig=1;
-        frame_parms[CC_id]->prach_config_common.prach_ConfigInfo.prach_ConfigIndex=0;
-        frame_parms[CC_id]->prach_config_common.prach_ConfigInfo.highSpeedFlag=0;
-        frame_parms[CC_id]->prach_config_common.prach_ConfigInfo.prach_FreqOffset=0;*/
-
-        // NR: Init to legacy LTE 20Mhz params
-        frame_parms[CC_id]->numerology_index	= 0;
-        frame_parms[CC_id]->ttis_per_subframe	= 1;
-        frame_parms[CC_id]->slots_per_tti		= 2;
-
-    }
-
-}
-
-void init_openair0(void);
-void init_openair0() {
-
-    int card;
-    int i;
-
-    for (card=0; card<MAX_CARDS; card++) {
-
-        openair0_cfg[card].mmapped_dma=mmapped_dma;
-        openair0_cfg[card].configFilename = NULL;
-
-        if(frame_parms[0]->N_RB_DL == 106) {
-	  if (numerology==0) {
-            if (frame_parms[0]->threequarter_fs) {
-                openair0_cfg[card].sample_rate=23.04e6;
-                openair0_cfg[card].samples_per_frame = 230400;
-                openair0_cfg[card].tx_bw = 10e6;
-                openair0_cfg[card].rx_bw = 10e6;
-            } else {
-                openair0_cfg[card].sample_rate=30.72e6;
-                openair0_cfg[card].samples_per_frame = 307200;
-                openair0_cfg[card].tx_bw = 10e6;
-                openair0_cfg[card].rx_bw = 10e6;
-            }
-	  } else if (numerology==1) {
-	    openair0_cfg[card].sample_rate=61.44e6;
-	    openair0_cfg[card].samples_per_frame = 307200;
-	    openair0_cfg[card].tx_bw = 20e6;
-	    openair0_cfg[card].rx_bw = 20e6;
-	  } else if (numerology==2) {
-	    openair0_cfg[card].sample_rate=122.88e6;
-	    openair0_cfg[card].samples_per_frame = 307200;
-	    openair0_cfg[card].tx_bw = 40e6;
-	    openair0_cfg[card].rx_bw = 40e6;
-	  } else {
-	    LOG_E(PHY,"Unsupported numerology!\n");
-	    exit(-1);
-	  }
-        } else if(frame_parms[0]->N_RB_DL == 50) {
-            openair0_cfg[card].sample_rate=15.36e6;
-            openair0_cfg[card].samples_per_frame = 153600;
-            openair0_cfg[card].tx_bw = 5e6;
-            openair0_cfg[card].rx_bw = 5e6;
-        } else if (frame_parms[0]->N_RB_DL == 25) {
-            openair0_cfg[card].sample_rate=7.68e6;
-            openair0_cfg[card].samples_per_frame = 76800;
-            openair0_cfg[card].tx_bw = 2.5e6;
-            openair0_cfg[card].rx_bw = 2.5e6;
-        } else if (frame_parms[0]->N_RB_DL == 6) {
-            openair0_cfg[card].sample_rate=1.92e6;
-            openair0_cfg[card].samples_per_frame = 19200;
-            openair0_cfg[card].tx_bw = 1.5e6;
-            openair0_cfg[card].rx_bw = 1.5e6;
-        }
-
-	if (frame_parms[0]->frame_type==TDD)
-	  openair0_cfg[card].duplex_mode = duplex_mode_TDD;
-	else //FDD
-	  openair0_cfg[card].duplex_mode = duplex_mode_FDD;
-	
-	printf("HW: Configuring card %d, nb_antennas_tx/rx %d/%d\n",card,
-	       PHY_vars_UE_g[0][0]->frame_parms.nb_antennas_tx,
-	       PHY_vars_UE_g[0][0]->frame_parms.nb_antennas_rx);
-	openair0_cfg[card].Mod_id = 0;
-	
-	openair0_cfg[card].num_rb_dl=frame_parms[0]->N_RB_DL;
-	
-	openair0_cfg[card].clock_source = clock_source;
-	
-	
-	openair0_cfg[card].tx_num_channels=min(2,PHY_vars_UE_g[0][0]->frame_parms.nb_antennas_tx);
-	openair0_cfg[card].rx_num_channels=min(2,PHY_vars_UE_g[0][0]->frame_parms.nb_antennas_rx);
-
-	for (i=0; i<4; i++) {
-	  
-	  if (i<openair0_cfg[card].tx_num_channels)
-	    openair0_cfg[card].tx_freq[i] = downlink_frequency[0][i]+uplink_frequency_offset[0][i];
-	  else
-	    openair0_cfg[card].tx_freq[i]=0.0;
-	  
-	  if (i<openair0_cfg[card].rx_num_channels)
-	    openair0_cfg[card].rx_freq[i] = downlink_frequency[0][i];
-	  else
-	    openair0_cfg[card].rx_freq[i]=0.0;
-	  
-	  openair0_cfg[card].autocal[i] = 1;
-	  openair0_cfg[card].tx_gain[i] = tx_gain[0][i];
-	  openair0_cfg[card].rx_gain[i] = PHY_vars_UE_g[0][0]->rx_total_gain_dB - rx_gain_off;
-	  
-	  
-	  openair0_cfg[card].configFilename = rf_config_file;
-	  printf("Card %d, channel %d, Setting tx_gain %f, rx_gain %f, tx_freq %f, rx_freq %f\n",
-		 card,i, openair0_cfg[card].tx_gain[i],
-		 openair0_cfg[card].rx_gain[i],
-		 openair0_cfg[card].tx_freq[i],
-		 openair0_cfg[card].rx_freq[i]);
-	}
-	
-	if (usrp_args) openair0_cfg[card].sdr_addrs = usrp_args;
-	if (usrp_clksrc) {
-	  if (strcmp(usrp_clksrc, "internal") == 0) {
-	    openair0_cfg[card].clock_source = internal;
-	    LOG_D(PHY, "USRP clock source set as internal\n");
-	  } else if (strcmp(usrp_clksrc, "external") == 0) {
-	    openair0_cfg[card].clock_source = external;
-	    LOG_D(PHY, "USRP clock source set as external\n");
-	  } else if (strcmp(usrp_clksrc, "gpsdo") == 0) {
-	    openair0_cfg[card].clock_source = gpsdo;
-	    LOG_D(PHY, "USRP clock source set as gpsdo\n");
-	  } else {
-	    openair0_cfg[card].clock_source = internal;
-	    LOG_I(PHY, "USRP clock source unknown ('%s'). defaulting to internal\n", usrp_clksrc);	
-	  }
-	} else {
-	  openair0_cfg[card].clock_source = internal;
-	  LOG_I(PHY, "USRP clock source not specified. defaulting to internal\n");	
-	}
-	
-    }
-}
-
-int main( int argc, char **argv ) {
-    int i;//j,k,aa,re;
-#if defined (XFORMS)
-    void *status;
-#endif
-
-    int CC_id;
-    uint8_t  abstraction_flag=0;
-    //uint8_t beta_ACK=0,beta_RI=0,beta_CQI=2;
-
-#if defined (XFORMS)
-    int ret;
-#endif
-
-    PHY_VARS_NR_UE *UE[MAX_NUM_CCs];
-
-    start_background_system();
-    if ( load_configmodule(argc,argv) == NULL) {
-      exit_fun("[SOFTMODEM] Error, configuration module init failed\n");
-    }
-    CONFIG_SETRTFLAG(CONFIG_NOEXITONHELP);
- 
-#ifdef DEBUG_CONSOLE
-    setvbuf(stdout, NULL, _IONBF, 0);
-    setvbuf(stderr, NULL, _IONBF, 0);
-#endif
-
-    set_default_frame_parms(frame_parms);
-
-    mode = normal_txrx;
-    memset(&openair0_cfg[0],0,sizeof(openair0_config_t)*MAX_CARDS);
-
-    memset(tx_max_power,0,sizeof(int)*MAX_NUM_CCs);
-
-    set_latency_target();
-
-    // initialize logging
-    logInit();
-
-
-    // get options and fill parameters from configuration file
-    get_options (); //Command-line options, enb_properties
-
-#if T_TRACER
-    T_Config_Init();
-#endif
-
-    //randominit (0);
-    set_taus_seed (0);
-
-    printf("configuring for UE\n");
-
-    //if (ouput_vcd)
-    //    VCD_SIGNAL_DUMPER_INIT("/tmp/openair_dump_UE.vcd");
-
-    //if (opp_enabled ==1) {
-    //    reset_opp_meas();
-    //}
-    cpuf=get_cpu_freq_GHz();
-
-#if defined(ENABLE_ITTI)
-    //log_set_instance_type (LOG_INSTANCE_UE);
-
-    itti_init(TASK_MAX, THREAD_MAX, MESSAGES_ID_MAX, tasks_info, messages_info);
-
-    // initialize mscgen log after ITTI
-    MSC_INIT(MSC_E_UTRAN, THREAD_MAX+TASK_MAX);
-#endif
-
-    if (opt_type != OPT_NONE) {
-        if (init_opt(in_path, in_ip) == -1)
-            LOG_E(OPT,"failed to run OPT \n");
-    }
-
-#ifdef PDCP_USE_NETLINK
-    netlink_init();
-#if defined(PDCP_USE_NETLINK_QUEUES)
-    pdcp_netlink_init();
-#endif
-#endif
-
-#if !defined(ENABLE_ITTI)
-    // to make a graceful exit when ctrl-c is pressed
-    signal(SIGSEGV, signal_handler);
-    signal(SIGINT, signal_handler);
-#endif
-
-
-  check_clock();
-
-#ifndef PACKAGE_VERSION
-#  define PACKAGE_VERSION "UNKNOWN-EXPERIMENTAL"
-#endif
-
-  LOG_I(HW, "Version: %s\n", PACKAGE_VERSION);
-  
-  // init the parameters
-  for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
-
-      frame_parms[CC_id]->nb_antennas_tx     = nb_antenna_tx;
-      frame_parms[CC_id]->nb_antennas_rx     = nb_antenna_rx;
-      frame_parms[CC_id]->nb_antenna_ports_eNB = 1; //initial value overwritten by initial sync later
-
-      LOG_I(PHY,"Set nb_rx_antenna %d , nb_tx_antenna %d \n",frame_parms[CC_id]->nb_antennas_rx, frame_parms[CC_id]->nb_antennas_tx);
-  
-    //init_ul_hopping(frame_parms[CC_id]);
-    //phy_init_nr_top(frame_parms[CC_id]);
-  }
-
-  for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
-        //init prach for openair1 test
-        // prach_fmt = get_prach_fmt(frame_parms->prach_config_common.prach_ConfigInfo.prach_ConfigIndex, frame_parms->frame_type);
-        // N_ZC = (prach_fmt <4)?839:139;
-  }
-
-  NB_UE_INST=1;
-  NB_INST=1;
-  PHY_vars_UE_g = malloc(sizeof(PHY_VARS_NR_UE**));
-  PHY_vars_UE_g[0] = malloc(sizeof(PHY_VARS_NR_UE*)*MAX_NUM_CCs);
-  
-  for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
-    printf("PHY_vars_UE_g[0][%d] = %p\n",CC_id,UE[CC_id]);
-    
-    printf("frame_parms %d\n",frame_parms[CC_id]->ofdm_symbol_size);
-
-    nr_init_frame_parms_ue(frame_parms[CC_id],numerology,NORMAL,frame_parms[CC_id]->N_RB_DL,(frame_parms[CC_id]->N_RB_DL-20)>>1,0);
-    PHY_vars_UE_g[0][CC_id] = init_nr_ue_vars(frame_parms[CC_id], 0,abstraction_flag);
-    UE[CC_id] = PHY_vars_UE_g[0][CC_id];
-    
-    if (phy_test==1)
-      UE[CC_id]->mac_enabled = 0;
-    else
-      UE[CC_id]->mac_enabled = 1;
-    
-    if (UE[CC_id]->mac_enabled == 0) {  //set default UL parameters for testing mode
-      for (i=0; i<NUMBER_OF_CONNECTED_eNB_MAX; i++) {
-	//UE[CC_id]->pusch_config_dedicated[i] = malloc(sizeof(PUSCH_CONFIG_DEDICATED));
-	
-	//UE[CC_id]->scheduling_request_config[i] = malloc(sizeof(SCHEDULING_REQUEST_CONFIG));
-	
-	/*UE[CC_id]->pusch_config_dedicated[i].betaOffset_ACK_Index = beta_ACK;
-	  UE[CC_id]->pusch_config_dedicated[i].betaOffset_RI_Index  = beta_RI;
-	  UE[CC_id]->pusch_config_dedicated[i].betaOffset_CQI_Index = beta_CQI;
-	  
-	  UE[CC_id]->scheduling_request_config[i].sr_PUCCH_ResourceIndex = 0;
-	  UE[CC_id]->scheduling_request_config[i].sr_ConfigIndex = 7+(0%3);
-	  UE[CC_id]->scheduling_request_config[i].dsr_TransMax = sr_n4;*/
-      }
-    }
-    
-    UE[CC_id]->UE_scan = UE_scan;
-    UE[CC_id]->UE_scan_carrier = UE_scan_carrier;
-    UE[CC_id]->UE_fo_compensation = UE_fo_compensation;
-    UE[CC_id]->mode    = mode;
-    printf("UE[%d]->mode = %d\n",CC_id,mode);
-    
-    for (uint8_t i=0; i<RX_NB_TH_MAX; i++) {
-      //UE[CC_id]->pdcch_vars[i][0]->agregationLevel = agregation_Level;
-      //UE[CC_id]->pdcch_vars[i][0]->dciFormat     = dci_Format;
-    
-    /*compute_prach_seq(&UE[CC_id]->frame_parms.prach_config_common,
-      UE[CC_id]->frame_parms.frame_type,
-      UE[CC_id]->X_u);*/
-    
-    if (UE[CC_id]->mac_enabled == 1)
-	UE[CC_id]->pdcch_vars[i][0]->crnti = 0x1234;
-    else
-	UE[CC_id]->pdcch_vars[i][0]->crnti = 0x1235;
-    }
-    
-    UE[CC_id]->rx_total_gain_dB =  (int)rx_gain[CC_id][0] + rx_gain_off;
-    UE[CC_id]->tx_power_max_dBm = tx_max_power[CC_id];
-    
-    if (frame_parms[CC_id]->frame_type==FDD) {
-      UE[CC_id]->N_TA_offset = 0;
-    } else {
-      if (frame_parms[CC_id]->N_RB_DL == 100)
-	UE[CC_id]->N_TA_offset = 624;
-      else if (frame_parms[CC_id]->N_RB_DL == 50)
-	UE[CC_id]->N_TA_offset = 624/2;
-      else if (frame_parms[CC_id]->N_RB_DL == 25)
-	UE[CC_id]->N_TA_offset = 624/4;
-    }
-    
-  }
-  
-  //  printf("tx_max_power = %d -> amp %d\n",tx_max_power[0],get_tx_amp(tx_max_poHwer,tx_max_power));
-  
-  
-  fill_modeled_runtime_table(runtime_phy_rx,runtime_phy_tx);
-  cpuf=get_cpu_freq_GHz();
-  
-  
-  //dump_frame_parms(frame_parms[0]);
-  
-  init_openair0();
-
-  // default threads.main = 2
-  // if there are enough processors, all others on subsequent CPUs
-  if (threads_offset>0) {
-    if (threads_offset+8<=get_nprocs()) {
-      if (threads.main<0) threads.main=threads_offset+1;
-      if (threads.sync<0) threads.sync=threads_offset+2;
-      if (threads.one<0) threads.one=threads_offset+3;
-      if (threads.two<0) threads.two=threads_offset+4;
-      if (threads.three<0) threads.three=threads_offset+5;
-      if (threads.slot1_proc_one<0) threads.slot1_proc_one=threads_offset+6;
-      if (threads.slot1_proc_two<0) threads.slot1_proc_two=threads_offset+7;
-      if (threads.slot1_proc_three<0) threads.slot1_proc_three=threads_offset+8;
-    }
-    else {
-      LOG_E(HW,"Not enough CPUs available (nprocs (=%d) >= threadmain (=%d) + 10)\n",get_nprocs(),threads_offset);
-      exit_fun("Error setting thread affinity\n");
-    }
-  }
-
-#ifndef DEADLINE_SCHEDULER
-
-    /* Currently we set affinity for UHD to CPU 0 for eNB/UE and only if number of CPUS >2 */
-
-    cpu_set_t cpuset;
-    int s;
-    char cpu_affinity[1024];
-    CPU_ZERO(&cpuset);
-#ifdef CPU_AFFINITY
-    int j;
-    if (get_nprocs()>=2) {
-      for (j = 2; j < get_nprocs(); j++)
-	CPU_SET(j, &cpuset);
-
-        s = pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
-        if (s != 0) {
-            perror( "pthread_setaffinity_np");
-            exit_fun("Error setting processor affinity");
-        }
-        LOG_I(HW, "Setting the affinity of main function to all CPUs, for device library to use CPU 0 only!\n");
-    }
-#endif
-
-  /* Check the actual affinity mask assigned to the thread */
-  s = pthread_getaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
-  if (s != 0) {
-    perror( "pthread_getaffinity_np");
-    exit_fun("Error getting processor affinity ");
-  }
-  memset(cpu_affinity, 0 , sizeof(cpu_affinity));
-  for (int j = 0; j < CPU_SETSIZE; j++) {
-    if (CPU_ISSET(j, &cpuset)) {
-      char temp[1024];
-      sprintf(temp, " CPU_%d ", j);
-      strcat(cpu_affinity, temp);
-    }
-  }
-  LOG_I(HW, "CPU Affinity of main() function is... %s\n", cpu_affinity);
-#endif
-
-
-    //openair0_cfg[0].log_level = glog_level;
-
-    /*int eMBMS_active=0;
-    if (node_function[0] <= NGFI_RAU_IF4p5) { // don't initialize L2 for RRU
-        LOG_I(PHY,"Intializing L2\n");
-        mac_xface = malloc(sizeof(MAC_xface));
-        l2_init(frame_parms[0],eMBMS_active,(uecap_xer_in==1)?uecap_xer:NULL,
-                0,// cba_group_active
-                0); // HO flag
-        mac_xface->macphy_exit = &exit_fun;
-    } else if (node_function[0] == NGFI_RRU_IF4p5) { // Initialize PRACH in this case
-
-    }*/
-
-
-
-#if defined(ENABLE_ITTI)
-
-        // don't create if node doesn't connect to RRC/S1/GTP
-        /*if (create_tasks(1) < 0) {
-            printf("cannot create ITTI tasks\n");
-            exit(-1); // need a softer mode
-        }*/
-
-    printf("ITTI tasks created\n");
-#endif
-
-    /*if (phy_test==0) {
-        if (UE_flag==1) {
-            printf("Filling UE band info\n");
-            fill_ue_band_info();
-            mac_xface->dl_phy_sync_success (0, 0, 0, 1);
-        } else if (node_function[0]>NGFI_RRU_IF4p5)
-            mac_xface->mrbch_phy_sync_failure (0, 0, 0);
-    }*/
-
-	// init UE_PF_PO and mutex lock
-	pthread_mutex_init(&ue_pf_po_mutex, NULL);
-	memset (&UE_PF_PO[0][0], 0, sizeof(UE_PF_PO_t)*NUMBER_OF_UE_MAX*MAX_NUM_CCs);
-
-
-    mlockall(MCL_CURRENT | MCL_FUTURE);
-
-    pthread_cond_init(&sync_cond,NULL);
-    pthread_mutex_init(&sync_mutex, NULL);
-
-    init_UE(1);
-
-#ifdef XFORMS
-    int UE_id;
-    int fl_argc=1;
-
-  if (do_forms==1) {
-    // fl_initialize messes with argv and argc, so pretend to not pass any options
-    fl_initialize (&fl_argc, argv, NULL, 0, 0);
-    // restore the original command line args
-    // argv = fl_get_cmdline_args( &argc );
-    //form_stats = create_form_stats_form();
-    //fl_show_form (form_stats->stats_form, FL_PLACE_HOTSPOT, FL_FULLBORDER, "stats");
-    UE_id = 0;
-    form_ue[UE_id] = create_lte_phy_scope_ue();
-    sprintf (title, "NR DL SCOPE UE");
-    fl_show_form (form_ue[UE_id]->lte_phy_scope_ue, FL_PLACE_HOTSPOT, FL_FULLBORDER, title);
-
-            /*
-            if (openair_daq_vars.use_ia_receiver) {
-                   fl_set_button(form_ue[UE_id]->button_0,1);
-                   fl_set_object_label(form_ue[UE_id]->button_0, "IA Receiver ON");
-            } else {
-                   fl_set_button(form_ue[UE_id]->button_0,0);
-                   fl_set_object_label(form_ue[UE_id]->button_0, "IA Receiver OFF");
-            }*/
-            fl_set_button(form_ue[UE_id]->button_0,0);
-            fl_set_object_label(form_ue[UE_id]->button_0, "IA Receiver OFF");
-        
-
-        ret = pthread_create(&forms_thread, NULL, scope_thread, NULL);
-
-        if (ret == 0)
-            pthread_setname_np( forms_thread, "xforms" );
-
-        printf("Scope thread created, ret=%d\n",ret);
-    }
-
-#endif
-
-    rt_sleep_ns(10*100000000ULL);
-
-    number_of_cards = 1;
-    
-    for(CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
-      PHY_vars_UE_g[0][CC_id]->rf_map.card=0;
-      PHY_vars_UE_g[0][CC_id]->rf_map.chain=CC_id+chain_offset;
-    }
-
-
-    for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
-      
-#if defined(OAI_USRP) || defined(OAI_ADRV9371_ZC706)
-      UE[CC_id]->hw_timing_advance = timing_advance;
-#else
-      UE[CC_id]->hw_timing_advance = 160;
-#endif
-    }
-
-    
-    if (input_fd) {
-      printf("Reading in from file to antenna buffer %d\n",0);
-      if (fread(UE[0]->common_vars.rxdata[0],
-		sizeof(int32_t),
-		frame_parms[0]->samples_per_subframe*10,
-		input_fd) != frame_parms[0]->samples_per_subframe*10)
-	printf("error reading from file\n");
-    }
-
-    sleep(3);
-
-
-    printf("Sending sync to all threads\n");
-
-    pthread_mutex_lock(&sync_mutex);
-    sync_var=0;
-    pthread_cond_broadcast(&sync_cond);
-    pthread_mutex_unlock(&sync_mutex);
-
-    // wait for end of program
-    printf("TYPE <CTRL-C> TO TERMINATE\n");
-    //getchar();
-
-    /*
-#if defined(ENABLE_ITTI)
-    printf("Entering ITTI signals handler\n");
-    itti_wait_tasks_end();
-    oai_exit=1;
-#else
-    */
-
-    while (oai_exit==0)
-        rt_sleep_ns(100000000ULL);
-
-    //#endif
-
-  // stop threads
-#ifdef XFORMS
-  printf("waiting for XFORMS thread\n");
-
-  if (do_forms==1) {
-    pthread_join(forms_thread,&status);
-    //fl_hide_form(form_stats->stats_form);
-    //fl_free_form(form_stats->stats_form);
-    fl_hide_form(form_ue[0]->lte_phy_scope_ue);
-    fl_free_form(form_ue[0]->lte_phy_scope_ue);
-  }
-
-#endif
-
-  printf("stopping MODEM threads\n");
-
-  pthread_cond_destroy(&sync_cond);
-  pthread_mutex_destroy(&sync_mutex);
-
-
-  // *** Handle per CC_id openair0
-  if (PHY_vars_UE_g[0][0]->rfdevice.trx_end_func)
-    PHY_vars_UE_g[0][0]->rfdevice.trx_end_func(&PHY_vars_UE_g[0][0]->rfdevice);
-  
-  //if (ouput_vcd)
-  //VCD_SIGNAL_DUMPER_CLOSE();
-
-  if (opt_enabled == 1)
-    terminate_opt();
-  
-  logClean();
-  
-  return 0;
-}