add csi data cap

cmake_targets/output_type.txt

+csi
\ No newline at end of file

cmake_targets/test_csi_data.m

+close all;
+clear all;
+
+ssb_len = 240;
+
+fileid = fopen('csi_params_0.am');
+params = fread(fileid, 'short');
+fclose(fileid);
+
+num_perrb = params(end);
+freq_density = params(end-1);
+l_prime = params(end-2);
+k_prime = params(end-3);
+CDM_group_size = params(end-4);
+N_cdm_groups = params(end-5);
+nr_of_rbs = params(end-6);
+start_rb = params(end-7);
+nb_antennas_rx = params(end-8);
+
+num_per_rb = (l_prime+1)*(k_prime+1)*CDM_group_size*N_cdm_groups;
+num_per_rb_port = (l_prime+1)*(k_prime+1);
+port_num = CDM_group_size*N_cdm_groups;
+
+fileid = fopen('csi_data_0.am');
+aa = fread(fileid, 'short');
+fclose(fileid);
+aa_c = complex(aa(1:2:end), aa(2:2:end));
+len_aa = length(aa_c);
+
+aa_s = reshape(aa_c, 3,[]);
+tx_csi_data = aa_s(1,:);
+rx_csi_data = aa_s(2,:);
+ch_csi_data = aa_s(3,:);
+
+temp_data = params(1:num_perrb);
+pos_port = (reshape(temp_data,num_per_rb_port*2,[])).';
+
+
+
+tx_csi_data_s = reshape(tx_csi_data,num_per_rb,[]);
+rx_csi_data_s = reshape(rx_csi_data,num_per_rb,[]);
+ch_csi_data_s = reshape(ch_csi_data,num_per_rb,[]);
+
+tx_csi_data_port =zeros(port_num, len_aa/3/port_num);
+rx_csi_data_port =zeros(port_num, len_aa/3/port_num);
+ch_csi_data_port =zeros(port_num, len_aa/3/port_num);
+for p = 1:port_num
+  temp_data = tx_csi_data_s((p-1)*num_per_rb_port+1:p*num_per_rb_port,:);
+  tx_csi_data_port(p,:) = temp_data(:).';
+
+  temp_data = rx_csi_data_s((p-1)*num_per_rb_port+1:p*num_per_rb_port,:);
+  rx_csi_data_port(p,:) = temp_data(:).';
+
+  temp_data = ch_csi_data_s((p-1)*num_per_rb_port+1:p*num_per_rb_port,:);
+  ch_csi_data_port(p,:) = temp_data(:).';
+end
+
+ch_00 = ch_csi_data_port(1,1:num_per_rb_port * nr_of_rbs);
+ch_01 = ch_csi_data_port(1,num_per_rb_port * nr_of_rbs+1:end);
+ch_10 = ch_csi_data_port(2,1:num_per_rb_port * nr_of_rbs);
+ch_11 = ch_csi_data_port(2,num_per_rb_port * nr_of_rbs+1:end);
+
+ch_00_time = ifft(ch_00);
+ch_01_time = ifft(ch_01);
+ch_10_time = ifft(ch_10);
+ch_11_time = ifft(ch_11);
+
+
+figure;
+plot(abs(ch_00),'bo-');
+hold on;
+plot(abs(ch_01),'r*-');
+hold on;
+plot(abs(ch_10),'go-');
+hold on;
+plot(abs(ch_11),'mo-');
+hold on;
+grid on;
+
+
+figure;
+subplot(2,2,1);
+plot(abs(ch_00_time),'bo-');
+hold on;
+subplot(2,2,2);
+plot(abs(ch_01_time),'r*-');
+hold on;
+subplot(2,2,3);
+plot(abs(ch_10_time),'go-');
+hold on;
+subplot(2,2,4);
+plot(abs(ch_11_time),'mo-');
+hold on;
+grid on;
+
+
+

executables/cap-interface.c

@@ -15,7 +15,8 @@ sem_t ric_send_sem;
 
 int ric_ssb_buf[RIC_SSB_LEN];
 int g_output_period = 1;
-
+int g_output_flag = 0;
+int g_output_type = 0;
 /*
 gcc -o ric_s ric-interface.c -DRIC_TEST_SERVER -pthread
 */
@@ -42,13 +43,44 @@ void *ric_interface_task(void *args_p)
 		    g_output_period = (c - '0') * 2;
 		
 		fclose(input_fd);
+		printf("ssb/csi output_period %d\n", g_output_period);
 	}
 
