add T-Tracer: SRS data collection

CMakeLists.txt

@@ -710,6 +710,7 @@ set(SCHED_NR_SRC
   ${OPENAIR1_DIR}/SCHED_NR/phy_procedures_nr_gNB.c
   ${OPENAIR1_DIR}/SCHED_NR/nr_prach_procedures.c
   ${OPENAIR1_DIR}/SCHED_NR/phy_frame_config_nr.c
+  ${OPENAIR1_DIR}/SCHED_NR/nr_srs_capture.c
 )
 add_library(SCHED_NR_LIB ${SCHED_NR_SRC})
 target_link_libraries(SCHED_NR_LIB PRIVATE asn1_nr_rrc_hdrs UTIL)

common/utils/T/T_messages.txt

@@ -159,6 +159,14 @@ ID = GNB_PHY_UL_SRS_TOA_NS
     DESC = gNB ToA estimate from SRS (in ns)
     GROUP = ALL:PHY:GNB
     FORMAT = int,gNB_ID : int,rnti : int,frame : int,subframe : buffer,toa_ns
+ID = GNB_PHY_UL_SRS_GENERATED_SIGNAL
+    DESC = gNB SRS reference signal generated by generate_srs_nr (frequency domain, per SRS port)
+    GROUP = ALL:PHY:GRAPHIC:HEAVY:GNB
+    FORMAT = int,gNB_ID : int,rnti : int,frame : int,slot : int,port : buffer,srs_generated
+ID = GNB_PHY_UL_SRS_RECEIVED_SIGNAL
+    DESC = gNB SRS received signal extracted by nr_get_srs_signal (frequency domain, per RX antenna)
+    GROUP = ALL:PHY:GRAPHIC:HEAVY:GNB
+    FORMAT = int,gNB_ID : int,rnti : int,frame : int,slot : int,antenna : buffer,srs_received
 
 #MAC logs
 ID = ENB_MAC_UE_DL_SDU

executables/data_transfer.c

@@ -13,10 +13,12 @@
 #include "openair2/RRC/NR/rrc_gNB_UE_context.h"  // need to get imsi from RRC
 #include "softmodem-common.h"
 #include "cJSON.h"
+#include "openair1/SCHED_NR/nr_srs_capture.h"
+#include "common/config/config_userapi.h"
 
 extern RAN_CONTEXT_t RC;
 
-#define PORT 8888
+#define DEFAULT_HTTP_PORT 8888
 
 int rb = 0;
 // 构造 HTTP 响应的函数
