commit

config/nacos.py

@@ -82,7 +82,7 @@ class NacosConfig:
         while True:
             try:
                 response = await asyncio.to_thread(lambda: client.send_heartbeat(service_name, ip, port))
-                print(response)
+                # print(response)
             except Exception as e:
                 print(f"Failed to send heartbeat: {str(e)}")
             await asyncio.sleep(10)

demo.py

@@ -175,6 +175,7 @@ class USRPTransceiver:
                     print(f"接收到的信号: 形状={rx_buffer.shape}, 类型={rx_buffer.dtype}")
                     # 计算接收信号的强度 (RMS)
                     signal_rms = np.sqrt(np.mean(np.abs(rx_buffer[:num_recv]) ** 2))
+                    print(f"\r接收信号强度: {signal_rms:.3f}")
                     signal_id = self.total_rx_signals + 1
 
                     # 将信号强度加入队列 (ID, 强度)

model/surveillance_radar.py

@@ -1,4 +1,6 @@
+from math import e
 from pickletools import read_string1
+from socket import timeout
 import numpy as np
 import numpy as np
 from scipy.signal import find_peaks
@@ -18,8 +20,8 @@ class SurveillanceRadar:
     def __init__(self, usrp, rx_channel=0, tx_channel=0):
         self.usrp = usrp
         self.stop_event = Event()
-        self.tx_buffer = queue.Queue(maxsize=10)
-        self.rx_buffer = queue.Queue(maxsize=10)
+        self.tx_buffer = queue.Queue(maxsize=300)
+        self.rx_buffer = queue.Queue(maxsize=300)
 
         # 流配置参数（与demo.py保持一致）
         tx_stream_args = uhd.usrp.StreamArgs('fc32', 'sc16')
@@ -28,7 +30,7 @@ class SurveillanceRadar:
         rx_stream_args = uhd.usrp.StreamArgs('fc32','sc16')
         rx_stream_args.channels = [rx_channel]
         self.rx_stream = self.usrp.get_rx_stream(rx_stream_args)
-        self.samps_per_packet = 100
+        self.samps_per_packet = 500000
         # self.stream_timeout = 3.0
 
         # 配置设备参数（与demo.py同步）
@@ -47,11 +49,27 @@ class SurveillanceRadar:
         self.tx_signal = None  # 存储干扰信号
         self.rx_signal = None  # 接收到的信号
         self.jammed_signal = np.zeros((self.samps_per_packet,), dtype=np.complex64)  # 初始化干扰信号缓冲区
-        self.processed_signal = None  # 存储处理后的信号
-        self.tx_buffer = queue.Queue(maxsize=10)
-        self.rx_buffer = queue.Queue(maxsize=10)
+        self.processed_signal = None # 存储处理后的信号
+        self.tx_buffer = queue.Queue(maxsize=100)
+        self.rx_buffer = queue.Queue(maxsize=100)
         self.processing_thread = None
 
+    def generate_signal(self):
+            """生成具有随机强度的测试信号"""
+            t = np.arange(int(SurveillanceRadar.SAMPLING_RATE * 0.1)) / SurveillanceRadar.SAMPLING_RATE  # 0.1秒的数据
+
+            # 基础幅度为0.5，添加随机波动 (±0.3)
+            amplitude = 0.5 + 0.3 * np.random.randn()
+            amplitude = max(0.1, min(0.9, amplitude))  # 限制在合理范围内
+
+            # 添加随机相位偏移
+            phase = np.random.uniform(0, 2 * np.pi)
+
+            # 添加随机频率偏移 (±50kHz)
+            freq_offset = np.random.uniform(-50e3, 50e3)
+
+            signal = amplitude * np.exp(2j * np.pi * (1e6 + freq_offset) * t + 1j * phase)
+            return signal.astype(np.complex64), amplitude
     def tx_worker(self):
         """发送线程函数"""
         try:
@@ -64,12 +82,13 @@ class SurveillanceRadar:
 
             while not self.stop_event.is_set():
                 # 生成随机信号
-                self.tx_signal = np.random.randn(100)
+                signal, amplitude = self.generate_signal()
+                self.tx_signal = signal
                 # 应用抗干扰算法
                 samples = self.process_transmit_signal(self.tx_signal, self.anti_jamming_algorithm, self.SAMPLING_RATE)
                 # print("samples:", samples)
                 # 发送信号
-                self.tx_stream.send(samples, metadata)
+                self.tx_stream.send(signal, metadata)
                  # 将100个信号依次队列
                 #如果队列已满，则去对头元素
                 if self.tx_buffer.full():
@@ -79,14 +98,15 @@ class SurveillanceRadar:
                 time.sleep(0.05)
 
         except Exception as e:
