Merge branch 'develop-nb-iot-mac' of...

Merge branch 'develop-nb-iot-mac' of https://gitlab.eurecom.fr/oai/openairinterface5g into develop-nb-iot-mac

openair1/PHY/LTE_TRANSPORT/dlsch_coding_NB_IoT.c

+/*******************************************************************************
+
+*******************************************************************************/
+/*! \file PHY/LTE_TRANSPORT/dlsch_coding_NB_IoT.c
+* \brief Top-level routines for implementing Tail-biting convolutional coding for transport channels (NPDSCH) for NB_IoT,	 TS 36-212, V13.4.0 2017-02
+* \author M. KANJ
+* \date 2017
+* \version 0.0
+* \company bcom
+* \email: matthieu.kanj@b-com.com
+* \note
+* \warning
+*/
+
+#include "PHY/defs.h"
+#include "PHY/extern.h"
+#include "PHY/CODING/defs.h"
+#include "PHY/CODING/extern.h"
+#include "PHY/CODING/lte_interleaver_inline.h"
+#include "PHY/LTE_TRANSPORT/defs.h"
+#include "PHY/LTE_TRANSPORT/proto.h"
+#include "SCHED/defs.h"
+#include "defs.h"
+#include "UTIL/LOG/vcd_signal_dumper.h"
+
+#define is_not_pilot(pilots,first_pilot,re) (1)
+
+#include "PHY/LTE_TRANSPORT/defs_NB_IoT.h" // newly added for NB_IoT
+
+void ccode_encode_npdsch_NB_IoT (int32_t numbits,
+								 uint8_t *inPtr,
+								 uint8_t *outPtr,
+								 uint32_t crc)
+{
+	uint32_t  state;
+	uint8_t  c, out, first_bit;
+	int8_t shiftbit=0;
+  /* The input bit is shifted in position 8 of the state.
+	Shiftbit will take values between 1 and 8 */
+	state = 0;
+	first_bit = 2;
+	c = ((uint8_t*)&crc)[0];
+	// Perform Tail-biting
+	// get bits from last byte of input (or crc)
+	for (shiftbit = 0 ; shiftbit <(8-first_bit) ; shiftbit++) {
+		if ((c&(1<<(7-first_bit-shiftbit))) != 0)
+		state |= (1<<shiftbit);
+	}
+	state = state & 0x3f;   // true initial state of Tail-biting CCode
+	state<<=1;              // because of loop structure in CCode
+		while (numbits > 0) {											// Tail-biting is applied to input bits , input 34 bits , output 102 bits
+			c = *inPtr++;
+			for (shiftbit = 7; (shiftbit>=0) && (numbits>0); shiftbit--,numbits--) {
+				state >>= 1;
+				if ((c&(1<<shiftbit)) != 0) {
+					state |= 64;
+				}
+				out = ccodelte_table_NB_IoT[state];
+
+				*outPtr++ = out  & 1;
+				*outPtr++ = (out>>1)&1;
+				*outPtr++ = (out>>2)&1;
+			}
+		}
+}
+
+
+int dlsch_encoding_NB_IoT(unsigned char *a,
+						  NB_IoT_eNB_DLSCH_t *dlsch,
+						  uint8_t Nsf,					// number of subframes required for npdsch pdu transmission calculated from Isf (3GPP spec table)
+						  unsigned int G; 				// G (number of available RE) is implicitly multiplied by 2 (since only QPSK modulation)
+						  time_stats_t *rm_stats,
+						  time_stats_t *te_stats,
+						  time_stats_t *i_stats)
+{
+	unsigned int crc=1;
+	//unsigned char harq_pid = dlsch->current_harq_pid;  			// to check during implementation if harq_pid is required in the NB_IoT_eNB_DLSCH_t structure  in defs_NB_IoT.h
+	unsigned int A;
+	uint8_t RCC;
+	A = dlsch->harq_processe->TBS;  				// 680
+	dlsch->harq_processe->length_e = G*Nsf			// G*Nsf (number_of_subframes) = total number of bits to transmit 
+	int32_t numbits = A+24;
+	
+	if (dlsch->harq_processe->round == 0) { 	    // This is a new packet
+
+		crc = crc24a(a,A)>>8;						// CRC calculation (24 bits CRC)
+												// CRC attachment to payload
+		a[A>>3] = ((uint8_t*)&crc)[2];
+		a[1+(A>>3)] = ((uint8_t*)&crc)[1];
+		a[2+(A>>3)] = ((uint8_t*)&crc)[0];
+		
+		dlsch->harq_processe->B = numbits;			// The length of table b in bits
+		
+		memcpy(dlsch->harq_processe->b,a,numbits/8); 
+		memset(dlsch->harq_processe->d,LTE_NULL,96);
+		
+		start_meas(te_stats);
+		ccode_encode_npdsch_NB_IoT(numbits, dlsch->harq_processe->b, dlsch->harq_processe->d+96, crc);  					//   step 1 Tail-biting convolutional coding
+		stop_meas(te_stats);
+		
+		start_meas(i_stats);
+		RCC = sub_block_interleaving_cc_NB_IoT(numbits,dlsch->harq_processe->d+96,dlsch->harq_processe->w);					//   step 2 interleaving
+		stop_meas(i_stats);
+		
+		start_meas(rm_stats);
+		lte_rate_matching_cc_NB_IoT(RCC,dlsch->harq_processe->length_e,dlsch->harq_processe->w,dlsch->harq_processe->e);    // step 3 Rate Matching
+		stop_meas(rm_stats);		
+    }
+  return(0);
+}

