Merge with nr_smallBlockCoding

openair1/PHY/CODING/TESTBENCH/polartest.c

@@ -7,10 +7,10 @@
 #include <time.h>
 
 #include "PHY/CODING/nrPolar_tools/nr_polar_defs.h"
-#include "PHY/NR_TRANSPORT/nr_dci.h"
-#include "PHY/defs_gNB.h"
 #include "SIMULATION/TOOLS/sim.h"
 
+//#define DEBUG_POLAR_PARAMS
+
 int main(int argc, char *argv[]) {
 
 	//Initiate timing. (Results depend on CPU Frequency. Therefore, might change due to performance variances during simulation.)
@@ -20,16 +20,6 @@ int main(int argc, char *argv[]) {
 	reset_meas(&timeEncoder);
 	reset_meas(&timeDecoder);
 
-	//gNB scheduler
-	/*PHY_VARS_gNB *gNB = RC.gNB[0][0];
-	NR_DL_FRAME_PARMS *fp = &gNB->frame_parms;
-	nfapi_nr_config_request_t *cfg = &gNB->gNB_config;
-
-	nfapi_nr_dl_config_request_pdu_t *pdu;
-	nfapi_nr_dl_config_pdcch_parameters_rel15_t *params_rel15 = &pdu->dci_dl_pdu.pdcch_params_rel15;
-	params_rel15->rnti_type = NFAPI_NR_RNTI_RA;
-	params_rel15->dci_format = NFAPI_NR_DL_DCI_FORMAT_1_0;*/
-
 	randominit(0);
 	//Default simulation values (Aim for iterations = 1000000.)
 	int itr, iterations = 1000, arguments, polarMessageType = 0; //0=PBCH, 1=DCI, -1=UCI
@@ -38,10 +28,9 @@ int main(int argc, char *argv[]) {
 	double SNR, SNR_lin;
 	int16_t nBitError = 0; // -1 = Decoding failed (All list entries have failed the CRC checks).
 	int8_t decoderState=0, blockErrorState=0; //0 = Success, -1 = Decoding failed, 1 = Block Error.
-	uint16_t testLength, coderLength, blockErrorCumulative=0, bitErrorCumulative=0;
+	uint16_t testLength = 0, coderLength = 0, blockErrorCumulative=0, bitErrorCumulative=0;
 	double timeEncoderCumulative = 0, timeDecoderCumulative = 0;
-
-	uint8_t aggregation_level, decoderListSize = 8, pathMetricAppr = 0; //0 --> eq. (8a) and (11b), 1 --> eq. (9) and (12)
+	uint8_t aggregation_level;
 
 	while ((arguments = getopt (argc, argv, "s:d:f:m:i:l:a:")) != -1)
 	switch (arguments)
@@ -125,6 +114,26 @@ int main(int argc, char *argv[]) {
 
 	t_nrPolar_paramsPtr nrPolar_params = NULL;
 	nr_polar_init(&nrPolar_params, polarMessageType, testLength, aggregation_level);
+#ifdef DEBUG_POLAR_PARAMS
+	nr_polar_init(&nrPolar_params, polarMessageType, testLength, aggregation_level);
+	nr_polar_init(&nrPolar_params, 1, 20, 1);
+	nr_polar_init(&nrPolar_params, 1, 21, 1);
+	nr_polar_init(&nrPolar_params, polarMessageType, testLength, aggregation_level);
+	nr_polar_print_polarParams(nrPolar_params);
+
+	uint32_t in[4];
+	in[0]=0x01189400;
+	in[1]=0xffffff0f;
+	uint8_t *out = malloc(sizeof(uint8_t) * 41);
+	nr_bit2byte_uint32_8_t(in, 41, out);
+	for (int i=0;i<41;i++)
+		printf("out[%d]=%d\n",i,out[i]);
+	uint32_t inn[4];
+	nr_byte2bit_uint8_32_t(out, 41, inn);
+	printf("inn[0]=%#x, inn[1]=%#x\n",inn[0],inn[1]);
+	return (0);
+#endif
+
 	t_nrPolar_paramsPtr currentPtr = nr_polar_params(nrPolar_params, polarMessageType, testLength);
 
 	// We assume no a priori knowledge available about the payload.
@@ -149,16 +158,24 @@ int main(int argc, char *argv[]) {
 				modulatedInput[i]=(-1)/sqrt(2);
 
 			channelOutput[i] = modulatedInput[i] + (gaussdouble(0.0,1.0) * (1/sqrt(2*SNR_lin)));
+			printf("%f\n",channelOutput[i]);
 		}
 
 
+
 		start_meas(&timeDecoder);
-		decoderState = polar_decoder(channelOutput,
+		/*decoderState = polar_decoder(channelOutput,
 									 estimatedOutput,
 									 currentPtr,
-									 decoderListSize,
+									 NR_POLAR_DECODER_LISTSIZE,
 									 aPrioriArray,
-									 pathMetricAppr);
+									 NR_POLAR_DECODER_PATH_METRIC_APPROXIMATION);*/
+		decoderState = polar_decoder_aPriori(channelOutput,
+											 estimatedOutput,
+											 currentPtr,
+											 NR_POLAR_DECODER_LISTSIZE,
+											 NR_POLAR_DECODER_PATH_METRIC_APPROXIMATION,
+											 aPrioriArray);
 		stop_meas(&timeDecoder);
 
 		//calculate errors

openair1/PHY/CODING/nrPolar_tools/nr_bitwise_operations.c

@@ -21,29 +21,23 @@
 
 #include "PHY/CODING/nrPolar_tools/nr_polar_defs.h"
 
-void nr_byte2bit_uint8(uint8_t *array, uint8_t arraySize, uint8_t *bitArray) {
-	//First 2 parameters are in bytes.
-
-	for (int i = 0; i < arraySize; i++) {
-		bitArray[(7 + (i * 8))] = (array[i] >> 0 & 0x01);
-		bitArray[(6 + (i * 8))] = (array[i] >> 1 & 0x01);
-		bitArray[(5 + (i * 8))] = (array[i] >> 2 & 0x01);
-		bitArray[(4 + (i * 8))] = (array[i] >> 3 & 0x01);
-		bitArray[(3 + (i * 8))] = (array[i] >> 4 & 0x01);
-		bitArray[(2 + (i * 8))] = (array[i] >> 5 & 0x01);
-		bitArray[(1 + (i * 8))] = (array[i] >> 6 & 0x01);
-		bitArray[(i * 8)] = (array[i] >> 7 & 0x01);
+void nr_bit2byte_uint32_8_t(uint32_t *in, uint16_t arraySize, uint8_t *out) {
+	uint8_t arrayInd = ceil(arraySize / 32.0);
+	for (int i = 0; i < arrayInd; i++) {
+		for (int j = 0; j < 32; j++) {
+			out[j+(i*32)] = (in[i] >> j) & 1;
 		}
-}
-
-void nr_bit2byte(uint32_t *in, uint16_t arraySize, uint8_t *out) {
-	for (int i = 0; i < arraySize; i++) {
-		out[i] = ((*in) >> i) & 1;
 	}
 }
 
-void nr_byte2bit(uint8_t *in, uint16_t arraySize, uint32_t *out) {
-	for (int i = 0; i < arraySize; i++) {
-		*out = (*out) << i | in[i];
+void nr_byte2bit_uint8_32_t(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;
+		for (int j = 31; j > 0; j--) {
+			out[i]|=in[(i*32)+j];
+			out[i]<<=1;
+		}
+		out[i]|=in[(i*32)];
 	}
 }

openair1/PHY/CODING/nrPolar_tools/nr_polar_defs.h

@@ -19,6 +19,17 @@
  *      contact@openairinterface.org
  */
 
+/*!\file PHY/CODING/nrPolar_tools/nr_polar_defs.h
+ * \brief
+ * \author Turker Yilmaz
+ * \date 2018
+ * \version 0.1
+ * \company EURECOM
+ * \email turker.yilmaz@eurecom.fr
+ * \note
+ * \warning
+*/
+
 #ifndef __NR_POLAR_DEFS__H__
 #define __NR_POLAR_DEFS__H__
 
@@ -32,6 +43,9 @@
 #include "PHY/CODING/nrPolar_tools/nr_polar_uci_defs.h"
 #include "PHY/CODING/nrPolar_tools/nr_polar_pbch_defs.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)
+
 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 };
 
 struct nrPolar_params {
@@ -65,20 +79,33 @@ struct nrPolar_params {
 	uint8_t **crc_generator_matrix; //G_P
 	uint8_t **G_N;
 
-	//polar_encoder vectors:
+	//polar_encoder vectors
 	uint8_t *nr_polar_crc;
-	uint8_t *nr_polar_b;
+	uint8_t *nr_polar_d;
+	uint8_t *nr_polar_e;
+
+	//Polar Coding vectors
+	uint8_t *nr_polar_a;
 	uint8_t *nr_polar_cPrime;
+	uint8_t *nr_polar_b;
 	uint8_t *nr_polar_u;
-	uint8_t *nr_polar_d;
 } __attribute__ ((__packed__));
 typedef struct nrPolar_params t_nrPolar_params;
 typedef t_nrPolar_params *t_nrPolar_paramsPtr;
 
-void polar_encoder(uint8_t *input, uint8_t *output, t_nrPolar_paramsPtr polarParams);
+void polar_encoder(uint32_t *input, uint32_t *output, t_nrPolar_paramsPtr polarParams);
 
-int8_t polar_decoder(double *input, uint8_t *output, t_nrPolar_paramsPtr polarParams,
-		uint8_t listSize, double *aPrioriPayload, uint8_t pathMetricAppr);
+int8_t polar_decoder(double *input,
+		 	 	 	 uint32_t *output,
+					 t_nrPolar_paramsPtr polarParams,
+					 uint8_t listSize,
+					 uint8_t pathMetricAppr);
+int8_t polar_decoder_aPriori(double *input,
+							 uint32_t *output,
+							 t_nrPolar_paramsPtr polarParams,
+							 uint8_t listSize,
+							 uint8_t pathMetricAppr,
+							 double *aPrioriPayload);
 
 void nr_polar_init(t_nrPolar_paramsPtr *polarParams,
 				   int8_t messageType,
@@ -113,9 +140,8 @@ void nr_polar_info_bit_pattern(uint8_t *ibp, int16_t *Q_I_N, int16_t *Q_F_N,
 void nr_polar_info_bit_extraction(uint8_t *input, uint8_t *output,
 		uint8_t *pattern, uint16_t size);
 
-void nr_byte2bit(uint8_t *in, uint16_t arraySize, uint32_t *out);
-void nr_byte2bit_uint8(uint8_t *array, uint8_t arraySize, uint8_t *bitArray);
-void nr_bit2byte(uint32_t *in, uint16_t arraySize, uint8_t *out);
+void nr_bit2byte_uint32_8_t(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_polar_bit_insertion(uint8_t *input, uint8_t *output, uint16_t N,
 		uint16_t K, int16_t *Q_I_N, int16_t *Q_PC_N, uint8_t n_PC);

openair1/PHY/CODING/nrPolar_tools/nr_polar_encoder.c

@@ -19,40 +19,75 @@
  *      contact@openairinterface.org
  */
 
+/*!\file PHY/CODING/nrPolar_tools/nr_polar_encoder.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 polar_encoder(
-		uint8_t *input,
-		uint8_t *output,
+void polar_encoder(uint32_t *in,
+				   uint32_t *out,
 				   t_nrPolar_paramsPtr polarParams)
 {
+	nr_bit2byte_uint32_8_t(in, polarParams->payloadBits, polarParams->nr_polar_a);
 
 	/*
 	 * Bytewise operations
 	 */
-
 	//Calculate CRC.
-	nr_matrix_multiplication_uint8_t_1D_uint8_t_2D(input, 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);
+	nr_matrix_multiplication_uint8_t_1D_uint8_t_2D(polarParams->nr_polar_a,
+												   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);
 
 	//Attach CRC to the Transport Block. (a to b)
-	for (uint16_t i = 0; i < polarParams->payloadBits; i++) polarParams->nr_polar_b[i] = input[i];
+	for (uint16_t i = 0; i < polarParams->payloadBits; i++) polarParams->nr_polar_b[i] = polarParams->nr_polar_a[i];
 	for (uint16_t i = polarParams->payloadBits; i < polarParams->K; i++)
 		polarParams->nr_polar_b[i]= polarParams->nr_polar_crc[i-(polarParams->payloadBits)];
 
 	//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, polarParams->N, polarParams->K,
-			polarParams->Q_I_N, polarParams->Q_PC_N, polarParams->n_pc);
+	nr_polar_bit_insertion(polarParams->nr_polar_cPrime,
+						   polarParams->nr_polar_u,
+						   polarParams->N,
+						   polarParams->K,
+						   polarParams->Q_I_N,
+						   polarParams->Q_PC_N,
+						   polarParams->n_pc);
 
 	//Encoding (u to d)
-	nr_matrix_multiplication_uint8_t_1D_uint8_t_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);
+	nr_matrix_multiplication_uint8_t_1D_uint8_t_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);
 
 	//Rate matching
 	//Sub-block interleaving (d to y) and Bit selection (y to e)
-	nr_polar_rate_matcher(polarParams->nr_polar_d, output, polarParams->rate_matching_pattern, polarParams->encoderLength);
+	nr_polar_rate_matcher(polarParams->nr_polar_d,
+						  polarParams->nr_polar_e,
+						  polarParams->rate_matching_pattern,
+						  polarParams->encoderLength);
+
+	/*
+	 * Return bits.
+	 */
+	nr_byte2bit_uint8_32_t(polarParams->nr_polar_e, polarParams->encoderLength, out);
 }

openair1/PHY/CODING/nrPolar_tools/nr_polar_pbch_defs.h

@@ -19,15 +19,15 @@
  *      contact@openairinterface.org
  */
 
-/*! \file PHY/CODING/nrPolar_tools/nr_polar_dci_defs.h
-* \brief Defines the constant variables for polar coding of the PBCH from 38-212, V15.1.1 2018-04.
-* \author
-* \date 2018
-* \version 0.1
-* \company Eurecom
-* \email:
-* \note
-* \warning
+/*!\file PHY/CODING/nrPolar_tools/nr_polar_defs.h
+ * \brief Defines the constant variables for polar coding of the PBCH from 38-212, V15.1.1 2018-04.
+ * \author Turker Yilmaz
+ * \date 2018
+ * \version 0.1
+ * \company EURECOM
+ * \email turker.yilmaz@eurecom.fr
+ * \note
+ * \warning
 */
 
 #ifndef __NR_POLAR_PBCH_DEFS__H__
@@ -52,9 +52,6 @@
 #define NR_POLAR_PBCH_I_BIL 0 //uint8_t
 #define NR_POLAR_PBCH_E 864   //uint16_t
 
-//#define NR_POLAR_PBCH_L 5 //uint8_t
-#define NR_POLAR_PBCH_PATH_METRIC_APPROXIMATION 0 //uint8_t; 0 --> eq. (8a) and (11b), 1 --> eq. (9) and (12)
-
 /*
  * TEST CODE
  */

openair1/PHY/CODING/nr_polar_init.c

@@ -19,6 +19,17 @@
  *      contact@openairinterface.org
  */
 
+/*!\file PHY/CODING/nr_polar_init.h
+ * \brief
+ * \author Turker Yilmaz
+ * \date 2018
+ * \version 0.1
+ * \company EURECOM
+ * \email turker.yilmaz@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"
@@ -31,16 +42,11 @@ void nr_polar_init(t_nrPolar_paramsPtr *polarParams,
 				   uint8_t aggregation_level)
 {
 	t_nrPolar_paramsPtr currentPtr = *polarParams;
-	t_nrPolar_paramsPtr previousPtr = NULL;
 
 	//Parse the list. If the node is already created, return without initialization.
 	while (currentPtr != NULL) {
-		if (currentPtr->idx == (messageType * messageLength)) {
-			return;
-		} else {
-			previousPtr = currentPtr;
-			currentPtr = currentPtr->nextPtr;
-		}
+		if (currentPtr->idx == (messageType * messageLength)) return;
+		else currentPtr = currentPtr->nextPtr;
 	}
 
 	//Else, initialize and add node to the end of the linked list.
@@ -88,13 +94,15 @@ void nr_polar_init(t_nrPolar_paramsPtr *polarParams,
 
 		//polar_encoder vectors:
 		newPolarInitNode->nr_polar_crc = malloc(sizeof(uint8_t) * newPolarInitNode->crcParityBits);
-		newPolarInitNode->nr_polar_cPrime = malloc(sizeof(uint8_t) * newPolarInitNode->K);
 		newPolarInitNode->nr_polar_d = malloc(sizeof(uint8_t) * newPolarInitNode->N);
+		newPolarInitNode->nr_polar_e = malloc(sizeof(uint8_t) * newPolarInitNode->encoderLength);
 
 		//Polar Coding vectors
 		newPolarInitNode->nr_polar_u = malloc(sizeof(uint8_t) * newPolarInitNode->N); //Decoder: nr_polar_uHat
 		newPolarInitNode->nr_polar_cPrime = malloc(sizeof(uint8_t) * newPolarInitNode->K); //Decoder: nr_polar_cHat
 		newPolarInitNode->nr_polar_b = malloc(sizeof(uint8_t) * newPolarInitNode->K); //Decoder: nr_polar_bHat
+		newPolarInitNode->nr_polar_a = malloc(sizeof(uint8_t) * newPolarInitNode->payloadBits); //Decoder: nr_polar_aHat
+
 
 
 		newPolarInitNode->Q_0_Nminus1 = nr_polar_sequence_pattern(newPolarInitNode->n);
@@ -174,7 +182,7 @@ t_nrPolar_paramsPtr nr_polar_params (t_nrPolar_paramsPtr polarParams,
 									 int8_t messageType,
 									 uint16_t messageLength)
 {
-	t_nrPolar_paramsPtr currentPtr;
+	t_nrPolar_paramsPtr currentPtr = NULL;
 
 	while (polarParams != NULL) {
 		if (polarParams->idx == (messageType * messageLength)) {

openair1/PHY/INIT/nr_init.c

@@ -119,7 +119,7 @@ int phy_init_nr_gNB(PHY_VARS_gNB *gNB,
   // PBCH DMRS gold sequences generation
   nr_init_pbch_dmrs(gNB);
   // Polar encoder init for PBCH
-  nr_polar_init(&fp->pbch_polar_params,
+  nr_polar_init(&gNB->nrPolar_params,
 		  	  	NR_POLAR_PBCH_MESSAGE_TYPE,
 				NR_POLAR_PBCH_PAYLOAD_BITS,
 				NR_POLAR_PBCH_AGGREGATION_LEVEL);

openair1/PHY/NR_TRANSPORT/nr_dci.c

@@ -34,6 +34,7 @@
 
 //#define DEBUG_PDCCH_DMRS
 //#define DEBUG_DCI
+#define DEBUG_POLAR_PARAMS
 
 extern short nr_mod_table[NR_MOD_TABLE_SIZE_SHORT];
 
@@ -202,24 +203,29 @@ uint8_t nr_generate_dci_top(NR_gNB_PDCCH pdcch_vars,
 
   /// DCI payload processing
   //channel coding
-  /*uint8_t *encoderInput = malloc(sizeof(uint8_t) * dci_alloc.size);
-  nr_bit2byte(dci_alloc.dci_pdu, dci_alloc.size, encoderInput);
-
-  nr_polar_init(&nrPolar_params, NR_POLAR_DCI_MESSAGE_TYPE, dci_alloc.size, pdcch_params.aggregation_level);
-  t_nrPolar_paramsPtr currentPtr = nr_polar_params(nrPolar_params,
-		  	  	  	  	  	  	  	  	  	  	   NR_POLAR_DCI_MESSAGE_TYPE,
-												   dci_alloc.size);
+  nr_polar_init(nrPolar_params, NR_POLAR_DCI_MESSAGE_TYPE, dci_alloc.size, dci_alloc.L);
+  t_nrPolar_paramsPtr currentPtr = nr_polar_params(*nrPolar_params, NR_POLAR_DCI_MESSAGE_TYPE, dci_alloc.size);
 
+  uint8_t *encoderInput = malloc(sizeof(uint8_t) * dci_alloc.size);
   uint8_t *encoderOutput = malloc(sizeof(uint8_t) * currentPtr->encoderLength);
-  polar_encoder(encoderInput, encoderOutput, currentPtr);
   uint32_t encoded_payload[4];
-  nr_byte2bit(encoderOutput,currentPtr->encoderLength,encoded_payload);*/
+
+  nr_bit2byte_uint32_8_t(dci_alloc.dci_pdu,dci_alloc.size,encoderInput);
+  polar_encoder(encoderInput, encoderOutput, currentPtr);
+  nr_byte2bit_uint8_32_t(encoderOutput, currentPtr->encoderLength, encoded_payload);
+
+#ifdef DEBUG_POLAR_PARAMS
+  printf("DCI PDU: [0]->0x%08x \t [1]->0x%08x \t [2]->0x%08x \t [3]->0x%08x\n",
+    		  dci_alloc.dci_pdu[0], dci_alloc.dci_pdu[1], dci_alloc.dci_pdu[2], dci_alloc.dci_pdu[3]);
+  printf("Encoded Payload: [0]->0x%08x \t [1]->0x%08x \t [2]->0x%08x \t [3]->0x%08x\n",
+		  encoded_payload[0], encoded_payload[1], encoded_payload[2], encoded_payload[3]);
+#endif
 
     // scrambling
   uint32_t scrambled_payload[NR_MAX_DCI_SIZE_DWORD];
   uint32_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;
   uint32_t n_RNTI = (pdcch_params.search_space_type == NFAPI_NR_SEARCH_SPACE_TYPE_UE_SPECIFIC)? pdcch_params.rnti : 0;
-  nr_pdcch_scrambling(dci_alloc.dci_pdu, dci_alloc.size, Nid, n_RNTI, scrambled_payload);
+  nr_pdcch_scrambling(encoded_payload, dci_alloc.size, Nid, n_RNTI, scrambled_payload);
 
     // QPSK modulation
   int16_t mod_dci[NR_MAX_DCI_SIZE>>1];

openair1/PHY/NR_TRANSPORT/nr_dci_tools.c

@@ -31,6 +31,7 @@
  */
 
 #include "nr_dci.h"
+#define DEBUG_NFAPI_NR_RNTI_RA
 
 void nr_fill_cce_list(NR_gNB_DCI_ALLOC_t* dci_alloc, uint16_t n_shift, uint8_t m) {
 
@@ -128,6 +129,17 @@ void nr_fill_dci_and_dlsch(PHY_VARS_gNB *gNB,
     case NFAPI_NR_DL_DCI_FORMAT_1_0:
       switch(params_rel15->rnti_type) {
         case NFAPI_NR_RNTI_RA:
+#ifdef DEBUG_NFAPI_NR_RNTI_RA
+printf("frequency_domain_assignment = %05d = %#010x\n"
+		"     time_domain_assignment = %05d = %#010x\n"
+		"         vrb_to_prb_mapping = %05d = %#010x\n"
+		"                        MCS = %05d = %#010x\n"
+		"                 tb_scaling = %05d = %#010x\n",
+		pdu_rel15->frequency_domain_assignment,pdu_rel15->frequency_domain_assignment,
+		pdu_rel15->time_domain_assignment,pdu_rel15->time_domain_assignment,
+		pdu_rel15->vrb_to_prb_mapping,pdu_rel15->vrb_to_prb_mapping,
+		pdu_rel15->mcs,pdu_rel15->mcs,pdu_rel15->tb_scaling,pdu_rel15->tb_scaling);
+#endif
           // Freq domain assignment
           fsize = (int)ceil( log2( (N_RB*(N_RB+1))>>1 ) );
           for (int i=0; i<fsize; i++)

openair1/PHY/NR_UE_TRANSPORT/nr_pbch.c

@@ -535,13 +535,13 @@ int nr_rx_pbch( PHY_VARS_NR_UE *ue,
   unsigned short idx_demod =0;
   int8_t decoderState=0;
   uint8_t decoderListSize = 8, pathMetricAppr = 0;
-  double aPrioriArray[frame_parms->pbch_polar_params.payloadBits];  // assume no a priori knowledge available about the payload.
 
   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);
 
-  for (int i=0; i<frame_parms->pbch_polar_params.payloadBits; i++) aPrioriArray[i] = NAN;
+  /*double aPrioriArray[frame_parms->pbch_polar_params.payloadBits];  // assume no a priori knowledge available about the payload.
+  for (int i=0; i<frame_parms->pbch_polar_params.payloadBits; i++) aPrioriArray[i] = NAN;*/
 
   int subframe_rx = proc->subframe_rx;
 
@@ -651,7 +651,7 @@ int nr_rx_pbch( PHY_VARS_NR_UE *ue,
 //#endif
 		
   //polar decoding de-rate matching
-  decoderState = polar_decoder(demod_pbch_e, pbch_a_b, &frame_parms->pbch_polar_params, decoderListSize, aPrioriArray, pathMetricAppr);
+  decoderState = polar_decoder(demod_pbch_e, pbch_a, &frame_parms->pbch_polar_params, decoderListSize, pathMetricAppr);
   printf("polar decoder state %d\n", decoderState);
   if(decoderState == -1)
   	return(decoderState);

openair1/PHY/defs_gNB.h

@@ -285,13 +285,14 @@ typedef struct PHY_VARS_gNB_s {
 
   Sched_Rsp_t         Sched_INFO;
   NR_gNB_PDCCH        pdcch_vars;
+  NR_gNB_PBCH         pbch;
+  t_nrPolar_paramsPtr nrPolar_params;
   nfapi_nr_dl_config_pdcch_parameters_rel15_t pdcch_type0_params;
   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];
-  NR_gNB_PBCH         pbch;
   LTE_eNB_PUSCH       *pusch_vars[NUMBER_OF_UE_MAX];
   LTE_eNB_PRACH        prach_vars;
   LTE_eNB_DLSCH_t     *dlsch[NUMBER_OF_UE_MAX][2];   // Nusers times two spatial streams
@@ -462,8 +463,6 @@ typedef struct PHY_VARS_gNB_s {
   int32_t pusch_stats_mcs[NUMBER_OF_UE_MAX][10240];
   int32_t pusch_stats_bsr[NUMBER_OF_UE_MAX][10240];
   int32_t pusch_stats_BO[NUMBER_OF_UE_MAX][10240];
-
-  t_nrPolar_paramsPtr nrPolar_params;
 } PHY_VARS_gNB;
 
 #endif

openair2/GNB_APP/gnb_config.c

@@ -592,12 +592,12 @@ int RCconfig_NRRRC(MessageDef *msg_p, uint32_t i, gNB_RRC_INST *rrc) {
   int32_t                RateMatchPatternLTE_CRS_radioframeAllocationOffset            = 0;
   char*                  RateMatchPatternLTE_CRS_subframeAllocation_choice             = NULL;
 
-  int32_t                srb1_timer_poll_retransmit    = 0;
+  /*int32_t                srb1_timer_poll_retransmit    = 0;
   int32_t                srb1_timer_reordering         = 0;
   int32_t                srb1_timer_status_prohibit    = 0;
   int32_t                srb1_poll_pdu                 = 0;
   int32_t                srb1_poll_byte                = 0;
-  int32_t                srb1_max_retx_threshold       = 0;
+  int32_t                srb1_max_retx_threshold       = 0;*/
 
   //int32_t             my_int;
 
@@ -606,11 +606,11 @@ int 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};
   
-  paramdef_t SRB1Params[] = SRB1PARAMS_DESC;  
+  //paramdef_t SRB1Params[] = SRB1PARAMS_DESC;
 
   /* get global parameters, defined outside any section in the config file */
  

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_phytest.c

@@ -42,7 +42,7 @@ void nr_schedule_css_dlsch_phytest(module_id_t   module_idP,
   uint8_t  CC_id;
 
   gNB_MAC_INST                        *nr_mac      = RC.nrmac[module_idP];
-  NR_COMMON_channels_t                *cc           = nr_mac->common_channels;
+  //NR_COMMON_channels_t                *cc           = nr_mac->common_channels;
   nfapi_nr_dl_config_request_body_t   *dl_req;
   nfapi_nr_dl_config_request_pdu_t  *dl_config_pdu;
   nfapi_tx_request_pdu_t            *TX_req;

targets/RT/USER/nr-ru.c

@@ -604,7 +604,7 @@ void fh_if4p5_north_asynch_in(RU_t *ru,int *frame,int *subframe) {
   RU_proc_t *proc        = &ru->proc;
 
   uint16_t packet_type;
-  uint32_t symbol_number,symbol_mask,symbol_mask_full;
+  uint32_t symbol_number,symbol_mask,symbol_mask_full=0;
   int subframe_tx,frame_tx;
 
   LOG_D(PHY, "%s(ru:%p frame, subframe)\n", __FUNCTION__, ru);