dapps 0.0.1__py3-none-any.whl

e3interface/e3_connector.py

@@ -0,0 +1,295 @@
+import struct
+from abc import ABC, abstractmethod
+from enum import Enum
+import os
+import socket
+import zmq
+from .e3_logging import e3_logger, LOG_DIR
+
+
+class E3LinkLayer(Enum):
+    ZMQ = "zmq"
+    POSIX = "posix"
+
+    def __str__(self):
+        return self.value
+
+    @staticmethod
+    def from_string(link_layer_str: str):
+        try:
+            return E3LinkLayer(link_layer_str.lower())
+        except ValueError:
+            raise ValueError(f"Invalid link layer: '{link_layer_str}'. Must be one of {[e.value for e in E3LinkLayer]}")
+
+class E3TransportLayer(Enum):
+    SCTP = "sctp"
+    TCP = "tcp"
+    IPC = "ipc"
+
+    def __str__(self):
+        return self.value
+
+    @staticmethod
+    def from_string(transport_layer_str: str):
+        try:
+            return E3TransportLayer(transport_layer_str.lower())
+        except ValueError:
+            raise ValueError(f"Invalid transport layer: '{transport_layer_str}'. Must be one of {[e.value for e in E3TransportLayer]}")
+
+class E3Connector(ABC):
+    # List of known valid configurations
+    VALID_CONFIGURATIONS = [
+        (E3LinkLayer.ZMQ, E3TransportLayer.IPC),
+        (E3LinkLayer.ZMQ, E3TransportLayer.TCP),
+        (E3LinkLayer.POSIX, E3TransportLayer.TCP),
+        (E3LinkLayer.POSIX, E3TransportLayer.SCTP),
+        (E3LinkLayer.POSIX, E3TransportLayer.IPC)
+    ]
+    
+    IPC_BASE_DIR = "/tmp/dapps"
+    E3_IPC_SETUP_PATH = f"{IPC_BASE_DIR}/setup"
+    E3_IPC_SOCKET_PATH = f"{IPC_BASE_DIR}/e3_socket" # inbound
+    DAPP_IPC_SOCKET_PATH = f"{IPC_BASE_DIR}/dapp_socket" # outbound
+
+    @staticmethod
+    def setup_connector(link_layer: str, transport_layer: str):
+        link_layer = E3LinkLayer.from_string(link_layer)
+        transport_layer = E3TransportLayer.from_string(transport_layer)
+        
+        # Check if the configuration is part of the valid configurations
+        if (link_layer, transport_layer) not in E3Connector.VALID_CONFIGURATIONS:
+            raise ValueError(
+                f"Invalid configuration: Link Layer={link_layer}, Transport Layer={transport_layer}. "
+                f"Must be one of {E3Connector.VALID_CONFIGURATIONS}"
+            )
+            
+        if link_layer == E3LinkLayer.POSIX:
+            return POSIXConnector(transport_layer)
+        else:
+            return ZMQConnector(transport_layer)
+    
+    @abstractmethod
+    def send_setup_request(self, payload):
+        pass
+    
+    @abstractmethod
+    def setup_inbound_connection(self):
+        pass
+    
+    @abstractmethod
+    def receive(self) -> bytes:
+        """Receive a byte-encoded payload based on the configuration."""
+        pass
+    
+    @abstractmethod
+    def setup_outbound_connection(self):
+        pass
+
+    @abstractmethod
+    def send(self, payload: bytes):
+        pass
+    
+    @abstractmethod 
+    def dispose(self):
+        pass
+      
+class ZMQConnector(E3Connector):
+    setup_context: zmq.Context
+    inbound_context: zmq.Context
+    outbound_context: zmq.Context
+
+    def __init__(self, transport_layer: E3TransportLayer):
+        self.setup_context = zmq.Context()
+        
+        match transport_layer:
+            case E3TransportLayer.SCTP | E3TransportLayer.TCP:
+                self.setup_endpoint = f"{transport_layer}://127.0.0.1:9990"
+                self.inbound_endpoint = f"{transport_layer}://127.0.0.1:9991"
+                self.outbound_endpoint = f"{transport_layer}://127.0.0.1:9999"  
+            
+            case E3TransportLayer.IPC:
+                self.setup_endpoint = f"{transport_layer}://{self.E3_IPC_SETUP_PATH}"
+                self.inbound_endpoint = f"{transport_layer}://{self.E3_IPC_SOCKET_PATH}"
+                self.outbound_endpoint = f"{transport_layer}://{self.DAPP_IPC_SOCKET_PATH}"
+
+            case _:
+                raise ValueError(f'Unknown/Unsupported value for transport layer {transport_layer}')
+
+        self.transport_layer = transport_layer
+        
+    def send_setup_request(self, payload):
+        # Lazy pirate pattern, i.e., reliability on the client side
+        request_timeout = 1000
+        request_retries = 5
+
+        while request_retries > 0:
+            setup_socket = self.setup_context.socket(zmq.REQ)
+            setup_socket.connect(self.setup_endpoint)
+            e3_logger.debug("Send E3 Setup request")
+            setup_socket.send(payload)
+
+            if (setup_socket.poll(request_timeout) & zmq.POLLIN) != 0:
+                reply = setup_socket.recv()
+                e3_logger.debug('ZMQ setup socket replied')
+                return reply
+            
+            request_retries -= 1
+            e3_logger.error("ZMQ setup did not reply")
+            setup_socket.setsockopt(zmq.LINGER, 0)
+            setup_socket.close()
+            e3_logger.debug('Retrying to connect')
+        
+        raise ConnectionRefusedError('E3 Setup request procedure did not went through')
+        
+
+    def setup_inbound_connection(self):
+        self.inbound_context = zmq.Context()
+        self.inbound_socket = self.inbound_context.socket(zmq.SUB)        
+        self.inbound_socket.setsockopt_string(zmq.SUBSCRIBE, "") # subscribe to all the messages
+        self.inbound_socket.setsockopt(zmq.CONFLATE, 1)  # Keep only last message
+        self.inbound_socket.connect(self.inbound_endpoint)
+
+        self.poller = zmq.Poller()
+        self.poller.register(self.inbound_socket, zmq.POLLIN)
+
+    def receive(self) -> bytes:
+        # The commented part should be decommented for measuring the effective performance of the control loop
+        # start_time = time.perf_counter()
+        # while True:
+            
+        #     # Poll the socket without blocking
+        #     events = dict(self.poller.poll(0))
+            
+        #     if self.inbound_socket in events and events[self.inbound_socket] == zmq.POLLIN:
+        #         with open(f"{LOG_DIR}/busy.txt", "a") as f:
+        #             print(f"{time.perf_counter() - start_time}", file=f)
+                return self.inbound_socket.recv()
+        
+
+    def setup_outbound_connection(self):
+        self.outbound_context = zmq.Context()
+        self.outbound_socket = self.outbound_context.socket(zmq.PUB)
+        self.outbound_socket.bind(self.outbound_endpoint)
+        if self.transport_layer == E3TransportLayer.IPC:
+            os.chmod(self.DAPP_IPC_SOCKET_PATH, 0o666)
+    
+    def send(self, payload: bytes):
+        self.outbound_socket.send(payload)
+
+    def dispose(self):
+        if hasattr(self, "setup_context"):    
+            self.setup_context.destroy()  
+        if hasattr(self, "inbound_context"):   
+            self.inbound_context.destroy()
+        if hasattr(self, "outbound_context"):   
+            self.outbound_context.destroy()
+
+class POSIXConnector(E3Connector):
+    CHUNK_SIZE = 8192
+    
+    def __init__(self, transport_layer: E3TransportLayer):   
+        match transport_layer:
+            case E3TransportLayer.SCTP | E3TransportLayer.TCP:
+                self.setup_endpoint = ("127.0.0.1", 9990)
+                self.inbound_endpoint = ("127.0.0.1", 9991)
+                self.outbound_endpoint = ("127.0.0.1", 9999)
+            
+            case E3TransportLayer.IPC: 
+                self.setup_endpoint = self.E3_IPC_SETUP_PATH
+                self.inbound_endpoint = self.E3_IPC_SOCKET_PATH
+                self.outbound_endpoint = self.DAPP_IPC_SOCKET_PATH
+
+            case _:
+                raise ValueError(f'Unknown/Unsupported value for transport layer {transport_layer}')
+        
+        self.transport_layer = transport_layer
+    
+    def _create_socket(self):
+        match self.transport_layer:
+            case E3TransportLayer.SCTP:
+                try:
+                    import sctp
+                except ModuleNotFoundError:
+                    e3_logger.critical(
+                        "SCTP selected as transport layer, but the optional dependency 'pysctp' is not installed.\n"
+                        "Fix this by running:\n\n"
+                        "    pip install 'dApps[network]'  # OR\n"
+                        "    pip install 'dApps[all]'\n",
+                        exc_info=True
+                    )
+                    exit(-1)
+                sock = sctp.sctpsocket_tcp(socket.AF_INET)
+            case E3TransportLayer.TCP:
+                sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            case E3TransportLayer.IPC:
+                sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+            case _:
+                raise ValueError(f'Unknown/Unsupported value for transport layer {self.transport_layer}')
+        return sock
+    
+    def send_setup_request(self, payload):
+        setup_socket = self._create_socket()
+
+        try:
+            setup_socket.connect(self.setup_endpoint)
+            setup_socket.send(payload)
+            reply = self.receive_in_chunks(setup_socket)
+        finally:
+            setup_socket.close()
+            
+        return reply
+    
+    def setup_inbound_connection(self):
+        self.inbound_socket = self._create_socket()
+        self.inbound_socket.bind(self.inbound_endpoint)
+        self.inbound_socket.listen(5)        
+        self.inbound_connection, _ = self.inbound_socket.accept()
+
+    def receive_in_chunks(self, conn):
+        data = bytearray()
+        chunks = 0
+
+        # Receive the size of the buffer first
+        raw_size = conn.recv(4)
+        if len(raw_size) < 4:
+            e3_logger.error("Failed to receive buffer size")
+            return None
+        buffer_size = struct.unpack("!I", raw_size)[0]
+        e3_logger.debug(f"buffer size is {buffer_size}")
+
+        # Receive the buffer in chunks
+        while len(data) < buffer_size:
+            remaining = buffer_size - len(data)
+            chunk = conn.recv(min(self.CHUNK_SIZE, remaining))
+            if not chunk:
+                e3_logger.error("Connection closed unexpectedly")
+                return None  # Connection closed unexpectedly
+            data.extend(chunk)
+            chunks += 1
+
+        e3_logger.debug(f"Chunks recv {chunks}")
+        e3_logger.debug(f"Total size recv {len(data)}")
+        return bytes(data)
+    
+    def receive(self) -> bytes:
+        return self.receive_in_chunks(self.inbound_connection) 
+
+    def setup_outbound_connection(self):
+        self.outbound_socket = self._create_socket()
+        self.outbound_socket.connect(self.outbound_endpoint)
+
+    def send(self, payload: bytes):
+        self.outbound_socket.send(payload)
+    
+    def dispose(self):
+        if hasattr(self, "outbound_socket"):
+            self.outbound_socket.close()
+        if hasattr(self, "inbound_connection"):
+            self.inbound_connection.close()
+        if hasattr(self, "inbound_socket"):
+            self.inbound_socket.close()
+        
+        if self.transport_layer == E3TransportLayer.IPC:
+            os.remove(self.E3_IPC_SETUP_PATH)    
+            os.remove(self.E3_IPC_SOCKET_PATH)    
+            os.remove(self.DAPP_IPC_SOCKET_PATH)             