openair1/PHY/LTE_TRANSPORT/dlsch_modulation_NB_IoT.c

+/***********************************************************************
+
+**********************************************************************/
+/*! \file PHY/LTE_TRANSPORT/dlsch_modulation_NB_IoT.c
+* \brief Top-level routines for generating the NPDSCH physical channel for NB_IoT,
+* \author M. KANJ
+* \date 2017
+* \version 0.0
+* \company bcom
+* \email: matthieu.kanj@b-com.com
+* \note
+* \warning
+*/
+
+#include "PHY/defs.h"
+#include "PHY/extern.h"
+#include "PHY/CODING/defs.h"
+#include "PHY/CODING/extern.h"
+#include "PHY/CODING/lte_interleaver_inline.h"
+#include "PHY/LTE_TRANSPORT/defs.h"
+#include "defs.h"
+#include "UTIL/LOG/vcd_signal_dumper.h"
+
+int allocate_REs_in_RB_NB_IoT(NB_IOT_DL_FRAME_PARMS *frame_parms,
+                              int32_t **txdataF,
+                              uint32_t *jj,
+                              uint32_t symbol_offset,
+                              uint8_t *x0,
+                              uint8_t pilots,
+                              int16_t amp,
+						  	  unsigned short id_offset,
+                              uint32_t *re_allocated)  //  not used variable ??!!
+{
+  MIMO_mode_t mimo_mode = (frame_parms->mode1_flag==1)?SISO:ALAMOUTI;
+  uint32_t tti_offset,aa;
+  uint8_t re, diff_re;
+  int16_t gain_lin_QPSK;
+  uint8_t first_re,last_re;
+  int32_t tmp_sample1,tmp_sample2;
+  gain_lin_QPSK = (int16_t)((amp*ONE_OVER_SQRT2_Q15)>>15);
+  first_re=0;
+  last_re=12;
+
+  for (re=first_re; re<last_re; re++) {      		// re varies between 0 and 12 sub-carriers
+
+    tti_offset = symbol_offset + re;				// symbol_offset = 512 * L ,  re_offset = 512 - 3*12  , re
+	
+	if (pilots != 1 || re%3 != id_offset)  			// if re is not a pilot
+	{
+													//	diff_re = re%3 - id_offset;  
+      if (mimo_mode == SISO) {  								//SISO mapping
+			*re_allocated = *re_allocated + 1;						// variable incremented but never used
+			
+			for (aa=0; aa<frame_parms->nb_antennas_tx; aa++) {
+					((int16_t*)&txdataF[aa][tti_offset])[0] += (x0[*jj]==1) ? (-gain_lin_QPSK) : gain_lin_QPSK; //I //b_i
+			}
+			*jj = *jj + 1;
+			for (aa=0; aa<frame_parms->nb_antennas_tx; aa++) {
+				((int16_t*)&txdataF[aa][tti_offset])[1] += (x0[*jj]==1) ? (-gain_lin_QPSK) : gain_lin_QPSK; //Q //b_{i+1}
+			}
+			*jj = *jj + 1;	
+			
+      } else if (mimo_mode == ALAMOUTI) {
+	  
+			*re_allocated = *re_allocated + 1;
+
+			((int16_t*)&tmp_sample1)[0] = (x0[*jj]==1) ? (-gain_lin_QPSK) : gain_lin_QPSK;
+			*jj=*jj+1;
+			((int16_t*)&tmp_sample1)[1] = (x0[*jj]==1) ? (-gain_lin_QPSK) : gain_lin_QPSK;
+			*jj=*jj+1;
+
+			// second antenna position n -> -x1*
+
+			((int16_t*)&tmp_sample2)[0] = (x0[*jj]==1) ? (gain_lin_QPSK) : -gain_lin_QPSK;
+			*jj=*jj+1;
+			((int16_t*)&tmp_sample2)[1] = (x0[*jj]==1) ? (-gain_lin_QPSK) : gain_lin_QPSK;
+			*jj=*jj+1;
+
+			// normalization for 2 tx antennas
+			((int16_t*)&txdataF[0][tti_offset])[0] += (int16_t)((((int16_t*)&tmp_sample1)[0]*ONE_OVER_SQRT2_Q15)>>15);
+			((int16_t*)&txdataF[0][tti_offset])[1] += (int16_t)((((int16_t*)&tmp_sample1)[1]*ONE_OVER_SQRT2_Q15)>>15);
+			((int16_t*)&txdataF[1][tti_offset])[0] += (int16_t)((((int16_t*)&tmp_sample2)[0]*ONE_OVER_SQRT2_Q15)>>15);
+			((int16_t*)&txdataF[1][tti_offset])[1] += (int16_t)((((int16_t*)&tmp_sample2)[1]*ONE_OVER_SQRT2_Q15)>>15);
+
+			// fill in the rest of the ALAMOUTI precoding
+			if ( pilots != 1 || (re+1)%3 != id_offset) {
+				((int16_t *)&txdataF[0][tti_offset+1])[0] += -((int16_t *)&txdataF[1][tti_offset])[0]; //x1
+				((int16_t *)&txdataF[0][tti_offset+1])[1] += ((int16_t *)&txdataF[1][tti_offset])[1];
+				((int16_t *)&txdataF[1][tti_offset+1])[0] += ((int16_t *)&txdataF[0][tti_offset])[0];  //x0*
+				((int16_t *)&txdataF[1][tti_offset+1])[1] += -((int16_t *)&txdataF[0][tti_offset])[1];
+			} else {
+				((int16_t *)&txdataF[0][tti_offset+2])[0] += -((int16_t *)&txdataF[1][tti_offset])[0]; //x1
+				((int16_t *)&txdataF[0][tti_offset+2])[1] += ((int16_t *)&txdataF[1][tti_offset])[1];
+				((int16_t *)&txdataF[1][tti_offset+2])[0] += ((int16_t *)&txdataF[0][tti_offset])[0];  //x0*
+				((int16_t *)&txdataF[1][tti_offset+2])[1] += -((int16_t *)&txdataF[0][tti_offset])[1];
+		
+				re++;														// skip pilots
+				*re_allocated = *re_allocated + 1;
+			}
+			re++;  															// adjacent carriers are taken care of by precoding
+			*re_allocated = *re_allocated + 1;   							// incremented variable but never used
+		}
+    }
+  }
+
+  return(0);
+}
+
+
+int dlsch_modulation_NB_IoT(int32_t **txdataF,
+							int16_t amp,
+							NB_IOT_DL_FRAME_PARMS *frame_parms,
+							uint8_t control_region_size,                          // control region size for LTE , values between 0..3, (0 for stand-alone / 1, 2 or 3 for in-band)
+							NB_IoT_eNB_DLSCH_t *dlsch0,
+							int G,												// number of bits per subframe
+							unsigned npdsch_data_subframe,							// subframe index of the data table of npdsch channel (G*Nsf)  , values are between 0..Nsf  			
+							unsigned short NB_IoT_RB_ID)
+{
+    //uint8_t harq_pid = dlsch0->current_harq_pid;
+    //NB_IoT_DL_eNB_HARQ_t *dlsch0_harq = dlsch0->harq_processes[harq_pid];
+    uint32_t jj=0;
+	uint32_t re_allocated,symbol_offset;
+    uint16_t l;
+    uint8_t id_offset,pilots=0; 
+	unsigned short bandwidth_even_odd;
+    unsigned short NB_IoT_start, RB_IoT_ID;
+    re_allocated=0;
+	id_offset=0;
+	// testing if the total number of RBs is even or odd 
+		bandwidth_even_odd = frame_parms->N_RB_DL % 2; 	 	// 0 even, 1 odd
+		RB_IoT_ID = NB_IoT_RB_ID;
+	// step  5, 6, 7   									 	// modulation and mapping (slot 1, symbols 0..3)
+	for (l=control_region_size; l<14; l++) { 								 	// loop on OFDM symbols	
+		if((l>=4 && l<=8) || (l>=11 && l<=13))
+		{
+			pilots =1;
+		} else {
+			pilots=0;
+		}
+		id_offset = frame_parms->Nid_cell % 3;    			// Cell_ID_NB_IoT % 3
+		if(RB_IoT_ID < (frame_parms->N_RB_DL/2))
+		{
+			NB_IoT_start = frame_parms->ofdm_symbol_size - 12*(frame_parms->N_RB_DL/2) - (bandwidth_even_odd*6) + 12*(RB_IoT_ID%(ceil(frame_parms->N_RB_DL/(float)2)));
+		} else {
+			NB_IoT_start = (bandwidth_even_odd*6) + 12*(RB_IoT_ID%(ceil(frame_parms->N_RB_DL/(float)2)));
+		}
+		symbol_offset = frame_parms->ofdm_symbol_size*l + NB_IoT_start;  						// symbol_offset = 512 * L + NB_IOT_RB start
+		allocate_REs_in_RB_NB_IoT(frame_parms,
+								txdataF,
+								&jj,
+								symbol_offset,
+								&dlsch0->harq_processes->s_e[G*npdsch_data_subframe],
+								pilots,
+								amp,
+								id_offset,
+								&re_allocated);
+	}
+	
+ // VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_DLSCH_MODULATION, VCD_FUNCTION_OUT);
+  return (re_allocated);
+}

