dapps 0.0.3__tar.gz → 0.0.4__tar.gz

{dapps-0.0.3 → dapps-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dapps
-Version: 0.0.3
+Version: 0.0.4
 Summary: A library for creating and connecting dApps to Open RAN units.
 Project-URL: Homepage, https://openrangym.com/o-ran-frameworks/dapps
 Project-URL: Package, https://pypi.org/project/dapps/
@@ -48,21 +48,24 @@ A complete tutorial on how to deploy a dApp can be found on the [OpenRAN Gym web
 
 ## Installation
 
-### Python package installation
+### Python package installation (recommended)
 
 ```
 pip3 install dapps[all]
 ```
 
-### Manual installation
-Clone the repository and install it manually
+The dApp can be found in the `examples` directory or it can be downloaded from this repository.
+
+### Manual installation (use only for library development)
+
+Clone the repository and install it manually with:
 
 ```
 hatch build
 pip3 install dist/*.tar.gz
 ```
 
-### Launch the Spectrum Sharing dApp
+### Launch the Spectrum Sharing dApp example
 
 OAI should start _before_ running the dApp
 
@@ -70,23 +73,25 @@ OAI should start _before_ running the dApp
 python3 examples/spectrum_dapp.py
 ```
 
-This dApp implements a spectrum sharing use case discussed in [our paper](https://arxiv.org/pdf/2501.16502).
-
-
-The dApp can be controlled through the following command-line arguments:
+This dApp implements a spectrum sharing use case discussed in [our paper](https://doi.org/10.1016/j.comnet.2025.111342) ([here for the archive version](https://arxiv.org/pdf/2501.16502)).
+The dApp parameters can be controlled through the following command-line arguments:
 
-- `--ota` (store_true, default: False): Specify if this is OTA or on Colosseum  
 - `--link` (str, default: 'zmq', choices: [layer.value for layer in E3LinkLayer]): Specify the link layer to be used  
 - `--transport` (str, default: 'ipc', choices: [layer.value for layer in E3TransportLayer]): Specify the transport layer to be used  
 - `--save-iqs` (store_true, default: False): Specify if this is data collection run or not. In the first case I/Q samples will be saved  
 - `--control` (store_true, default: False): Set whether to perform control of PRB  
+- `--noise-floor-threshold` (int, default: None): Set the noise floor threshold for determining the presence of incumbents and for detecting the PRBs affected.
+- `--ota` (store_true, default: False): Specify if the setup used is OTA or on Colosseum for determining the noise floor threshold. If the `noise_floor_threshold` parameter is specified, this parameter is ignored
 - `--energy-gui` (store_true, default: False): Set whether to enable the energy GUI  
 - `--iq-plotter-gui` (store_true, default: False): Set whether to enable the IQ Plotter GUI  
 - `--demo-gui` (store_true, default: False): Set whether to enable the Demo GUI  
+- `--num-prbs` (int, default: 106): Number of PRBs  
+- `--num-subcarrier-spacing` (int, default: 30): Subcarrier spacing in kHz (FR1 is 30)  
+- `--e` (store_true, default: False): Set if 3/4 sampling for FFT size is set on the gNB (-E option on OAI)  
+- `--center-freq` (float, default: 3.6192e9): Center frequency in Hz  
 - `--timed` (store_true, default: False): Run with a 5-minute time limit  
 - `--model` (str, default: ''): Path to the CNN model file to be used  
 - `--time-window` (int, default: 5): Number of input vectors to pass to the CNN model  
-- `--input-vector` (int, default: 1536): Number of I/Q samples per input vector  
 - `--moving-avg-window` (int, default: 30): Window size (in samples) for the moving average used to detect energy peaks in the spectrum  
 - `--extraction-window` (int, default: 600): Number of samples to retain after detecting an energy peak
 

{dapps-0.0.3 → dapps-0.0.4}/README.md

@@ -4,21 +4,24 @@ A complete tutorial on how to deploy a dApp can be found on the [OpenRAN Gym web
 
 ## Installation
 
-### Python package installation
+### Python package installation (recommended)
 
 ```
 pip3 install dapps[all]
 ```
 
-### Manual installation
-Clone the repository and install it manually
+The dApp can be found in the `examples` directory or it can be downloaded from this repository.
+
+### Manual installation (use only for library development)
+
+Clone the repository and install it manually with:
 
 ```
 hatch build
 pip3 install dist/*.tar.gz
 ```
 
-### Launch the Spectrum Sharing dApp
+### Launch the Spectrum Sharing dApp example
 
 OAI should start _before_ running the dApp
 
@@ -26,23 +29,25 @@ OAI should start _before_ running the dApp
 python3 examples/spectrum_dapp.py
 ```
 
-This dApp implements a spectrum sharing use case discussed in [our paper](https://arxiv.org/pdf/2501.16502).
-
-
-The dApp can be controlled through the following command-line arguments:
+This dApp implements a spectrum sharing use case discussed in [our paper](https://doi.org/10.1016/j.comnet.2025.111342) ([here for the archive version](https://arxiv.org/pdf/2501.16502)).
+The dApp parameters can be controlled through the following command-line arguments:
 
-- `--ota` (store_true, default: False): Specify if this is OTA or on Colosseum  
 - `--link` (str, default: 'zmq', choices: [layer.value for layer in E3LinkLayer]): Specify the link layer to be used  
 - `--transport` (str, default: 'ipc', choices: [layer.value for layer in E3TransportLayer]): Specify the transport layer to be used  
 - `--save-iqs` (store_true, default: False): Specify if this is data collection run or not. In the first case I/Q samples will be saved  
 - `--control` (store_true, default: False): Set whether to perform control of PRB  
+- `--noise-floor-threshold` (int, default: None): Set the noise floor threshold for determining the presence of incumbents and for detecting the PRBs affected.
+- `--ota` (store_true, default: False): Specify if the setup used is OTA or on Colosseum for determining the noise floor threshold. If the `noise_floor_threshold` parameter is specified, this parameter is ignored
 - `--energy-gui` (store_true, default: False): Set whether to enable the energy GUI  
 - `--iq-plotter-gui` (store_true, default: False): Set whether to enable the IQ Plotter GUI  
 - `--demo-gui` (store_true, default: False): Set whether to enable the Demo GUI  
+- `--num-prbs` (int, default: 106): Number of PRBs  
+- `--num-subcarrier-spacing` (int, default: 30): Subcarrier spacing in kHz (FR1 is 30)  
+- `--e` (store_true, default: False): Set if 3/4 sampling for FFT size is set on the gNB (-E option on OAI)  
+- `--center-freq` (float, default: 3.6192e9): Center frequency in Hz  
 - `--timed` (store_true, default: False): Run with a 5-minute time limit  
 - `--model` (str, default: ''): Path to the CNN model file to be used  
 - `--time-window` (int, default: 5): Number of input vectors to pass to the CNN model  
-- `--input-vector` (int, default: 1536): Number of I/Q samples per input vector  
 - `--moving-avg-window` (int, default: 30): Window size (in samples) for the moving average used to detect energy peaks in the spectrum  
 - `--extraction-window` (int, default: 600): Number of samples to retain after detecting an energy peak
 

dapps-0.0.4/VERSION

@@ -0,0 +1 @@
+0.0.4

{dapps-0.0.3 → dapps-0.0.4}/examples/spectrum_dapp.py

@@ -37,27 +37,36 @@ def main(args, time_to_wait: float = 60.0):
             )
             exit(-1)
 
-    if args.ota:
-        print(f'Using OTA configuration')
-        noise_floor_threshold = 20 # this really depends on the RF conditions and should be carefully calibrated
-    else: # Colosseum
-        print(f'Using Colosseum configuration')
-        noise_floor_threshold = 53
-
-    print(f'Threshold {noise_floor_threshold}')
+    # This value really depends on the RF conditions and the RU used and should be carefully calibrated
+    if args.noise_floor_threshold:
+        print(f'Using custom configuration')
+        noise_floor_threshold = args.noise_floor_threshold
+    else:    
+        if args.ota:
+            print(f'Using OTA configuration')
+            noise_floor_threshold = 20 
+        else: # Colosseum
+            print(f'Using Colosseum configuration')
+            noise_floor_threshold = 53
+
+    print(f'Threshold is {noise_floor_threshold}')
 
     classifier = None
     if args.model:
+        import math
+        ofdm_symbol_size = args.num_prbs * 12  # 12 subcarriers per PRB always fixed by LTE/NR standard
+        fft_size = 2 ** math.ceil(math.log2(ofdm_symbol_size))  # Next power of 2
         classifier = Classifier(
             time_window = args.time_window,
-            input_vector = args.input_vector,
+            input_vector = fft_size,
             moving_avg_window = args.moving_avg_window,
             extraction_window = args.extraction_window,
             model_path = args.model
         )
 
     dapp = SpectrumSharingDApp(noise_floor_threshold=noise_floor_threshold, save_iqs=args.save_iqs, control=args.control, link=args.link, transport=args.transport,
-                energyGui=args.energy_gui, iqPlotterGui=args.iq_plotter_gui, dashboard=args.demo_gui, classifier=classifier)
+                energyGui=args.energy_gui, iqPlotterGui=args.iq_plotter_gui, dashboard=args.demo_gui, classifier=classifier, center_freq=args.center_freq,
+                num_prbs=args.num_prbs, e_sampling=args.e, num_subcarrier_spacing= args.num_subcarrier_spacing)
 
     dapp.setup_connection()
     
@@ -76,18 +85,22 @@ def main(args, time_to_wait: float = 60.0):
 
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(description="Example of a dApp for Spectrum Sharing")
-    parser.add_argument('--ota', action='store_true', default=False, help="Specify if this is OTA or on Colosseum")
     parser.add_argument('--link', type=str, default='zmq', choices=[layer.value for layer in E3LinkLayer], help="Specify the link layer to be used")
     parser.add_argument('--transport', type=str, default='ipc', choices=[layer.value for layer in E3TransportLayer], help="Specify the transport layer to be used")
     parser.add_argument('--save-iqs', action='store_true', default=False, help="Specify if this is data collection run or not. In the first case I/Q samples will be saved")
     parser.add_argument('--control', action='store_true', default=False, help="Set whether to perform control of PRB")
+    parser.add_argument('--noise-floor-threshold', type=int, default=None, help="Set the noise floor threshold for determining the presence of incumbents and for detecting the PRBs affected.")
+    parser.add_argument('--ota', action='store_true', default=False, help="Specify if the setup used is OTA or on Colosseum for determining the noise floor threshold. If the `noise_floor_threshold` parameter is specified, this parameter is ignored")
     parser.add_argument('--energy-gui', action='store_true', default=False, help="Set whether to enable the energy GUI")
     parser.add_argument('--iq-plotter-gui', action='store_true', default=False, help="Set whether to enable the IQ Plotter GUI")
     parser.add_argument('--demo-gui', action='store_true', default=False, help="Set whether to enable the Demo GUI")
+    parser.add_argument('--num-prbs', type=int, default=106, help="Number of PRBs")
+    parser.add_argument('--num-subcarrier-spacing', type=int, default=30, help="Subcarrier spacing in kHz (FR1 is 30)")
+    parser.add_argument('--e', action='store_true', default=False, help="Set if 3/4 sampling for FFT size is set on the gNB (-E option on OAI)")
+    parser.add_argument('--center-freq', type=float, default=3.6192e9, help="Center frequency in Hz")
     parser.add_argument('--timed', action='store_true', default=False, help="Run with a 5-minute time limit")
     parser.add_argument('--model', type=str, default='', help="Path to the CNN model file to be used")
     parser.add_argument('--time-window', type=int, default=5, help="Number of input vectors to pass to the CNN model.")
-    parser.add_argument('--input-vector', type=int, default=1536, help="Number of I/Q samples per input vector.")
     parser.add_argument('--moving-avg-window', type=int, default=30, help="Window size (in samples) for the moving average used to detect energy peaks in the spectrum.")
     parser.add_argument('--extraction-window', type=int, default=600, help="Number of samples to retain after detecting an energy peak.")
 

{dapps-0.0.3 → dapps-0.0.4}/src/dapp/dapp.py

@@ -19,7 +19,7 @@ LOG_DIR = ('.' if os.geteuid() != 0 else '') + '/logs/'
 class DApp(ABC):
     e3_interface: E3Interface
 
-    def __init__(self, id: int = 1, link: str = 'posix', transport:str = 'uds', callbacks: list = [], **kwargs):
+    def __init__(self, id: int = 1, link: str = 'posix', transport:str = 'ipc', callbacks: list = [], **kwargs):
         super().__init__()
         self.dapp_id = id
         self.e3_interface = E3Interface(link=link, transport=transport)

{dapps-0.0.3 → dapps-0.0.4}/src/e3interface/defs/e3.asn

@@ -10,7 +10,7 @@ E3 DEFINITIONS AUTOMATIC TAGS ::= BEGIN
     }
 
     E3-IndicationMessage ::= SEQUENCE {
-        protocolData          OCTET STRING (SIZE(1..8192))
+        protocolData          OCTET STRING (SIZE(1..16384))
     }
 
     E3-ControlAction ::= SEQUENCE {

{dapps-0.0.3 → dapps-0.0.4}/src/spectrum/spectrum_dapp.py

@@ -15,26 +15,36 @@ from e3interface.e3_logging import dapp_logger, LOG_DIR
 
 class SpectrumSharingDApp(DApp):
 
-    ###  Configuration ###
-    # gNB runs with BW = 40 MHz, with -E (3/4 sampling)
+    ###  Default Configuration ###
+    # gNB runs with BW = ~40 MHz
     # Center frequency = 3.6192 GHz
-    # OAI sampling frequency 46.08e6
+    # OAI sampling frequency 46.08e6 # not useful for visualization
     # No SRS for now, hence in gNB config file set do_SRS = 0
-    # gNB->frame_parms.ofdm_symbol_size = 1536
-    # gNB->frame_parms.first_carrier_offset = 900
-    # Noise floor threshold needs to be calibrated
-    # We receive the symbols and average them over some frames, and do thresholding.
-
-    def __init__(self, id: int = 1, noise_floor_threshold: int = 53, save_iqs: bool = False, control: bool = False, link: str = 'posix', transport:str = 'uds', **kwargs):
-        super().__init__(link=link, transport=transport, **kwargs) 
-
-        self.bw = 40.08e6  # Bandwidth in Hz
-        self.center_freq = 3.6192e9 # Center frequency in Hz
-        self.First_carrier_offset = 900
-        self.Num_car_prb = 12
-        self.prb_thrs = 75 # This avoids blacklisting PRBs where the BWP is scheduled (it’s a workaround bc the UE and gNB would not be able to communicate anymore, a cleaner fix is to move the BWP if needed or things like that)
-        self.FFT_SIZE = 1536  
-        self.Average_over_frames = 63
+    # gNB->frame_parms.ofdm_symbol_size = 1536 # FFT size (even though is called ofdm_symbol_size) for USRP, with -E flag (3/4 sampling)
+    # gNB->frame_parms.ofdm_symbol_size = 2048 # FFT size (even though is called ofdm_symbol_size) for RUs, with no -E flag
+    # Noise floor threshold needs to be calibrated according to the RU
+    # We receive the symbols, average them over 63 frames and do PRB thresholding.
+
+    def __init__(self, id: int = 1, link: str = 'posix', transport: str = 'ipc', noise_floor_threshold: int = 53, save_iqs: bool = False, control: bool = False,
+                center_freq: float = 3.6192e9, num_prbs: int = 106, num_subcarrier_spacing: int = 30, e_sampling: bool = False, **kwargs):
+        super().__init__(id=id, link=link, transport=transport, **kwargs) 
+
+        # gNB radio configuration used to compute exact values
+        self.num_consecutive_subcarriers_for_prb: int = 12 # Always fixed by the LTE/NR standard to 12
+        self.num_prbs = num_prbs
+        self.num_subcarrier_spacing = num_subcarrier_spacing # subcarrier spacing in kHz (FR1 is 30)
+        self.ofdm_symbol_size = num_prbs * self.num_consecutive_subcarriers_for_prb
+        self.bw = self.num_prbs * self.num_consecutive_subcarriers_for_prb * self.num_subcarrier_spacing * 1e3 # Bandwidth in Hz
+        self.center_freq = center_freq # Center frequency in Hz
+        self.fft_size = 2 ** int(np.ceil(np.log2(self.ofdm_symbol_size))) # Next power of 2 to include guard bands
+        if e_sampling:
+            self.fft_size = int(self.fft_size * 3 / 4) # 3/4 of sampling for USRPs (-E flag) 
+        self.first_carrier_offset = self.fft_size - (self.ofdm_symbol_size // 2)
+
+        # dApp configuration
+        # The first 76 PRB usually have channels that should not be nulled (but we should investigate more options to enable this)
+        self.prb_thrs = 75 # This avoids blacklisting PRBs where the BWP is scheduled (it’s a workaround since the UE and gNB would not be able to communicate anymore, a cleaner fix is to move the BWP if needed or things like that)  
+        self.average_over_frames = 63
         self.noise_floor_threshold = noise_floor_threshold
         self.save_iqs = save_iqs
         self.e3_interface.add_callback(self.get_iqs_from_ran)
@@ -50,25 +60,24 @@ class SpectrumSharingDApp(DApp):
         self.dashboard = kwargs.get('dashboard', False)
 
         self.control_count = 1
-        self.abs_iq_av = np.zeros(self.FFT_SIZE)
+        self.abs_iq_av = np.zeros(self.fft_size)
 
         if self.energyGui:
             from visualization.energy import EnergyPlotter
             self.sig_queue = multiprocessing.Queue() 
-            self.energyPlotter = EnergyPlotter(self.FFT_SIZE, bw=self.bw, center_freq=self.center_freq) 
+            self.energyPlotter = EnergyPlotter(self.fft_size, bw=self.bw, center_freq=self.center_freq) 
 
         if self.iqPlotterGui:
             from visualization.iq import IQPlotter
             self.iq_queue = multiprocessing.Queue() 
-            iq_size = self.FFT_SIZE * 2 # double the size of ofdm_symbol_size since real and imaginary parts are interleaved
-            self.iqPlotter = IQPlotter(buffer_size=500, iq_size=iq_size, bw=self.bw, center_freq=self.center_freq)    
+            self.iqPlotter = IQPlotter(buffer_size=500, fft_size=self.fft_size, bw=self.bw, center_freq=self.center_freq)    
 
         if self.dashboard:
             from visualization.dashboard import Dashboard
             self.demo_queue = multiprocessing.Queue()
-            iq_size = self.FFT_SIZE * 2 # double the size of ofdm_symbol_size since real and imaginary parts are interleaved
             classifier = kwargs.get('classifier', None)
-            self.demo = Dashboard(buffer_size=100, iq_size=iq_size, classifier=classifier) 
+            self.demo = Dashboard(buffer_size=100, ofdm_symbol_size=self.ofdm_symbol_size, first_carrier_offset=self.first_carrier_offset,
+                                bw=self.bw, center_freq=self.center_freq, num_prbs=num_prbs, classifier=classifier) 
 
     def get_iqs_from_ran(self, data):
         dapp_logger.debug(f'Triggered callback')
@@ -83,7 +92,7 @@ class SpectrumSharingDApp(DApp):
                
         iq_arr = np.frombuffer(data, dtype=np.int16)
         dapp_logger.debug(f"Shape of iq_arr {iq_arr.shape}")
-        
+
         if self.iqPlotterGui:
             self.iq_queue.put(iq_arr)
 
@@ -100,9 +109,9 @@ class SpectrumSharingDApp(DApp):
             self.control_count += 1
             dapp_logger.debug(f"Control count is: {self.control_count}")
 
-            if self.control_count == self.Average_over_frames:
-                abs_iq_av_db =  20 * np.log10(1 + (self.abs_iq_av/(self.Average_over_frames)))
-                abs_iq_av_db_offset_correct = np.append(abs_iq_av_db[self.First_carrier_offset:self.FFT_SIZE],abs_iq_av_db[0:self.First_carrier_offset])
+            if self.control_count == self.average_over_frames:
+                abs_iq_av_db =  20 * np.log10(1 + (self.abs_iq_av/(self.average_over_frames)))
+                abs_iq_av_db_offset_correct = np.append(abs_iq_av_db[self.first_carrier_offset:self.fft_size],abs_iq_av_db[0:self.first_carrier_offset])
                 dapp_logger.info(f'--- AVG VALUES ----')
                 dapp_logger.info(f'abs_iq_av_db_offset_correct: {abs_iq_av_db_offset_correct.mean()}')
                 dapp_logger.info(f'--- MAX VALUES ----')
@@ -111,11 +120,11 @@ class SpectrumSharingDApp(DApp):
                 # dapp_logger.info(f'Last 20 max values (abs_iq_av_db_offset_correct): {last_5_max_abs_iq_av_db_offset_correct}')
 
                 # PRB blocking based on the noise floor threshold
-                f_ind = np.arange(self.FFT_SIZE)
+                f_ind = np.arange(self.fft_size)
                 blklist_sub_carrier = f_ind[abs_iq_av_db_offset_correct > self.noise_floor_threshold]
                 np.sort(blklist_sub_carrier)
                 dapp_logger.info(f'blklist_sub_carrier: {blklist_sub_carrier}')
-                prb_blk_list = np.unique((np.floor(blklist_sub_carrier/self.Num_car_prb))).astype(np.uint16)
+                prb_blk_list = np.unique((np.floor(blklist_sub_carrier/self.num_consecutive_subcarriers_for_prb))).astype(np.uint16)
                 dapp_logger.info(f'prb_blk_list: {prb_blk_list}')
                 prb_blk_list = prb_blk_list[prb_blk_list > self.prb_thrs]
                 # prb_blk_list = np.array([76, 77,  78,  79, 80, 81, 82, 83], dtype=np.uint16) # 76, 77,  78,  79, 80, 81, 82, 83
@@ -137,7 +146,7 @@ class SpectrumSharingDApp(DApp):
                     self.demo_queue.put(("prb_list", prb_blk_list))
 
                 # Reset the variables
-                self.abs_iq_av = np.zeros(self.FFT_SIZE)
+                self.abs_iq_av = np.zeros(self.fft_size)
                 self.control_count = 1  
 
     def _control_loop(self):

{dapps-0.0.3 → dapps-0.0.4}/src/visualization/dashboard.py

@@ -14,18 +14,21 @@ except ModuleNotFoundError:
 import numpy as np
 
 class Dashboard:
-    def __init__(self, buffer_size=100, iq_size=1536, bw=46.08e6, center_freq=3.6192e9, classifier=None):
-        # TODO double check killing conditions
+    # The default values of the dashboard are based on the default configuration
+    def __init__(self, buffer_size: int = 100, ofdm_symbol_size: int = 1272, bw: float = 38.16e6, center_freq: float = 3.6192e9, 
+                 num_prbs: int = 106, first_carrier_offset: int = 900, classifier = None):
         # Flask app setup
         self.app = Flask(__name__)
         self.app.config['TEMPLATES_AUTO_RELOAD'] = True
         self.socketio = SocketIO(self.app)
 
         # Parameters
-        self.BUFFER_SIZE = buffer_size
-        self.iq_size = iq_size
-        self.BW = bw
-        self.CENTER_FREQ = center_freq
+        self.buffer_size = buffer_size
+        self.ofdm_symbol_size = ofdm_symbol_size
+        self.bw = bw
+        self.center_freq = center_freq
+        self.num_prbs = num_prbs
+        self.first_carrier_offset = first_carrier_offset
         
         # Route setup
         self.app.add_url_rule("/", view_func=self.index)
@@ -51,20 +54,12 @@ class Dashboard:
         self.run_thread.start()
 
     def handle_initial_connection(self):
-        num_prbs = 106
-        iqs_to_show = int(
-            self.iq_size / 2
-        )  # / 2 since the size received is real and imaginary part
-        # Each PRB corresponds to 12 subcarriers
-        # Parameter first_carrier_offset (currently set to 900) is the first subcarrier.
-        # So PRB 0 is [900-911], 1 is [912-923], etc. They wrap around fft_size (now at 1536)
-        # The carrier frequency is in the middle PRB (including DC leak on some radios), this means it falls at (first_carrier_offset + 106*12/2) % fft_size? where % is the modulo operation
-        # The first 76 PRB usually have channels that should not be nulled (but we should investigate more options to enable this)
-        # So if you want the spectrum waterfall to correspond to the PRB masking plot, you can rotate them as per bullet 2 above and drop [635-899]
-        iqs_to_show -= 264  # is the size of the array to drop
         data_buffer = {
-            "magnitude": np.zeros((self.BUFFER_SIZE, iqs_to_show)).tolist(),
-            "num_prbs": num_prbs,
+            "magnitude": np.zeros((self.buffer_size, self.ofdm_symbol_size)).tolist(),
+            "center_freq": self.center_freq,
+            "bw": self.bw,
+            "num_prbs": self.num_prbs,
+            "first_carrier_offset": self.first_carrier_offset,
             "predicted_label": self.classifier is not None
         }
         self.socketio.emit("initialize_plot", data_buffer)
@@ -84,8 +79,6 @@ class Dashboard:
         plot, payload = message
         if plot == "iq_data":
             iq_data = payload
-            if iq_data.size != self.iq_size:
-                raise ValueError(f'Expected IQ data of size {self.iq_size}, but got {iq_data.size}')
 
             self.sampling_counter += 1        
             if self.sampling_counter >= self.sampling_threshold:
@@ -105,7 +98,6 @@ class Dashboard:
     def stop(self):
         """Stops the server and kills the thread."""
         if self.run_thread and self.run_thread.is_alive():
-            self.socketio.stop()
             self.run_thread.join()
 
 if __name__ == "__main__":

{dapps-0.0.3 → dapps-0.0.4}/src/visualization/iq.py

@@ -17,19 +17,19 @@ import os
 print(os.environ.get('DISPLAY'))
 
 class IQPlotter:
-    def __init__(self, buffer_size=100, iq_size=1536, bw=46.08e6, center_freq=3.6192e9):
+    def __init__(self, buffer_size=100, fft_size=1536, bw=38.16e6, center_freq=3.6192e9):
         """
         Initialize the IQ plotter with buffer size and IQ data dimensions.
         buffer_size: Number of columns (timesteps) to store and plot.
-        iq_size: Size of the IQ data, should be double the size of ofdm_symbol_size with real and imaginary interleaved.
+        fft_size: Size of the FFT.
         bw: Sampling frequency.
         center_freq: Center frequency of the signal.
         """
         self.buffer_size = buffer_size
-        self.iq_size = iq_size
+        self.iq_size = fft_size * 2 # double the size of fft_size since real and imaginary parts are interleaved
         self.bw = bw
         self.center_freq = center_freq
-        self.iq_shape = (iq_size // 2, buffer_size)  # Half the size after splitting real and imaginary parts
+        self.iq_shape = (self.iq_size // 2, buffer_size)  # Half the size after splitting real and imaginary parts
         
         # Initialize the buffer
         self.buffer = np.zeros(self.iq_shape)

{dapps-0.0.3 → dapps-0.0.4}/src/visualization/templates/index.html

@@ -4,7 +4,7 @@
 <head>
     <meta charset="UTF-8">
     <title>Real-Time Plots</title>
-    <script src="https://cdn.plot.ly/plotly-latest.min.js"></script>
+    <script src="https://cdn.plot.ly/plotly-3.0.1.min.js" charset="utf-8"></script>
     <script src="//cdnjs.cloudflare.com/ajax/libs/socket.io/4.0.1/socket.io.js"></script>
 </head>
 
@@ -18,27 +18,38 @@
             z: [],
             type: 'heatmap',
             colorscale: "Viridis",
+            zmin: 0,
+            zmax: 100,
             colorbar: {
                 title:{ 
                     text: "Magnitude [dB]",
                     side: 'right'
                 },
-                orientation: 'h'
+                orientation: 'v'
             }
         }];
 
         var waterfallLayout = {
-            title: "Sensed Spectrum",
+            title: {
+                text: "Sensed Spectrum",
+                font: { size: 16 }
+            },
             xaxis: {
-                title: "OFDM Symbol Subcarriers"
+                title: {
+                    text: "OFDM Symbol Subcarriers",
+                    font: { size: 14 }
+                }
             },
             yaxis: {
-                title: "Time samples",
+                title: {
+                    text: "Time samples",
+                    font: { size: 14 }
+                },
                 autorange: 'reversed'
             },
             annotations: [
                 {
-                    x: 1272 / 2,
+                    x: 0, // Will be updated dynamically
                     y: 1.15,
                     xref: 'x',
                     yref: 'paper',
@@ -49,21 +60,21 @@
                     }
                 },  
                 {
-                    x: 10,
+                    x: 0, // Will be updated dynamically
                     y: 1.1,
                     xref: 'x',
                     yref: 'paper',
-                    text: '3.5992',
+                    text: `0.0000`,
                     showarrow: false,
                     font: {
                         size: 12
                     }
                 },                {
-                    x: 1272 / 4,
+                    x: 0, // Will be updated dynamically
                     y: 1.1,
                     xref: 'x',
                     yref: 'paper',
-                    text: '3.6092',
+                    text: `0.0000`,
                     showarrow: false,
                     font: {
                         size: 12
@@ -71,33 +82,33 @@
                 },
 
                 {
-                    x: 1272 / 2,
+                    x: 0, // Will be updated dynamically
                     y: 1.1,
                     xref: 'x',
                     yref: 'paper',
-                    text: '3.6192',
+                    text: `0.0000`,
                     showarrow: false,
                     font: {
                         size: 12
                     }
                 },
                 {
-                    x: 1272 * 3 / 4,
+                    x: 0, // Will be updated dynamically
                     y: 1.1,
                     xref: 'x',
                     yref: 'paper',
-                    text: '3.6292',
+                    text: `0.0000`,
                     showarrow: false,
                     font: {
                         size: 12
                     }
                 },
                 {
-                    x: 1272 - 23,
+                    x: 0, // Will be updated dynamically
                     y: 1.1,
                     xref: 'x',
                     yref: 'paper',
-                    text: '3.6392',
+                    text: `0.0000`,
                     showarrow: false,
                     font: {
                         size: 12
@@ -145,12 +156,21 @@
                 align: 'right'
             }
         ],
-            title: "PRB Status Grid",
+            title: {
+                text: "PRB Status Grid",
+                font: { size: 16 }
+            },
             xaxis: {
-                title: "PRB Index"
+                title: {
+                    text: "PRB Index",
+                    font: { size: 14 }
+                }
             },
             yaxis: {
-                title: "Status",
+                title: {
+                    text: "Status",
+                    font: { size: 14 }
+                },
                 showticklabels: false
             },
             height: 200,
@@ -172,11 +192,41 @@
         var waterfall_buffer;
         var prbs_buffer;
         var predictedLabel;
+        var start_ignore;
+        var end_ignore;
+        var initialized = false;
 
         var socket = io.connect('http://' + document.domain + ':' + location.port);
         socket.on('initialize_plot', function (data) {
+            var ofdm_symbol_size = data.magnitude[0].length;
+            var first_carrier_offset = data.first_carrier_offset;
+            var freq_step = data.bw / ofdm_symbol_size;
+            var start_freq = data.center_freq - (ofdm_symbol_size / 2) * freq_step;
+            var freq_labels = [];
+            for (let i = 0; i < 5; i++) {
+                let pos = Math.floor(i * ofdm_symbol_size / 4);
+                let f = (start_freq + pos * freq_step) / 1e9;
+                freq_labels.push(f.toFixed(4));
+            }
+
+            // Update x values for annotations (frequency markers) with proper edge margins
+            var left_margin = Math.max(25, ofdm_symbol_size * 0.02); // At least 25 or 2% of width
+            var right_margin = Math.max(65, ofdm_symbol_size * 0.02); // At least 65 or 2% of width
+            
+            waterfallLayout.annotations[0].x = ofdm_symbol_size / 2 + ofdm_symbol_size / 50; // slightly centered to the right
+            waterfallLayout.annotations[1].x = left_margin;
+            waterfallLayout.annotations[2].x = ofdm_symbol_size / 4;
+            waterfallLayout.annotations[3].x = ofdm_symbol_size / 2;
+            waterfallLayout.annotations[4].x = ofdm_symbol_size * 3 / 4;
+            waterfallLayout.annotations[5].x = ofdm_symbol_size - right_margin;
+            waterfallLayout.annotations[1].text = `${freq_labels[0]}`;
+            waterfallLayout.annotations[2].text = `${freq_labels[1]}`;
+            waterfallLayout.annotations[3].text = `${freq_labels[2]}`;
+            waterfallLayout.annotations[4].text = `${freq_labels[3]}`;
+            waterfallLayout.annotations[5].text = `${freq_labels[4]}`;
+
             waterfall_buffer = data.magnitude;
-            waterfall[0].z.push(waterfall_buffer);
+            waterfall[0].z = waterfall_buffer;
             prbs_buffer = [new Array(data.num_prbs).fill(0)];
             prbs[0].z = prbs_buffer;
             Plotly.newPlot('magnitude', waterfall, waterfallLayout);
@@ -184,29 +234,66 @@
             if(data.predicted_label){
                 Plotly.newPlot("predicted_label", [], classifierLayout);
             }
+
+            // Dynamic preprocessing based on first_carrier_offset    
+            // The carrier frequency is in the middle PRB (including DC leak on some radios)
+            console.log("Initial values:", {
+                ofdm_symbol_size: ofdm_symbol_size,
+                first_carrier_offset: first_carrier_offset,
+                num_prbs: data.num_prbs
+            });
+            const num_consecutive_subcarriers_for_prb = 12; // Always 12 by LTE / NR standard
+            // Calculate the middle PRB position
+            var middle_prb_offset = data.num_prbs * num_consecutive_subcarriers_for_prb / 2;
+            console.log("Calculated middle_prb_offset:", middle_prb_offset);
+            
+            // Calculate slice points dynamically
+            // We want to show the spectrum centered around the middle PRB
+            // The interval to consider is from the middle prb offset to the first carrier offset
+            start_ignore = middle_prb_offset;
+            end_ignore = first_carrier_offset;
+
+            console.log("Slice points:", {
+                start_ignore: start_ignore,
+                end_ignore: end_ignore
+            });
+
+            initialized = true;
         });
 
         socket.on('update_plot', function (data) {
+            if (!initialized) {
+                return;
+            }
+
             if ('magnitude' in data) {
                 // console.log("Magnitude is: ", data.magnitude)
-                // Preprocess data
-                let part1 = data.magnitude.slice(0, 635);
-                // let ignoredPart = data.magnitude.slice(635, 899);
-                let part3 = data.magnitude.slice(899);
+
+                var magnitude_length = data.magnitude.length;                
+                // Dynamic slicing based on calculated positions
+                let part1 = data.magnitude.slice(0, start_ignore);
+                // Ignore the middle section (guards symbols)
+                let part3 = data.magnitude.slice(end_ignore);
                 let magnitudeToShow = part3.concat(part1).reverse();
+                
+                // console.log("Parts lengths:", {
+                //     // part1_length: part1.length,
+                //     // part3_length: part3.length,
+                //     magnitudeToShow_length: magnitudeToShow.length
+                // });
+                
                 // Update waterfall plot
                 waterfall_buffer.pop();
                 waterfall_buffer.unshift(magnitudeToShow);
                 Plotly.restyle('magnitude', { z: [waterfall_buffer] });
-            }
-            else if ('prb_list' in data) {
-                console.log("PRBs are: ", data.prb_list);
+            } else if ('prb_list' in data) {
+                // console.log("PRBs are: ", data.prb_list);
                 // We get a list of indexes to replace each time
                 prbs_buffer[0].fill(0);
                 data.prb_list.forEach(index => prbs_buffer[0][index] = 1);
                 Plotly.restyle('prbs', { z: [prbs_buffer] });
             } else if ('predicted_label' in data) {
-                console.log("RFI Predicted is ", data.predicted_label);
+                // console.log("RFI Predicted is ", data.predicted_label);
                 Plotly.relayout('predicted_label', {
                     'title.text': `RFI Predicted: ${data.predicted_label}`
                 });

dapps-0.0.3/VERSION

@@ -1 +0,0 @@
-0.0.3