e3interface/e3_interface.py

@@ -0,0 +1,187 @@
+import os
+import multiprocessing
+import queue
+import threading
+from .e3_connector import E3Connector
+from .e3_logging import e3_logger
+import asn1tools
+
+class E3Interface:
+    _instance = None
+    _lock = threading.Lock()
+
+    def __new__(cls, *args, **kwargs):
+        with cls._lock:
+            if not cls._instance:
+                cls._instance = super(E3Interface, cls).__new__(cls)
+        return cls._instance
+
+    def __init__(self, *args, **kwargs):
+        if not hasattr(self, "initialized"):
+            self.callbacks = []
+            self.stop_event = multiprocessing.Event()
+            self.initialized = True
+
+            # Create an E3Connector instance based on the configuration
+            self.e3_connector = E3Connector.setup_connector(kwargs.get('link', ''), kwargs.get('transport', '')) 
+            
+            e3_logger.info(f"Endpoint setup {self.e3_connector.setup_endpoint}")
+            e3_logger.info(f"Endpoint inbound {self.e3_connector.inbound_endpoint}")
+            e3_logger.info(f"Endpoint outbound {self.e3_connector.outbound_endpoint}")
+
+            self.defs = asn1tools.compile_files(os.path.join(os.path.dirname(os.path.realpath(__file__)), "./defs/e3.asn"), codec="per") 
+            self.outbound_queue = multiprocessing.Queue()
+    
+    def send_setup_request(self, dappId: int = 1) -> bool:
+        e3_logger.info("Start setup request")
+        payload = self.create_setup_request(dappId)
+        try:
+            response = self.e3_connector.send_setup_request(payload)
+        except ConnectionRefusedError as e:
+            e3_logger.error(f"Unable to connect to E3 setup endpoint, connection refused: {e}")
+            return False
+
+        e3_logger.info("Setup response received")
+        pdu = self.defs.decode('E3-PDU', response)
+        if pdu[0] == "setupResponse":
+            e3_setup_response = pdu[1]
+            e3_logger.info(e3_setup_response)
+            # Either here or in setup connections we need E3 sub request and response
+            self.setup_connections()
+            return e3_setup_response['responseCode'] == 'positive'
+        else:
+            return False
+
+    def setup_connections(self):
+        # Two connections, one for the inbound the other for the outbound
+        self.inbound_process =  multiprocessing.Process(target=self._inbound_connection)
+        self.outbound_process = multiprocessing.Process(target=self._outbound_connection)
+        
+        self.inbound_process.start()
+        self.outbound_process.start()    
+
+    def _inbound_connection(self):
+        """
+        Inbound is for all the messages that are coming from the RAN after the initial setup 
+        """
+        e3_logger.info(f'Start inbound connection')
+        self.e3_connector.setup_inbound_connection()
+        e3_logger.info(f'Start inbound loop')
+
+        try:
+            while not self.stop_event.is_set():
+                data = self.e3_connector.receive()
+                if not data:
+                    e3_logger.error(f'No data received, connection closed, end')
+                    break
+                e3_logger.debug(f'Received data size: {len(data)}')
+                e3_logger.debug(data.hex())
+                pdu = self.defs.decode("E3-PDU", data)
+                e3_logger.debug(f"Data decoded")
+                match pdu[0]:
+                    case "indicationMessage":
+                        e3_indication_message = pdu[1]
+                        protocolData = e3_indication_message['protocolData']
+                        e3_logger.debug(protocolData)
+                        e3_logger.debug(f"Indication message protocolData {len(protocolData)}")
+                        self._handle_incoming_data(protocolData)
+
+                    case "xAppControlAction":
+                        e3_xapp_control_action = pdu[1]
+                        raise NotImplementedError()
+
+                    case _:
+                        raise ValueError("Unrecognized value ", pdu)
+                    
+        except Exception as e:
+            e3_logger.error(f"Error in inbound thread: {e}")
+            self.stop_event.set()
+        finally:
+            e3_logger.info("Close inbound connection")
+
+    def _outbound_connection(self):
+        """
+        Outbound is for all the messages that should go to the RAN after the initial setup 
+        Messages are dApp Control Action and dApp Report Message
+        """
+        e3_logger.info(f'Start outbound connection')
+        self.e3_connector.setup_outbound_connection()
+
+        e3_logger.info(f'Start outbound loop')
+        try:
+            while not self.stop_event.is_set():
+                try:
+                    msg, data = self.outbound_queue.get(timeout=0.5)
+                except queue.Empty:
+                    continue
+                
+                e3_logger.debug(f"Outbound queue has got '{msg}', {data}")
+                
+                match msg:
+                    case "control":
+                        payload = self.create_control_action(data)
+                    case "report":
+                        payload = self.create_dapp_report(data)
+
+                    case _:
+                        raise ValueError("Unrecognized value ", msg)
+
+                e3_logger.debug(f"Send the pdu encoded {payload}")
+                self.e3_connector.send(payload)
+
+        except Exception as e:
+            e3_logger.error(f"Error outbound thread: {e}")
+            self.stop_event.set()
+        finally:
+            e3_logger.info("Close outbound connection")
+
+    def _handle_incoming_data(self, data):
+        for callback in self.callbacks:
+            e3_logger.debug("Launch callback")
+            callback(data)
+                
+    def schedule_control(self, payload: bytes):
+        self.outbound_queue.put(('control', payload))
+    
+    def schedule_report(self, payload: bytes):
+        self.outbound_queue.put(('report', payload))
+
+    def add_callback(self, callback):
+        if callback not in self.callbacks:
+            e3_logger.debug("Add callback")
+            self.callbacks.append(callback)
+
+    def remove_callback(self, callback):
+        if callback in self.callbacks:
+            e3_logger.debug("Remove callback")
+            self.callbacks.remove(callback)
+
+    def terminate_connections(self):
+        e3_logger.info("Stop event")
+        self.stop_event.set()
+        
+        if hasattr(self, "inbound_process"):
+            self.inbound_process.join()
+        if hasattr(self, "outbound_process"):
+            self.outbound_process.join()
+
+        self.e3_connector.dispose()
+  
+    def create_control_action(self, actionData: bytes):
+        control_message = ("controlAction", {"actionData": actionData})
+        payload = self.defs.encode("E3-PDU", control_message)
+        return payload
+
+    def create_dapp_report(self, reportData: bytes):
+        dapp_report_message = ("dAppReport", {"reportData": reportData})
+        payload = self.defs.encode("E3-PDU", dapp_report_message)
+        return payload
+        
+    def create_setup_request(self, ranId: int = 1, ranFunctions: list = []):
+        setup_request_message = ("setupRequest", {"ranIdentifier": ranId, "ranFunctionsList": ranFunctions})
+        payload = self.defs.encode("E3-PDU", setup_request_message)
+        return payload
+
+    def __del__(self):
+        if not self.stop_event.is_set():
+           self.terminate_connections()