-	sprintf(filename,"ssb_data_%d.am",0);
-	output_fd = fopen(filename,"w+");
-	fclose(output_fd);
-
-    printf("ssb output_period %d\n", g_output_period);
+	input_fd = fopen("output_type.txt","r");
+    if (input_fd==NULL){
+		printf("Error opening0 \n");				       
+	}
+	else
+	{
+		char cc[3];
+		cc[0] = fgetc(input_fd);
+		cc[1] = fgetc(input_fd);
+		cc[2] = fgetc(input_fd);
+
+        if ((cc[0] == 's') && (cc[1] == 's') && (cc[2] == 'b'))
+		{
+			g_output_type = 1; // ssb
+			fclose(input_fd);
+
+			sprintf(filename,"ssb_data_%d.am",0);
+			output_fd = fopen(filename,"w+");
+			fclose(output_fd);
+		}
+		else if ((cc[0] == 'c') && (cc[1] == 's') && (cc[2] == 'i'))
+		{
+			g_output_type = 2; // csi
+            fclose(input_fd);
+            
+			sprintf(filename,"csi_data_%d.am",0);
+			output_fd = fopen(filename,"w+");
+			fclose(output_fd);
+
+			sprintf(filename,"csi_params_%d.am",0);
+			output_fd = fopen(filename,"w+");
+			fclose(output_fd);
+		}		
+	}
+    
     while(1)
     {
         sem_wait (&ric_send_sem);  
@@ -77,17 +109,51 @@ void *ric_interface_task(void *args_p)
 
 			if (outputdata == 1)
 			{
-	            sprintf(filename,"ssb_data_%d.am",0);
-                output_fd = fopen(filename,"a+");
-				if (output_fd==NULL){
-				printf("Error opening1 \n");
+				if (g_output_type == 1)
+				{
+					sprintf(filename,"ssb_data_%d.am",0);
+					output_fd = fopen(filename,"a+");
+					if (output_fd==NULL){
+					printf("Error opening1 \n");
+					}
+
+					if (output_fd) {
+						printf("log ssb data, cnt %d\n", cnt);
+						fwrite(ric_ssb_buf,sizeof(int), RIC_SSB_LEN, output_fd);
+					fclose(output_fd);
+					}
 				}
+				else if (g_output_type == 2)
+				{
+					static int log_params_first = 0;
+					sprintf(filename,"csi_data_%d.am",0);
+					output_fd = fopen(filename,"a+");
+					if (output_fd==NULL){
+					printf("Error opening1 \n");
+					}
+
+					if (output_fd) {
+						printf("log csi data, cnt %d\n", cnt);
+						fwrite(g_csi_data,sizeof(short), g_csi_data_num, output_fd);
+					fclose(output_fd);
+					}
+
+					if (log_params_first == 0)
+					{
+						log_params_first++;
+						sprintf(filename,"csi_params_%d.am",0);
+						output_fd = fopen(filename,"a+");
+						if (output_fd==NULL){
+						printf("Error opening1 \n");
+						}
 
-				if (output_fd) {
-					printf("log ssb data, cnt %d\n", cnt);
-					fwrite(ric_ssb_buf,sizeof(int), RIC_SSB_LEN, output_fd);
-				fclose(output_fd);
-			    }
+						if (output_fd) {
+							printf("log csi paras, cnt %d\n", cnt);
+							fwrite(g_csi_params, sizeof(short), g_csi_params_num, output_fd);
+						fclose(output_fd);
+						}
+					}
+				}
 
 			}
 			cnt++;

executables/cap-interface.h

@@ -6,5 +6,11 @@
 extern int ric_ssb_buf[];
 extern sem_t ric_send_sem;
 extern int g_output_period;
+extern int g_output_type;
+
+extern short g_csi_data[];
+extern short g_csi_params[];
+extern int g_csi_data_num;
+extern int g_csi_params_num;
 
 extern void    *ric_interface_task(void *args_p);
\ No newline at end of file

openair1/PHY/NR_TRANSPORT/nr_csi_rs.c

@@ -159,6 +159,7 @@ void nr_generate_csi_rs(const NR_DL_FRAME_PARMS *frame_parms,
       j[i] = 0;
       loverline[i] = csi_params->symb_l0;
       koverline[i] = k_n[0];
+      LOG_I(PHY,"loverline %d, koverline %d\n", loverline[i], koverline[i]);
     }
     break;
 

openair1/PHY/NR_UE_TRANSPORT/csi_rx.c

@@ -39,6 +39,7 @@
 #include "common/utils/nr/nr_common.h"
 #include "PHY/NR_TRANSPORT/nr_transport_proto.h"
 #include "PHY/NR_UE_ESTIMATION/filt16a_32.h"
+#include "executables/cap-interface.h"
 
 // 10*log10(pow(2,30))
 #define pow_2_30_dB 90
@@ -280,6 +281,11 @@ uint32_t calc_power_csirs(const uint16_t *x, const fapi_nr_dl_config_csirs_pdu_r
   return sum_x2 / size - (sum_x / size) * (sum_x / size);
 }
 
+#define MAX_CSI_LEN 6552
+short g_csi_data[MAX_CSI_LEN*6];
+short g_csi_params[256];
+int g_csi_data_num = 0;
+int g_csi_params_num = 0;
 int nr_csi_rs_channel_estimation(const PHY_VARS_NR_UE *ue,
                                  const UE_nr_rxtx_proc_t *proc,
                                  const fapi_nr_dl_config_csirs_pdu_rel15_t *csirs_config_pdu,
@@ -306,7 +312,12 @@ int nr_csi_rs_channel_estimation(const PHY_VARS_NR_UE *ue,
   *noise_power = 0;
   int maxh = 0;
   int count = 0;
+  static int s_log_cnt = 0;
+  int tmp_id = 0;
+  int tmp_id_rb = 0;
 
+  LOG_I(NR_PHY, "frame %d %d, ch est ant_rx %d, ports %d, rbs %d groups %d, ingroups %d, kprime %d, lprime %d,g_output_period %d\n", proc->frame_rx, proc->nr_slot_rx,
+      frame_parms->nb_antennas_rx, N_ports, csirs_config_pdu->nr_of_rbs, N_cdm_groups, CDM_group_size, k_prime, l_prime ,g_output_period);
   for (int ant_rx = 0; ant_rx < frame_parms->nb_antennas_rx; ant_rx++) {
 
     /// LS channel estimation
@@ -348,10 +359,62 @@ int nr_csi_rs_channel_estimation(const PHY_VARS_NR_UE *ue,
               // for the sake of optimizing the memory used.
               csi_rs_ls_estimated_channel16[kinit].r += csi_rs_ls_estimated_channel_re;
               csi_rs_ls_estimated_channel16[kinit].i += csi_rs_ls_estimated_channel_im;
+
+              if ((g_output_period!=0) && ((s_log_cnt%g_output_period)==0) && (g_output_type == 2))
+              {
+                #if 1
+                g_csi_data[tmp_id] = tx_csi_rs_signal[k].r;
+                g_csi_data[tmp_id+1] = tx_csi_rs_signal[k].i;
+                g_csi_data[tmp_id+2] = rx_csi_rs_signal[k].r;
+                g_csi_data[tmp_id+3] = rx_csi_rs_signal[k].i;
+                g_csi_data[tmp_id+4] = csi_rs_ls_estimated_channel_re;
+                g_csi_data[tmp_id+5] = csi_rs_ls_estimated_channel_im;
+                #endif
+                if ((ant_rx == 0) && (rb == csirs_config_pdu->start_rb) && (s_log_cnt == 0))
+                {
+
+                  g_csi_params[tmp_id_rb] = symb;
+                  g_csi_params[tmp_id_rb+1] = k_overline[cdm_id] + kp;
+                  tmp_id_rb += 2;
+                  LOG_I(PHY, "cdm_id %d, s %d, l_overline %d k_overline %d, symb %d\n", cdm_id,s,l_overline[cdm_id],k_overline[cdm_id], symb);
+                }
+                tmp_id += 6;
+              }
+
             }
           }
         }
       }
+      //LOG_I(NR_PHY, "tmp_id %d, tmp_id_rb %d\n", tmp_id, tmp_id_rb);
+      if ((ant_rx == frame_parms->nb_antennas_rx-1) && (rb == (csirs_config_pdu->start_rb+csirs_config_pdu->nr_of_rbs)-1))
+      {
+        if ((g_output_period!=0) && ((s_log_cnt%g_output_period)==0) && (g_output_type == 2))
+        {
+          if (s_log_cnt == 0)
+          {
+            #if 1
+            AssertFatal(tmp_id_rb * frame_parms->nb_antennas_rx *csirs_config_pdu->nr_of_rbs <= MAX_CSI_LEN, "csi output buff overflow\n");
+            g_csi_params[tmp_id_rb] = 255;
+            g_csi_params[tmp_id_rb+1] = frame_parms->nb_antennas_rx;
+            g_csi_params[tmp_id_rb+2] = csirs_config_pdu->start_rb;
+            g_csi_params[tmp_id_rb+3] = csirs_config_pdu->nr_of_rbs;
+            g_csi_params[tmp_id_rb+4] = N_cdm_groups;
+            g_csi_params[tmp_id_rb+5] = CDM_group_size;
+            g_csi_params[tmp_id_rb+6] = k_prime;
+            g_csi_params[tmp_id_rb+7] = l_prime;
+            g_csi_params[tmp_id_rb+8] = csirs_config_pdu->freq_density;
+            g_csi_params[tmp_id_rb+9] = tmp_id_rb;   
+            g_csi_params_num =  tmp_id_rb+10;
+            g_csi_data_num = tmp_id;
+            #endif
+          }
+          sem_post(&ric_send_sem);  
+          LOG_I(PHY, "frame %d %d, csi output period %d, send cnt %d, num %d %d\n", 
+          proc->frame_rx, proc->nr_slot_rx, g_output_period, s_log_cnt, g_csi_params_num, g_csi_data_num);
+        }
+        s_log_cnt++;
+      }
+
     }
 
 #ifdef NR_CSIRS_DEBUG
@@ -862,7 +925,7 @@ void nr_ue_csi_rs_procedures(PHY_VARS_NR_UE *ue, UE_nr_rxtx_proc_t *proc, c16_t
 
   const fapi_nr_dl_config_csirs_pdu_rel15_t *csirs_config_pdu = &ue->csirs_vars[gNB_id]->csirs_config_pdu;
 
-#ifdef NR_CSIRS_DEBUG
+//#ifdef NR_CSIRS_DEBUG
   LOG_I(NR_PHY, "csirs_config_pdu->subcarrier_spacing = %i\n", csirs_config_pdu->subcarrier_spacing);
   LOG_I(NR_PHY, "csirs_config_pdu->cyclic_prefix = %i\n", csirs_config_pdu->cyclic_prefix);
   LOG_I(NR_PHY, "csirs_config_pdu->start_rb = %i\n", csirs_config_pdu->start_rb);
@@ -877,13 +940,15 @@ void nr_ue_csi_rs_procedures(PHY_VARS_NR_UE *ue, UE_nr_rxtx_proc_t *proc, c16_t
   LOG_I(NR_PHY, "csirs_config_pdu->scramb_id = %i\n", csirs_config_pdu->scramb_id);
   LOG_I(NR_PHY, "csirs_config_pdu->power_control_offset = %i\n", csirs_config_pdu->power_control_offset);
   LOG_I(NR_PHY, "csirs_config_pdu->power_control_offset_ss = %i\n", csirs_config_pdu->power_control_offset_ss);
-#endif
+//#endif
 
   if(csirs_config_pdu->measurement_bitmap == 0) {
     LOG_E(NR_PHY, "Handling of CSI-RS for tracking not handled yet at PHY\n");
     return;
   }
 
+  LOG_I(NR_PHY, "csirs_config_pdu->measurement_bitmap %d\n", csirs_config_pdu->measurement_bitmap);
+
   const NR_DL_FRAME_PARMS *frame_parms = &ue->frame_parms;
   int32_t csi_rs_received_signal[frame_parms->nb_antennas_rx][frame_parms->samples_per_slot_wCP];
   uint8_t N_cdm_groups = 0;
@@ -946,7 +1011,7 @@ void nr_ue_csi_rs_procedures(PHY_VARS_NR_UE *ue, UE_nr_rxtx_proc_t *proc, c16_t
 
 
   // if we need to measure only RSRP no need to do channel estimation
-  if (csirs_config_pdu->measurement_bitmap > 1)
+  //if (csirs_config_pdu->measurement_bitmap > 1)
     nr_csi_rs_channel_estimation(ue,
                                  proc,
                                  csirs_config_pdu,

openair1/SCHED_NR_UE/phy_procedures_nr_ue.c

@@ -926,37 +926,39 @@ void pbch_pdcch_processing(PHY_VARS_NR_UE *ue,
             }
             ue->apply_timing_offset = true;
              
-           if ((g_output_period!=0) && ((s_log_cnt%g_output_period)==0) )
+           if (g_output_type == 1)
            {
-              int sc_start = (fp->first_carrier_offset + fp->ssb_start_subcarrier) % fp->ofdm_symbol_size;
-              int left_num, right_num;
-              if(sc_start + 240 > fp->ofdm_symbol_size)
-              { 
-                 left_num = fp->ofdm_symbol_size -  sc_start;
-                 right_num = 240 - left_num;     
-              }
-              else{
-                left_num = 240;
-                right_num = 0;
-              }
-              for (int ii = 0; ii < 4; ii++)
+              if ((g_output_period!=0) && ((s_log_cnt%g_output_period)==0) )
               {
-                  memcpy(&ric_ssb_buf[240*ii], &rxdataF[0][(ssb_start_symbol+ii)%(fp->symbols_per_slot)*fp->ofdm_symbol_size + sc_start], left_num*4);
-                  if (right_num > 0)
+                  int sc_start = (fp->first_carrier_offset + fp->ssb_start_subcarrier) % fp->ofdm_symbol_size;
+                  int left_num, right_num;
+                  if(sc_start + 240 > fp->ofdm_symbol_size)
+                  { 
+                    left_num = fp->ofdm_symbol_size -  sc_start;
+                    right_num = 240 - left_num;     
+                  }
+                  else{
+                    left_num = 240;
+                    right_num = 0;
+                  }
+                  for (int ii = 0; ii < 4; ii++)
                   {
-                     memcpy(&ric_ssb_buf[240*ii+left_num], &rxdataF[0][(ssb_start_symbol+ii)%(fp->symbols_per_slot)*fp->ofdm_symbol_size], right_num*4);
+                      memcpy(&ric_ssb_buf[240*ii], &rxdataF[0][(ssb_start_symbol+ii)%(fp->symbols_per_slot)*fp->ofdm_symbol_size + sc_start], left_num*4);
+                      if (right_num > 0)
+                      {
+                        memcpy(&ric_ssb_buf[240*ii+left_num], &rxdataF[0][(ssb_start_symbol+ii)%(fp->symbols_per_slot)*fp->ofdm_symbol_size], right_num*4);
+                      }
                   }
-              }
-              for (int ii = 1; ii < 4; ii++)
-              {
-                  memcpy(&ric_ssb_buf[240*(4+ii-1)], &dl_ch_estimates[0][(ssb_start_symbol+ii)%(fp->symbols_per_slot)*fp->ofdm_symbol_size], 240*4);
-              }
-              sem_post(&ric_send_sem);  
-              LOG_I(PHY, "frame %d %d, ssb_slot %d %d, ssb_index %d, ssb_start_symbol %d,  ssb_sc_start %d , cell id %d cnt %d, rscp %d\n", 
-                     frame_rx, nr_slot_rx, ssb_slot, ssb_slot_2, ssb_index, ssb_start_symbol, sc_start, fp->Nid_cell, s_log_cnt, ue->measurements.ssb_rsrp_dBm[ssb_index]);
-            }
-            s_log_cnt++;
-
+                  for (int ii = 1; ii < 4; ii++)
+                  {
+                      memcpy(&ric_ssb_buf[240*(4+ii-1)], &dl_ch_estimates[0][(ssb_start_symbol+ii)%(fp->symbols_per_slot)*fp->ofdm_symbol_size], 240*4);
+                  }
+                  sem_post(&ric_send_sem);  
+                  LOG_I(PHY, "frame %d %d, ssb_slot %d %d, ssb_index %d, ssb_start_symbol %d,  ssb_sc_start %d , cell id %d cnt %d, rscp %d\n", 
+                        frame_rx, nr_slot_rx, ssb_slot, ssb_slot_2, ssb_index, ssb_start_symbol, sc_start, fp->Nid_cell, s_log_cnt, ue->measurements.ssb_rsrp_dBm[ssb_index]);
+                }
+                s_log_cnt++;
+           }
           }
           LOG_D(PHY, "Doing N0 measurements in %s\n", __FUNCTION__);
           nr_ue_rrc_measurements(ue, proc, rxdataF);

openair2/LAYER2/NR_MAC_UE/nr_ue_procedures.c

@@ -63,6 +63,8 @@
 //#define DEBUG_EXTRACT_DCI
 //#define DEBUG_RAR
 
+extern int g_output_type;
+
 extern uint32_t N_RB_DL;
 
 /* TS 38.213 9.2.5.2 UE procedure for multiplexing HARQ-ACK/SR and CSI in a PUCCH */
@@ -267,7 +269,7 @@ void nr_ue_decode_mib(module_id_t module_id, int cc_id)
   }
 
 //#ifdef DEBUG_MIB
-  if ((mac->mib_frame %64) == 0)
+  if (((mac->mib_frame %64) == 0) && (g_output_type == 1))
   {
   uint8_t half_frame_bit = (extra_bits >> 4) & 0x1; //	extra bits[4]
   LOG_I(MAC,"system frame number(6 MSB bits): %d\n",  mac->mib->systemFrameNumber.buf[0]);