-            self.stop_event.set()
-            metadata.end_of_burst = True
-            self.tx_stream.send(np.zeros((1,), dtype=np.complex64), metadata)
-            raise Exception(f"发送线程出错: {e}")
+            # self.stop_event.set()
+            # metadata.end_of_burst = True
+            # self.tx_stream.send(np.zeros((1,), dtype=np.complex64), metadata)
+            # raise Exception(f"发送线程出错: {e}")
+            print(f"发送线程出错: {e}")
             
             
     def rx_worker(self):
-        # try:
+        
         # 启动接收流
         stream_cmd = uhd.types.StreamCMD(uhd.types.StreamMode.start_cont)
         stream_cmd.stream_now = True
@@ -95,21 +115,22 @@ class SurveillanceRadar:
 
         buff = np.zeros((self.samps_per_packet,), dtype=np.complex64)
         while not self.stop_event.is_set():
-            num_rx = self.rx_stream.recv(buff, metadata)
-            time.sleep(0.05)
-            if metadata.error_code != uhd.types.RXMetadataErrorCode.none:
-                print(f"接收错误: {metadata.error_code}")
-                continue
-            # 将100个信号依次队列
-            if num_rx > 0:
-                #如果队列已满，则去对头元素
-                if self.rx_buffer.full():
-                    self.rx_buffer.get()
-                self.rx_buffer.put(buff.copy())
-        # except Exception as e:
-        #     stream_cmd = uhd.types.StreamCMD(uhd.types.StreamMode.stop_cont)
-        #     self.usrp.issue_stream_cmd(stream_cmd)
-        #     raise Exception(f"接收线程出错: {e}")
+            try:
+                num_rx = self.rx_stream.recv(buff, metadata,timeout=10)
+                if metadata.error_code != uhd.types.RXMetadataErrorCode.none:
+                    print(f"接收错误: {metadata.error_code}")
+                    continue
+                # 将100个信号依次队列
+                if num_rx > 0:
+                    #如果队列已满，则去对头元素
+                    if self.rx_buffer.full():
+                        self.rx_buffer.get()
+                    self.rx_buffer.put(buff.copy()[:num_rx])
+            except Exception as e:
+            # stream_cmd = uhd.types.StreamCMD(uhd.types.StreamMode.stop_cont)
+            # self.usrp.issue_stream_cmd(stream_cmd)
+            # raise Exception(f"接收线程出错: {e}")
+                print(f"接收线程出错: {e}")
 
     def process_transmit_signal(self, tx_signal: np.ndarray, algorithm: callable, sample_rate: float) -> np.ndarray:
         """
@@ -155,17 +176,24 @@ class SurveillanceRadar:
     def anti_jamming_worker(self):
         # try:
         while not self.stop_event.is_set():
-            if not self.rx_buffer.empty():
-                rx_signal = self.rx_buffer.get()
-                combined_signal = rx_signal + self.jammed_signal
-                # print("原始信号:", rx_signal)
-                # print("干扰信号:", self.jammed_signal)
-                # print("合成信号:", combined_signal)
-                self.processed_signal = self.apply_anti_jamming_processing(
-                    combined_signal,
-                    self.anti_jamming_algorithm,
-                    self.SAMPLING_RATE
-                )
+            if not self.rx_buffer.qsize() > 150:
+                list = np.array([])
+                for i in range(100):
+                    buff = self.rx_buffer.get()
+                    combined_signal = buff 
+                    # processed_signal = self.apply_anti_jamming_processing(
+                    #     combined_signal,
+                    #     self.anti_jamming_algorithm,
+                    #     self.SAMPLING_RATE
+                    # )
+                    # 计算接收信号的强度 (RMS)
+                    signal_rms = np.sqrt(np.mean(np.abs(buff) ** 2))
+                    print(f"\r接收信号强度: {signal_rms:.3f}")
+                    list = np.append(list,signal_rms)
+                print("list:",list.tolist())    
+                self.processed_signal = list
+                time.sleep(0.05)   
+
         # except Exception as e:
         #     self.stop_event.set()
         #     raise Exception(f"信号处理线程出错: {e}")

service/service.py

@@ -122,7 +122,8 @@ class Service:
             # 返回结果
             return ResponseDTO.SUCCESS({
                     "jamming_signal": np.real(jammed_signal).tolist(),
-                    "anti_jamming_signal": np.real(surveillance_radar.processed_signal).flatten().tolist(),
+                    # "anti_jamming_signal": np.real(surveillance_radar.processed_signal).flatten().tolist(),
+                    "anti_jamming_signal": surveillance_radar.processed_signal.tolist(),
                     "jamming_range": {
                         "upper": upper_bound,
                         "lower": lower_bound