e3interface/e3_logging.py

@@ -0,0 +1,23 @@
+import logging
+import os
+
+LOG_DIR = ('.' if os.geteuid() != 0 else '') + '/logs/'
+
+def setup_logger(name, log_file, level=logging.INFO, format_str="[%(name)s] [%(created)f] %(levelname)s - %(message)s"):
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+
+    handler = logging.FileHandler(log_file)
+    handler.setLevel(level)
+
+    formatter = logging.Formatter(format_str)
+    handler.setFormatter(formatter)
+
+    # Avoid adding multiple handlers if logger is reused
+    if not logger.handlers:
+        logger.addHandler(handler)
+
+    return logger
+
+e3_logger = setup_logger("e3_logger", f"{LOG_DIR}/e3.log", format_str="[E3] [%(created)f] %(levelname)s - %(message)s")
+dapp_logger = setup_logger("dapp_logger", f"{LOG_DIR}/dapp.log", format_str="[dApp] [%(created)f] %(levelname)s - %(message)s")

spectrum/__init__.py

@@ -0,0 +1,4 @@
+import os
+import sys
+
+sys.path.append(os.path.realpath(os.getcwd()))

spectrum/spectrum_dapp.py

@@ -0,0 +1,169 @@
+#!/usr/bin/env python3
+"""
+dApp for Spectrum Sharing
+"""
+
+__author__ = "Andrea Lacava"
+
+import multiprocessing
+import time
+import numpy as np
+# np.set_printoptions(threshold=sys.maxsize)
+
+from dapp.dapp import DApp
+from e3interface.e3_logging import dapp_logger, LOG_DIR
+
+class SpectrumSharingDApp(DApp):
+
+    ###  Configuration ###
+    # gNB runs with BW = 40 MHz, with -E (3/4 sampling)
+    # Center frequency = 3.6192 GHz
+    # OAI sampling frequency 46.08e6
+    # 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, ota: bool = False, 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
+        
+        if ota:
+            dapp_logger.info(f'Using OTA configuration')
+            self.Noise_floor_threshold = 20 # this really depends on the RF conditions and should be carefully calibrated
+        else: # Colosseum
+            dapp_logger.info(f'Using Colosseum configuration')
+            self.Noise_floor_threshold = 53
+
+        self.save_iqs = save_iqs
+        self.e3_interface.add_callback(self.get_iqs_from_ran)
+        if self.save_iqs:
+            self.iq_save_file = open(f"{LOG_DIR}/iqs_{int(time.time())}.bin", "ab")
+            self.save_counter = 0
+            self.limit_per_file = 200
+        self.control = control
+        dapp_logger.info(f"Control is {'not ' if not self.control else ''}active")
+
+        self.energyGui = kwargs.get('energyGui', False)
+        self.iqPlotterGui = kwargs.get('iqPlotterGui', False)
+        self.demoGui = kwargs.get('demoGui', False)
+
+        self.control_count = 1
+        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) 
+
+        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)    
+
+        if self.demoGui:
+            from visualization.dashboard import DemoGui
+            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
+            self.demo = DemoGui(buffer_size=100, iq_size=iq_size) 
+
+    def get_iqs_from_ran(self, data):
+        dapp_logger.debug(f'Triggered callback')
+        if self.save_iqs:
+            dapp_logger.debug("I will write on the logfile iqs")
+            self.save_counter += 1
+            self.iq_save_file.write(data)
+            self.iq_save_file.flush()
+            if self.save_counter > self.limit_per_file:
+                self.iq_save_file.close()
+                self.iq_save_file = open(f"{LOG_DIR}/iqs_{int(time.time())}.bin", "ab")
+               
+        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)
+
+        if self.demoGui:
+            self.demo_queue.put(("iq_data", iq_arr))
+
+        if self.control:
+            dapp_logger.debug("Start control operations")
+            iq_comp = iq_arr[::2] + iq_arr[1::2] * 1j
+            dapp_logger.debug(f"Shape of iq_comp {iq_comp.shape}")
+            abs_iq = np.abs(iq_comp).astype(float)
+            dapp_logger.debug(f"After iq division self.abs_iq_av: {self.abs_iq_av.shape} abs_iq: {abs_iq.shape}")
+            self.abs_iq_av += abs_iq
+            self.control_count += 1
+            dapp_logger.debug(f"Control count is: {self.control_count}")
+
+            if self.iqPlotterGui:
+                self.iq_queue.put(iq_arr)
+
+            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 ----')
+                dapp_logger.info(f'abs_iq_av_db_offset_correct: {abs_iq_av_db_offset_correct.max()}')
+                # last_5_max_abs_iq_av_db_offset_correct = np.sort(abs_iq_av_db_offset_correct)[-20:]
+                # 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)
+                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)
+                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
+                # prb_blk_list = np.arange(start=76, stop=140, dtype=np.uint16)
+                dapp_logger.info(f"Blacklisted prbs ({prb_blk_list.size}): {prb_blk_list}")
+                prb_new = prb_blk_list.view(prb_blk_list.dtype.newbyteorder('>'))
+                
+                # Create the payload
+                size = prb_blk_list.size.to_bytes(2,'little')
+                prbs_to_send = prb_new.tobytes(order="C")
+                
+                # Schedule the delivery
+                self.e3_interface.schedule_control(size+prbs_to_send)
+
+                if self.energyGui:
+                    self.sig_queue.put(abs_iq_av_db)
+                
+                if self.demoGui:
+                    self.demo_queue.put(("prb_list", prb_blk_list))
+
+                # Reset the variables
+                self.abs_iq_av = np.zeros(self.FFT_SIZE)
+                self.control_count = 1  
+
+    def _control_loop(self):
+        if self.energyGui:
+            abs_iq_av_db = self.sig_queue.get()
+            self.energyPlotter.process_iq_data(abs_iq_av_db)
+        if self.iqPlotterGui:
+            iq_data = self.iq_queue.get()
+            self.iqPlotter.process_iq_data(iq_data)
+        if self.demoGui:
+            message = self.demo_queue.get()
+            self.demo.process_iq_data(message)
+
+    def _stop(self):        
+        if self.save_iqs:
+            self.iq_save_file.close()
+        
+        if self.demoGui:
+            self.demo.stop()

visualization/__init__.py

@@ -0,0 +1,4 @@
+import os
+import sys
+
+sys.path.append(os.path.realpath(os.getcwd()))