openair1/PHY/LTE_TRANSPORT/dlsch_scrambling_NB_IoT.c

+/*******************************************************************************
+
+ *******************************************************************************/
+/*! \file PHY/LTE_TRANSPORT/dlsch_scrambling_NB_IoT.c
+* \brief Routines for the scrambling procedure of the NPDSCH physical channel for NB_IoT,	 TS 36-211, V13.4.0 2017-02
+* \author M. KANJ
+* \date 2017
+* \version 0.0
+* \company bcom
+* \email: matthieu.kanj@b-com.com
+* \note
+* \warning
+*/
+
+//#define DEBUG_SCRAMBLING 1
+
+#include "PHY/defs.h"
+#include "PHY/CODING/extern.h"
+#include "PHY/CODING/lte_interleaver_inline.h"
+#include "defs.h"
+#include "extern.h"
+#include "PHY/extern.h"
+#include "UTIL/LOG/vcd_signal_dumper.h"
+
+#include "defs_NB_IoT.h"
+
+void dlsch_scrambling_NB_IoT(NB_IOT_DL_FRAME_PARMS *frame_parms,
+							 NB_IoT_eNB_DLSCH_t *dlsch,
+							 int G,        							// total number of bits to transmit
+							 uint8_t Nf,   							// Nf is the frame number (0..9)
+							 uint8_t Ns)							// slot number (0..19)
+{
+  int i,j,k=0;
+  uint32_t x1, x2, s=0;
+  uint8_t *e=dlsch->harq_processes->e; 															//uint8_t *e=dlsch->harq_processes[dlsch->current_harq_pid]->e;
+
+  x2 = (dlsch->rnti<<14) + ((Nf%2)<<13) + ((Ns>>1)<<9) + frame_parms->Nid_cell;                    //this is c_init in 36.211 Sec 10.2.3.1
+  
+  s = lte_gold_generic_NB_IoT(&x1, &x2, 1);
+
+  for (i=0; i<(1+(G>>5)); i++) {
+
+    for (j=0; j<32; j++,k++) {
+
+      dlsch->s_e[k] = (e[k]&1) ^ ((s>>j)&1);
+
+    }
+    s = lte_gold_generic_NB_IoT(&x1, &x2, 0);
+  }
+
+}