@@ -72,9 +74,92 @@ int answer_to_connection(void *cls, struct MHD_Connection *connection,
                          const char *version, const char *upload_data,
                          size_t *upload_data_size, void **con_cls)
 {
-    (void)cls; (void)method; (void)version; (void)upload_data; (void)upload_data_size; (void)con_cls;
+    (void)cls; (void)version; (void)upload_data; (void)upload_data_size; (void)con_cls;
+
+    /* ---- SRS capture control (zero-loss file dump inside gNB) ---- */
+    if (strcmp(url, "/srs/capture/start") == 0) {
+        if (strcmp(method, "GET") != 0 && strcmp(method, "POST") != 0) {
+            const char *json = "{\"error\":\"method not allowed\"}";
+            struct MHD_Response *response = MHD_create_response_from_buffer(strlen(json), (void *)json, MHD_RESPMEM_MUST_COPY);
+            MHD_add_response_header(response, "Content-Type", "application/json");
+            int ret = MHD_queue_response(connection, MHD_HTTP_METHOD_NOT_ALLOWED, response);
+            MHD_destroy_response(response);
+            return ret;
+        }
+        const char *count_s = MHD_lookup_connection_value(connection, MHD_GET_ARGUMENT_KIND, "count");
+        uint32_t max_occasions = 0;
+        if (count_s && count_s[0])
+            max_occasions = (uint32_t)strtoul(count_s, NULL, 10);
+
+        int rc = nr_srs_capture_start(max_occasions);
+        nr_srs_capture_status_t st;
+        nr_srs_capture_get_status(&st);
+        cJSON *obj = cJSON_CreateObject();
+        cJSON_AddStringToObject(obj, "ok", rc == 0 ? "true" : "false");
+        cJSON_AddNumberToObject(obj, "rc", rc);
+        cJSON_AddNumberToObject(obj, "state", st.state);
+        cJSON_AddNumberToObject(obj, "captured", st.captured);
+        cJSON_AddNumberToObject(obj, "max_occasions", st.max_occasions);
+        cJSON_AddStringToObject(obj, "generate_path", st.generate_path);
+        cJSON_AddStringToObject(obj, "receive_path", st.receive_path);
+        if (st.last_error[0])
+            cJSON_AddStringToObject(obj, "error", st.last_error);
+        char *json_string = cJSON_PrintUnformatted(obj);
+        int ret = send_json_response(connection, json_string ? json_string : "{\"error\":\"oom\"}");
+        if (json_string)
+            free(json_string);
+        cJSON_Delete(obj);
+        return ret;
+    }
+
+    if (strcmp(url, "/srs/capture/stop") == 0) {
+        if (strcmp(method, "GET") != 0 && strcmp(method, "POST") != 0) {
+            const char *json = "{\"error\":\"method not allowed\"}";
+            struct MHD_Response *response = MHD_create_response_from_buffer(strlen(json), (void *)json, MHD_RESPMEM_MUST_COPY);
+            MHD_add_response_header(response, "Content-Type", "application/json");
+            int ret = MHD_queue_response(connection, MHD_HTTP_METHOD_NOT_ALLOWED, response);
+            MHD_destroy_response(response);
+            return ret;
+        }
+        nr_srs_capture_stop();
+        nr_srs_capture_status_t st;
+        nr_srs_capture_get_status(&st);
+        cJSON *obj = cJSON_CreateObject();
+        cJSON_AddStringToObject(obj, "ok", "true");
+        cJSON_AddNumberToObject(obj, "state", st.state);
+        cJSON_AddNumberToObject(obj, "captured", st.captured);
+        cJSON_AddStringToObject(obj, "generate_path", st.generate_path);
+        cJSON_AddStringToObject(obj, "receive_path", st.receive_path);
+        char *json_string = cJSON_PrintUnformatted(obj);
+        int ret = send_json_response(connection, json_string ? json_string : "{\"error\":\"oom\"}");
+        if (json_string)
+            free(json_string);
+        cJSON_Delete(obj);
+        return ret;
+    }
+
+    if (strcmp(url, "/srs/capture/status") == 0) {
+        nr_srs_capture_status_t st;
+        nr_srs_capture_get_status(&st);
+        cJSON *obj = cJSON_CreateObject();
+        cJSON_AddNumberToObject(obj, "state", st.state);
+        cJSON_AddStringToObject(obj, "state_name", st.state == NR_SRS_CAPTURE_RUNNING ? "running" : "idle");
+        cJSON_AddNumberToObject(obj, "captured", st.captured);
+        cJSON_AddNumberToObject(obj, "max_occasions", st.max_occasions);
+        cJSON_AddStringToObject(obj, "generate_path", st.generate_path);
+        cJSON_AddStringToObject(obj, "receive_path", st.receive_path);
+        if (st.last_error[0])
+            cJSON_AddStringToObject(obj, "error", st.last_error);
+        char *json_string = cJSON_PrintUnformatted(obj);
+        int ret = send_json_response(connection, json_string ? json_string : "{\"error\":\"oom\"}");
+        if (json_string)
+            free(json_string);
+        cJSON_Delete(obj);
+        return ret;
+    }
 
     if (strcmp(url, "/stats") == 0) {
+        (void)method;
         cJSON *root = cJSON_CreateArray();
         if (root == NULL) {
             return -1;
@@ -137,18 +222,39 @@ int answer_to_connection(void *cls, struct MHD_Connection *connection,
 
 struct MHD_Daemon *httpdaemon;
 
+static uint16_t get_http_port_from_gnb_conf(void)
+{
+  uint16_t port = DEFAULT_HTTP_PORT;
+  paramdef_t p[] = {
+      {"http_port",
+       "gNB HTTP API listen port (stats / SRS capture)",
+       0,
+       .uptr = &port,
+       .defuintval = DEFAULT_HTTP_PORT,
+       TYPE_UINT,
+       0},
+  };
+  if (config_get_if() != NULL)
+    config_get(config_get_if(), p, 1, "gNBs.[0]");
+  if (port == 0)
+    port = DEFAULT_HTTP_PORT;
+  return port;
+}
+
 int start_http_server(int dl_rb)
 {
     rb = dl_rb;
+    const uint16_t port = get_http_port_from_gnb_conf();
     httpdaemon = MHD_start_daemon(MHD_USE_INTERNAL_POLLING_THREAD,
-                              PORT,
+                              port,
                               NULL, NULL,
                               &answer_to_connection, NULL,
                               MHD_OPTION_END);
     if (httpdaemon == NULL) {
-        fprintf(stderr, "Failed to start HTTP server\n");
+        fprintf(stderr, "Failed to start HTTP server on port %u\n", (unsigned)port);
         return 1;
     }
+    printf("gNB HTTP server listening on port %u\n", (unsigned)port);
 
     return 0;
 }

openair1/SCHED_NR/nr_srs_capture.c

+/*
+ * SPDX-License-Identifier: LicenseRef-CSSL-1.0
+ */
+
+#include "nr_srs_capture.h"
+
+#include <errno.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdatomic.h>
+
+#include "common/utils/LOG/log.h"
+
+typedef struct {
+  uint32_t magic;
+  uint16_t frame;
+  uint16_t slot;
+  uint16_t rnti;
+  uint16_t ofdm_symbol_size;
+  uint8_t nb_antennas_rx;
+  uint8_t N_ap;
+  uint8_t N_symb_SRS;
+  uint8_t reserved;
+} nr_srs_capture_rec_hdr_t;
+
+static atomic_int g_srs_capture_state = ATOMIC_VAR_INIT(NR_SRS_CAPTURE_IDLE);
+static pthread_mutex_t g_srs_capture_mutex = PTHREAD_MUTEX_INITIALIZER;
+static FILE *g_fp_gen = NULL;
+static FILE *g_fp_rx = NULL;
+static uint32_t g_captured = 0;
+static uint32_t g_max_occasions = 0;
+static char g_last_error[128] = "";
+
+int get_srs_capture_status(void)
+{
+  return atomic_load(&g_srs_capture_state);
+}
+
+void set_srs_capture_status(int state)
+{
+  atomic_store(&g_srs_capture_state, state);
+}
+
+static void set_error_locked(const char *msg)
+{
+  snprintf(g_last_error, sizeof(g_last_error), "%s", msg ? msg : "");
+}
+
+static void close_files_locked(void)
+{
+  if (g_fp_gen) {
+    fflush(g_fp_gen);
+    fclose(g_fp_gen);
+    g_fp_gen = NULL;
+  }
+  if (g_fp_rx) {
+    fflush(g_fp_rx);
+    fclose(g_fp_rx);
+    g_fp_rx = NULL;
+  }
+}
+
+void nr_srs_capture_get_status(nr_srs_capture_status_t *out)
+{
+  if (!out)
+    return;
+  memset(out, 0, sizeof(*out));
+  pthread_mutex_lock(&g_srs_capture_mutex);
+  out->state = atomic_load(&g_srs_capture_state);
+  out->captured = g_captured;
+  out->max_occasions = g_max_occasions;
+  out->generate_path = OPENXG_SRS_CAPTURE_GENERATE_PATH;
+  out->receive_path = OPENXG_SRS_CAPTURE_RECEIVE_PATH;
+  snprintf(out->last_error, sizeof(out->last_error), "%s", g_last_error);
+  pthread_mutex_unlock(&g_srs_capture_mutex);
+}
+
+int nr_srs_capture_start(uint32_t max_occasions)
+{
+  pthread_mutex_lock(&g_srs_capture_mutex);
+  if (atomic_load(&g_srs_capture_state) == NR_SRS_CAPTURE_RUNNING) {
+    pthread_mutex_unlock(&g_srs_capture_mutex);
+    return 0; /* already running */
+  }
+
+  close_files_locked();
+  set_error_locked("");
+
+  g_fp_gen = fopen(OPENXG_SRS_CAPTURE_GENERATE_PATH, "wb");
+  if (!g_fp_gen) {
+    snprintf(g_last_error, sizeof(g_last_error), "open generate failed: %s", strerror(errno));
+    pthread_mutex_unlock(&g_srs_capture_mutex);
+    LOG_E(PHY, "SRS capture: %s\n", g_last_error);
+    return -1;
+  }
+  g_fp_rx = fopen(OPENXG_SRS_CAPTURE_RECEIVE_PATH, "wb");
+  if (!g_fp_rx) {
+    snprintf(g_last_error, sizeof(g_last_error), "open receive failed: %s", strerror(errno));
+    fclose(g_fp_gen);
+    g_fp_gen = NULL;
+    pthread_mutex_unlock(&g_srs_capture_mutex);
+    LOG_E(PHY, "SRS capture: %s\n", g_last_error);
+    return -1;
+  }
+
+  uint32_t file_magic = NR_SRS_CAPTURE_FILE_MAGIC;
+  if (fwrite(&file_magic, sizeof(file_magic), 1, g_fp_gen) != 1
+      || fwrite(&file_magic, sizeof(file_magic), 1, g_fp_rx) != 1) {
+    set_error_locked("write file magic failed");
+    close_files_locked();
+    pthread_mutex_unlock(&g_srs_capture_mutex);
+    return -1;
+  }
+  fflush(g_fp_gen);
+  fflush(g_fp_rx);
+
+  g_captured = 0;
+  g_max_occasions = max_occasions;
+  atomic_store(&g_srs_capture_state, NR_SRS_CAPTURE_RUNNING);
+  pthread_mutex_unlock(&g_srs_capture_mutex);
+
+  LOG_I(PHY,
+        "SRS capture START max_occasions=%u gen=%s rx=%s\n",
+        max_occasions,
+        OPENXG_SRS_CAPTURE_GENERATE_PATH,
+        OPENXG_SRS_CAPTURE_RECEIVE_PATH);
+  return 0;
+}
+
+int nr_srs_capture_stop(void)
+{
+  pthread_mutex_lock(&g_srs_capture_mutex);
+  atomic_store(&g_srs_capture_state, NR_SRS_CAPTURE_IDLE);
+  close_files_locked();
+  uint32_t n = g_captured;
+  pthread_mutex_unlock(&g_srs_capture_mutex);
+  LOG_I(PHY, "SRS capture STOP captured=%u\n", n);
+  return 0;
+}
+
+void nr_srs_capture(uint16_t frame,
+                    uint16_t slot,
+                    uint16_t rnti,
+                    int srs_est,
+                    uint8_t nb_antennas_rx,
+                    uint8_t N_ap,
+                    uint8_t N_symb_SRS,
+                    uint16_t ofdm_symbol_size,
+                    c16_t **srs_generated_signal,
+                    c16_t srs_received_signal[][ofdm_symbol_size * N_symb_SRS])
+{
+  if (atomic_load(&g_srs_capture_state) != NR_SRS_CAPTURE_RUNNING)
+    return;
+  if (srs_est < 0)
+    return; /* keep contiguous valid occasions only */
+  if (!srs_generated_signal || !srs_received_signal || N_ap == 0 || nb_antennas_rx == 0
+      || N_symb_SRS == 0 || ofdm_symbol_size == 0)
+    return;
+
+  const size_t samples_per_plane = (size_t)ofdm_symbol_size * (size_t)N_symb_SRS;
+
+  pthread_mutex_lock(&g_srs_capture_mutex);
+  if (atomic_load(&g_srs_capture_state) != NR_SRS_CAPTURE_RUNNING || !g_fp_gen || !g_fp_rx) {
+    pthread_mutex_unlock(&g_srs_capture_mutex);
+    return;
+  }
+
+  nr_srs_capture_rec_hdr_t hdr = {
+      .magic = NR_SRS_CAPTURE_REC_GEN,
+      .frame = frame,
+      .slot = slot,
+      .rnti = rnti,
+      .ofdm_symbol_size = ofdm_symbol_size,
+      .nb_antennas_rx = nb_antennas_rx,
+      .N_ap = N_ap,
+      .N_symb_SRS = N_symb_SRS,
+      .reserved = 0,
+  };
+
+  bool ok = true;
+  if (fwrite(&hdr, sizeof(hdr), 1, g_fp_gen) != 1)
+    ok = false;
+  for (int p = 0; ok && p < N_ap; p++) {
+    if (!srs_generated_signal[p]
+        || fwrite(srs_generated_signal[p], sizeof(c16_t), samples_per_plane, g_fp_gen) != samples_per_plane)
+      ok = false;
+  }
+
+  hdr.magic = NR_SRS_CAPTURE_REC_RX;
+  if (ok && fwrite(&hdr, sizeof(hdr), 1, g_fp_rx) != 1)
+    ok = false;
+  for (int a = 0; ok && a < nb_antennas_rx; a++) {
+    if (fwrite(srs_received_signal[a], sizeof(c16_t), samples_per_plane, g_fp_rx) != samples_per_plane)
+      ok = false;
+  }
+
+  if (!ok) {
+    set_error_locked("fwrite failed during capture");
+    LOG_E(PHY, "SRS capture write failed frame=%u slot=%u\n", frame, slot);
+    atomic_store(&g_srs_capture_state, NR_SRS_CAPTURE_IDLE);
+    close_files_locked();
+    pthread_mutex_unlock(&g_srs_capture_mutex);
+    return;
+  }
+
+  /* Keep disk stream hot without fsync every occasion (zero-loss in RAM→stdio buffer). */
+  g_captured++;
+  const uint32_t n = g_captured;
+  const uint32_t max_n = g_max_occasions;
+
+  if (max_n > 0 && n >= max_n) {
+    atomic_store(&g_srs_capture_state, NR_SRS_CAPTURE_IDLE);
+    close_files_locked();
+    LOG_I(PHY, "SRS capture auto-STOP after %u occasions\n", n);
+  }
+
+  pthread_mutex_unlock(&g_srs_capture_mutex);
+}

openair1/SCHED_NR/nr_srs_capture.h

+/*
+ * SPDX-License-Identifier: LicenseRef-CSSL-1.0
+ *
+ * Zero-loss SRS capture inside gNB: append consecutive valid SRS occasions
+ * to binary files while RUNNING. Start/stop via HTTP (gNB http_port, default 8888).
+ */
+
+#ifndef NR_SRS_CAPTURE_H
+#define NR_SRS_CAPTURE_H
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "common/utils/nr/nr_common.h"
+#include "openair1/PHY/defs_nr_common.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define OPENXG_SRS_CAPTURE_GENERATE_PATH "/tmp/openxg_srs_generate.bin"
+#define OPENXG_SRS_CAPTURE_RECEIVE_PATH "/tmp/openxg_srs_receive.bin"
+
+/* File magic (little-endian ASCII) */
+#define NR_SRS_CAPTURE_FILE_MAGIC 0x31535253u /* 'SRS1' */
+#define NR_SRS_CAPTURE_REC_GEN 0x45475253u /* 'SRGE' */
+#define NR_SRS_CAPTURE_REC_RX 0x58525253u /* 'SRRX' */
+
+enum nr_srs_capture_state_e {
+  NR_SRS_CAPTURE_IDLE = 0,
+  NR_SRS_CAPTURE_RUNNING = 1,
+};
+
+typedef struct nr_srs_capture_status {
+  int state; /* nr_srs_capture_state_e */
+  uint32_t captured;
+  uint32_t max_occasions; /* 0 = until stop */
+  const char *generate_path;
+  const char *receive_path;
+  char last_error[128];
+} nr_srs_capture_status_t;
+
+int get_srs_capture_status(void);
+void set_srs_capture_status(int state);
+
+/** Start capture. max_occasions==0 means run until stop. Returns 0 on success. */
+int nr_srs_capture_start(uint32_t max_occasions);
+
+/** Stop capture and close files. Returns 0 on success. */
+int nr_srs_capture_stop(void);
+
+/** Fill status snapshot (thread-safe). */
+void nr_srs_capture_get_status(nr_srs_capture_status_t *out);
+
+/**
+ * Called from PHY on each SRS occasion.
+ * When RUNNING and srs_est>=0, appends one contiguous record to both files.
+ */
+void nr_srs_capture(uint16_t frame,
+                    uint16_t slot,
+                    uint16_t rnti,
+                    int srs_est,
+                    uint8_t nb_antennas_rx,
+                    uint8_t N_ap,
+                    uint8_t N_symb_SRS,
+                    uint16_t ofdm_symbol_size,
+                    c16_t **srs_generated_signal,
+                    c16_t srs_received_signal[][ofdm_symbol_size * N_symb_SRS]);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* NR_SRS_CAPTURE_H */

openair1/SCHED_NR/phy_procedures_nr_gNB.c

@@ -23,6 +23,7 @@
 #include <stdint.h>
 #include <openair1/PHY/TOOLS/phy_scope_interface.h>
 #include "PHY/log_tools.h"
+#include "nr_srs_capture.h"
 
 //#define DEBUG_RXDATA
 //#define SRS_IND_DEBUG
@@ -858,11 +859,52 @@ void nr_srs_rx_procedures(PHY_VARS_gNB *gNB,
   }
 
   stop_meas(&gNB->generate_srs_stats);
+
+#if T_TRACER
+  /* Always emit the cached generated reference (not only on reconfiguration). */
+  if (T_ACTIVE(T_GNB_PHY_UL_SRS_GENERATED_SIGNAL)) {
+    for (int p_ind = 0; p_ind < N_ap; p_ind++) {
+      T(T_GNB_PHY_UL_SRS_GENERATED_SIGNAL,
+        T_INT(gNB->Mod_id),
+        T_INT(srs_pdu->rnti),
+        T_INT(frame_rx),
+        T_INT(slot_rx),
+        T_INT(p_ind),
+        T_BUFFER(nr_srs_info->srs_generated_signal[p_ind], N_symb_SRS * ofdm_symbol_size * sizeof(c16_t)));
+    }
+  }
+#endif
+
   c16_t **rxdataF = gNB->common_vars.rxdataF[srs->beam_nb];
   start_meas(&gNB->get_srs_signal_stats);
   *srs_est = nr_get_srs_signal(gNB, rxdataF, slot_rx, srs_pdu, nr_srs_info, srs_received_signal, srs_received_noise);
   stop_meas(&gNB->get_srs_signal_stats);
 
+  nr_srs_capture(frame_rx,
+                 slot_rx,
+                 srs_pdu->rnti,
+                 *srs_est,
+                 nb_antennas_rx,
+                 N_ap,
+                 N_symb_SRS,
+                 ofdm_symbol_size,
+                 nr_srs_info->srs_generated_signal,
+                 srs_received_signal);
+
+#if T_TRACER
+  if (*srs_est >= 0 && T_ACTIVE(T_GNB_PHY_UL_SRS_RECEIVED_SIGNAL)) {
+    for (int ant_rx_ind = 0; ant_rx_ind < nb_antennas_rx; ant_rx_ind++) {
+      T(T_GNB_PHY_UL_SRS_RECEIVED_SIGNAL,
+        T_INT(gNB->Mod_id),
+        T_INT(srs_pdu->rnti),
+        T_INT(frame_rx),
+        T_INT(slot_rx),
+        T_INT(ant_rx_ind),
+        T_BUFFER(srs_received_signal[ant_rx_ind], N_symb_SRS * ofdm_symbol_size * sizeof(c16_t)));
+    }
+  }
+#endif
+
   uint32_t signal_power_avg = 0;
   c16_t srs_ls_estimated_channel[nb_antennas_rx][N_ap][ofdm_symbol_size * N_symb_SRS];
 

openair2/GNB_APP/gnb_paramdef.h

@@ -78,6 +78,7 @@ typedef enum {
 #define GNB_CONFIG_STRING_DOTCI                         "do_TCI"
 #define GNB_CONFIG_STRING_DOCSIRS                       "do_CSIRS"
 #define GNB_CONFIG_STRING_DOSRS                         "do_SRS"
+#define GNB_CONFIG_STRING_HTTP_PORT                     "http_port"
 #define GNB_CONFIG_STRING_NRCELLID                      "nr_cellid"
 #define GNB_CONFIG_STRING_MINRXTXTIME                   "min_rxtxtime"
 #define GNB_CONFIG_STRING_ULPRBBLACKLIST                "ul_prbblacklist"
@@ -162,6 +163,7 @@ typedef enum {
 {GNB_CONFIG_STRING_CONFIG_REP, GNB_CONFIG_HLP_CONFIG_REP, 0,          .strptr=NULL, .defstrval="ssb_rsrp",        TYPE_STRING,    0},  \
 {GNB_CONFIG_STRING_1ST_ACTIVE_BWP,               NULL,   0,            .iptr=NULL,  .defintval=0,                 TYPE_INT,       0},  \
 {GNB_CONFIG_STRING_LIMIT_RSRP_REPORT,            NULL,   0,            .iptr=NULL,  .defintval=0,                 TYPE_INT,       0},  \
+{GNB_CONFIG_STRING_HTTP_PORT, "gNB HTTP API listen port (stats/SRS capture)", 0, .uptr=NULL, .defuintval=8888, TYPE_UINT, 0},  \
 }
 // clang-format on
 
@@ -206,6 +208,7 @@ typedef enum {
 #define GNB_CONFIG_REP_IDX              37
 #define GNB_1ST_ACTIVE_BWP_IDX          38
 #define GNB_LIMIT_RSRP_REPORT_IDX       39
+#define GNB_HTTP_PORT_IDX               40
 
 #define TRACKING_AREA_CODE_OKRANGE {0x0001,0xFFFD}
 #define NUM_DL_HARQ_OKVALUES {2,4,6,8,10,12,16,32}
@@ -255,6 +258,7 @@ typedef enum {
              3 } }, \
   { .s5 = { NULL } },                                             \
   { .s5 = { NULL } },                                             \
+  { .s5 = { NULL } },                                             \
 }
 
 /*-------------------------------------------------------------------------------------------------------------------------------------------------*/

targets/PROJECTS/GENERIC-NR-5GC/CONF/gnb.sa.band78.fr1.273PRB.oxgrf.conf

@@ -21,6 +21,8 @@ gNBs =
     pusch_AntennaPorts                                              = 1;
     do_CSIRS                                                        = 1;
     do_SRS                                                          = 0;
+    # OpenXG HTTP API (UE stats / SRS capture); default 8888 if omitted
+    http_port                                                       = 8888;
     ul_prbblacklist                                                 = "135,136,137,138"
     min_rxtxtime                                                    = 4;
 
@@ -157,14 +159,14 @@ gNBs =
 
 
     ////////// AMF parameters:
-    amf_ip_address      = ({ ipv4       = "18.119.182.0"; });
+    amf_ip_address      = ({ ipv4       = "172.11.200.14"; });
 
 
     NETWORK_INTERFACES :
     {
-        GNB_IPV4_ADDRESS_FOR_NG_AMF              = "192.168.199.102/24";
-        GNB_IPV4_ADDRESS_FOR_NGU                 = "192.168.199.102/24";
-        GNB_IPV4_ADDRESS_FOR_NGU_EXTERNAL        = "111.198.54.3";
+        GNB_IPV4_ADDRESS_FOR_NG_AMF              = "172.11.200.1";
+        GNB_IPV4_ADDRESS_FOR_NGU                 = "172.11.200.1";
+        #GNB_IPV4_ADDRESS_FOR_NGU_EXTERNAL        = "172.11.200.1";
         GNB_PORT_FOR_S1U                         = 2152; # Spec 2152
     };