加入侦干算法

.history/algo/anti_jamming_signal_algo_20250421113016.py

@@ -0,0 +1,17 @@
+import numpy as np
+from scipy import signal
+
+class AntiJammingSignalAlgo:
+    @staticmethod
+    def time_frequency_filter(rx_signal, sample_rate):
+        return signal.wiener(rx_signal)
+
+    @staticmethod
+    def adaptive_filter(rx_signal, sample_rate):
+        return signal.lfilter([1.0/3]*3, 1, rx_signal)
+
+    @staticmethod
+    def polarization_filter(rx_signal, sample_rate):
+        analytic_signal = signal.hilbert(rx_signal)
+        amplitude_envelope = np.abs(analytic_signal)
+        return rx_signal / amplitude_envelope

.history/algo/anti_jamming_signal_algo_20250421113017.py

@@ -0,0 +1,17 @@
+import numpy as np
+from scipy import signal
+
+class AntiJammingSignalAlgo:
+    @staticmethod
+    def time_frequency_filter(rx_signal, sample_rate):
+        return signal.wiener(rx_signal)
+
+    @staticmethod
+    def adaptive_filter(rx_signal, sample_rate):
+        return signal.lfilter([1.0/3]*3, 1, rx_signal)
+
+    @staticmethod
+    def polarization_filter(rx_signal, sample_rate):
+        analytic_signal = signal.hilbert(rx_signal)
+        amplitude_envelope = np.abs(analytic_signal)
+        return rx_signal / amplitude_envelope

.history/algo/anti_jamming_signal_algo_20250421114932.py

@@ -0,0 +1,6 @@
+import numpy as np
+from scipy import signal, fft, linalg
+from typing import Tuple, List
+
+
+class AntiJammingSignalAlgo:

.history/algo/anti_jamming_signal_algo_20250421115147.py

@@ -0,0 +1,33 @@
+import numpy as np
+from scipy import signal, fft, linalg
+from typing import Tuple, List
+
+
+class AntiJammingSignalAlgo:
+    @staticmethod
+    def time_frequency_filter(signal, sample_rate):
+        """时频域联合滤波算法"""
+        # 实现频域滤波与时域平滑的组合处理
+        spectrum = np.fft.fft(signal)
+        filtered_spectrum = spectrum * np.hamming(len(spectrum))
+        return np.fft.ifft(filtered_spectrum).real
+
+    @staticmethod
+    def adaptive_filter(rx_signal, reference_signal):
+        """自适应滤波算法"""
+        # 实现基于LMS的自适应滤波
+        lms_step = 0.01
+        weights = np.zeros(10)
+        for i in range(len(rx_signal)-10):
+            x = rx_signal[i:i+10]
+            error = reference_signal[i] - np.dot(weights, x)
+            weights += lms_step * error * x
+        return np.convolve(weights, rx_signal, mode='valid')
+
+    @staticmethod
+    def polarization_filter(signal, polarization_params):
+        """极化滤波算法"""
+        # 实现极化域滤波处理
+        covariance = np.cov(signal.reshape(2, -1))
+        eig_vals, eig_vecs = np.linalg.eig(covariance)
+        return eig_vecs[:, np.argmax(eig_vals)] @ signal.reshape(2, -1)

.history/algo/anti_jamming_signal_algo_20250421120144.py

@@ -0,0 +1,33 @@
+import numpy as np
+from scipy import signal, fft, linalg
+from typing import Tuple, List
+
+
+class AntiJammingSignalAlgo:
+    @staticmethod
+    def time_frequency_filter(rx_signal, sample_rate):
+        """时频域联合滤波算法"""
+        # 实现频域滤波与时域平滑的组合处理
+        spectrum = np.fft.fft(signal)
+        filtered_spectrum = spectrum * np.hamming(len(spectrum))
+        return np.fft.ifft(filtered_spectrum).real
+
+    @staticmethod
+    def adaptive_filter(rx_signal, reference_signal):
+        """自适应滤波算法"""
+        # 实现基于LMS的自适应滤波
+        lms_step = 0.01
+        weights = np.zeros(10)
+        for i in range(len(rx_signal)-10):
+            x = rx_signal[i:i+10]
+            error = reference_signal[i] - np.dot(weights, x)
+            weights += lms_step * error * x
+        return np.convolve(weights, rx_signal, mode='valid')
+
+    @staticmethod
+    def polarization_filter(signal, polarization_params):
+        """极化滤波算法"""
+        # 实现极化域滤波处理
+        covariance = np.cov(signal.reshape(2, -1))
+        eig_vals, eig_vecs = np.linalg.eig(covariance)
+        return eig_vecs[:, np.argmax(eig_vals)] @ signal.reshape(2, -1)

.history/algo/anti_jamming_signal_algo_20250421120145.py

@@ -0,0 +1,33 @@
+import numpy as np
+from scipy import signal, fft, linalg
+from typing import Tuple, List
+
+
+class AntiJammingSignalAlgo:
+    @staticmethod
+    def time_frequency_filter(rx_signal, sample_rate):
+        """时频域联合滤波算法"""
+        # 实现频域滤波与时域平滑的组合处理
+        spectrum = np.fft.fft(signal)
+        filtered_spectrum = spectrum * np.hamming(len(spectrum))
+        return np.fft.ifft(filtered_spectrum).real
+
+    @staticmethod
+    def adaptive_filter(rx_signal, reference_signal):
+        """自适应滤波算法"""
+        # 实现基于LMS的自适应滤波
+        lms_step = 0.01
+        weights = np.zeros(10)
+        for i in range(len(rx_signal)-10):
+            x = rx_signal[i:i+10]
+            error = reference_signal[i] - np.dot(weights, x)
+            weights += lms_step * error * x
+        return np.convolve(weights, rx_signal, mode='valid')
+
+    @staticmethod
+    def polarization_filter(signal, polarization_params):
+        """极化滤波算法"""
+        # 实现极化域滤波处理
+        covariance = np.cov(signal.reshape(2, -1))
+        eig_vals, eig_vecs = np.linalg.eig(covariance)
+        return eig_vecs[:, np.argmax(eig_vals)] @ signal.reshape(2, -1)

.history/algo/anti_jamming_signal_algo_20250421151703.py

@@ -0,0 +1,39 @@
+import numpy as np
+from scipy import signal, fft, linalg
+from typing import Tuple, List
+
+
+class AntiJammingSignalAlgo:
+    @staticmethod
+    def time_frequency_filter(rx_signal, sample_rate):
+        """时频域联合滤波算法"""
+        # 输入信号维度检查
+        if rx_signal.size == 0 or not np.iscomplexobj(rx_signal):
+            return np.zeros_like(rx_signal)
+            
+        # 确保信号为1维数组
+        rx_signal = np.atleast_1d(rx_signal).ravel()
+        
+        spectrum = np.fft.fft(rx_signal)
+        filtered_spectrum = spectrum * np.hamming(len(spectrum))
+        return np.fft.ifft(filtered_spectrum).real
+
+    @staticmethod
+    def adaptive_filter(rx_signal, reference_signal):
+        """自适应滤波算法"""
+        # 实现基于LMS的自适应滤波
+        lms_step = 0.01
+        weights = np.zeros(10)
+        for i in range(len(rx_signal)-10):
+            x = rx_signal[i:i+10]
+            error = reference_signal[i] - np.dot(weights, x)
+            weights += lms_step * error * x
+        return np.convolve(weights, rx_signal, mode='valid')
+
+    @staticmethod
+    def polarization_filter(signal, polarization_params):
+        """极化滤波算法"""
+        # 实现极化域滤波处理
+        covariance = np.cov(signal.reshape(2, -1))
+        eig_vals, eig_vecs = np.linalg.eig(covariance)
+        return eig_vecs[:, np.argmax(eig_vals)] @ signal.reshape(2, -1)

.history/algo/anti_jamming_signal_algo_20250421152021.py

@@ -0,0 +1,39 @@
+import numpy as np
+from scipy import signal, fft, linalg
+from typing import Tuple, List
+
+
+class AntiJammingSignalAlgo:
+    @staticmethod
+    def time_frequency_filter(rx_signal, sample_rate):
+        """时频域联合滤波算法"""
+        # 输入信号维度检查
+        if rx_signal.size == 0 or not np.iscomplexobj(rx_signal):
+            return np.zeros_like(rx_signal)
+            
+        # 确保信号为1维数组
+        rx_signal = np.atleast_1d(rx_signal).ravel()
+        
+        spectrum = np.fft.fft(rx_signal)
+        filtered_spectrum = spectrum * np.hamming(len(spectrum))
+        return np.fft.ifft(filtered_spectrum).real
+
+    @staticmethod
+    def adaptive_filter(rx_signal, reference_signal):
+        """自适应滤波算法"""
+        # 实现基于LMS的自适应滤波
+        lms_step = 0.01
+        weights = np.zeros(10)
+        for i in range(len(rx_signal)-10):
+            x = rx_signal[i:i+10]
+            error = reference_signal[i] - np.dot(weights, x)
+            weights += lms_step * error * x
+        return np.convolve(weights, rx_signal, mode='valid')
+
+    @staticmethod
+    def polarization_filter(signal, polarization_params):
+        """极化滤波算法"""
+        # 实现极化域滤波处理
+        covariance = np.cov(signal.reshape(2, -1))
+        eig_vals, eig_vecs = np.linalg.eig(covariance)
+        return eig_vecs[:, np.argmax(eig_vals)] @ signal.reshape(2, -1)

.history/algo/anti_jamming_signal_algo_20250421152138.py

@@ -0,0 +1,39 @@
+import numpy as np
+from scipy import signal, fft, linalg
+from typing import Tuple, List
+
+
+class AntiJammingSignalAlgo:
+    @staticmethod
+    def time_frequency_filter(rx_signal, sample_rate):
+        """时频域联合滤波算法"""
+        # 输入信号维度检查
+        if rx_signal.size == 0 or not np.iscomplexobj(rx_signal):
+            return np.zeros_like(rx_signal)
+            
+        # 确保信号为1维数组
+        rx_signal = np.atleast_1d(rx_signal).ravel()
+        
+        spectrum = np.fft.fft(rx_signal)
+        filtered_spectrum = spectrum * np.hamming(len(spectrum))
+        return np.fft.ifft(filtered_spectrum).real
+
+    @staticmethod
+    def adaptive_filter(rx_signal, reference_signal):
+        """自适应滤波算法"""
+        # 实现基于LMS的自适应滤波
+        lms_step = 0.01
+        weights = np.zeros(10)
+        for i in range(len(rx_signal)-10):
+            x = rx_signal[i:i+10]
+            error = reference_signal[i] - np.dot(weights, x)
+            weights += lms_step * error * x
+        return np.convolve(weights, rx_signal, mode='valid')
+
+    @staticmethod
+    def polarization_filter(signal, polarization_params):
+        """极化滤波算法"""
+        # 实现极化域滤波处理
+        covariance = np.cov(signal.reshape(2, -1))
+        eig_vals, eig_vecs = np.linalg.eig(covariance)
+        return (eig_vecs[:, np.argmax(eig_vals)] @ signal.reshape(2, -1)).real

.history/algo/anti_jamming_signal_algo_20250421152402.py

@@ -0,0 +1,39 @@
+import numpy as np
+from scipy import signal, fft, linalg
+from typing import Tuple, List
+
+
+class AntiJammingSignalAlgo:
+    @staticmethod
+    def time_frequency_filter(rx_signal, sample_rate):
+        """时频域联合滤波算法"""
+        # 输入信号维度检查
+        if rx_signal.size == 0:
+            return np.zeros_like(rx_signal)
+            
+        # 确保信号为1维数组
+        rx_signal = np.atleast_1d(rx_signal).ravel()
+        
+        spectrum = np.fft.fft(rx_signal)
+        filtered_spectrum = spectrum * np.hamming(len(spectrum))
+        return np.fft.ifft(filtered_spectrum).real
+
+    @staticmethod
+    def adaptive_filter(rx_signal, reference_signal):
+        """自适应滤波算法"""
+        # 实现基于LMS的自适应滤波
+        lms_step = 0.01
+        weights = np.zeros(10)
+        for i in range(len(rx_signal)-10):
+            x = rx_signal[i:i+10]
+            error = reference_signal[i] - np.dot(weights, x)
+            weights += lms_step * error * x
+        return np.convolve(weights, rx_signal, mode='valid')
+
+    @staticmethod
+    def polarization_filter(signal, polarization_params):
+        """极化滤波算法"""
+        # 实现极化域滤波处理
+        covariance = np.cov(signal.reshape(2, -1))
+        eig_vals, eig_vecs = np.linalg.eig(covariance)
+        return (eig_vecs[:, np.argmax(eig_vals)] @ signal.reshape(2, -1)).real

.history/algo/anti_jamming_signal_algo_20250421152403.py

@@ -0,0 +1,39 @@
+import numpy as np
+from scipy import signal, fft, linalg
+from typing import Tuple, List
+
+
+class AntiJammingSignalAlgo:
+    @staticmethod
+    def time_frequency_filter(rx_signal, sample_rate):
+        """时频域联合滤波算法"""
+        # 输入信号维度检查
+        if rx_signal.size == 0:
+            return np.zeros_like(rx_signal)
+            
+        # 确保信号为1维数组
+        rx_signal = np.atleast_1d(rx_signal).ravel()
+        
+        spectrum = np.fft.fft(rx_signal)
+        filtered_spectrum = spectrum * np.hamming(len(spectrum))
+        return np.fft.ifft(filtered_spectrum).real
+
+    @staticmethod
+    def adaptive_filter(rx_signal, reference_signal):
+        """自适应滤波算法"""
+        # 实现基于LMS的自适应滤波
+        lms_step = 0.01
+        weights = np.zeros(10)
+        for i in range(len(rx_signal)-10):
+            x = rx_signal[i:i+10]
+            error = reference_signal[i] - np.dot(weights, x)
+            weights += lms_step * error * x
+        return np.convolve(weights, rx_signal, mode='valid')
+
+    @staticmethod
+    def polarization_filter(signal, polarization_params):
+        """极化滤波算法"""
+        # 实现极化域滤波处理
+        covariance = np.cov(signal.reshape(2, -1))
+        eig_vals, eig_vecs = np.linalg.eig(covariance)
+        return (eig_vecs[:, np.argmax(eig_vals)] @ signal.reshape(2, -1)).real

.history/algo/anti_jamming_signal_algo_20250421164110.py

@@ -0,0 +1,48 @@
+import numpy as np
+from scipy import signal, fft, linalg
+from typing import Tuple, List
+
+
+class AntiJammingSignalAlgo:
+    @staticmethod
+    def time_frequency_filter(rx_signal, sample_rate):
+        """时频域联合滤波算法"""
+        # 输入信号维度检查
+        if rx_signal.size == 0:
+            return np.zeros_like(rx_signal)
+            
+        # 确保信号为1维数组
+        rx_signal = np.atleast_1d(rx_signal).ravel()
+        
+        spectrum = np.fft.fft(rx_signal)
+        filtered_spectrum = spectrum * np.hamming(len(spectrum))
+        return np.fft.ifft(filtered_spectrum).real
+
+    @staticmethod
+    def adaptive_filter(rx_signal, reference_signal):
+        """自适应滤波算法"""
+        # 实现基于LMS的自适应滤波
+        lms_step = 0.01
+        weights = np.zeros(10)
+        for i in range(len(rx_signal)-10):
+            x = rx_signal[i:i+10]
+            error = reference_signal[i] - np.dot(weights, x)
+            weights += lms_step * error * x
+        return np.convolve(weights, rx_signal, mode='valid')
+
+    @staticmethod
+    def polarization_filter(rx_signal, sample_rate, polarization_params):
+        """极化滤波算法"""
+        # 应用极化参数
+        angle_rad = np.deg2rad(polarization_params['angle'])
+        ellipticity = polarization_params['ellipticity']
+        
+        # 构建极化滤波矩阵
+        filter_matrix = np.array([
+            [np.cos(angle_rad), -ellipticity * np.sin(angle_rad)],
+            [np.sin(angle_rad), ellipticity * np.cos(angle_rad)]
+        ])
+        
+        # 应用极化滤波
+        polarized_signal = filter_matrix @ rx_signal.reshape(2, -1)
+        return polarized_signal[0].real

.history/algo/anti_jamming_signal_algo_20250421164111.py

@@ -0,0 +1,48 @@
+import numpy as np
+from scipy import signal, fft, linalg
+from typing import Tuple, List
+
+
+class AntiJammingSignalAlgo:
+    @staticmethod
+    def time_frequency_filter(rx_signal, sample_rate):
+        """时频域联合滤波算法"""
+        # 输入信号维度检查
+        if rx_signal.size == 0:
+            return np.zeros_like(rx_signal)
+            
+        # 确保信号为1维数组
+        rx_signal = np.atleast_1d(rx_signal).ravel()
+        
+        spectrum = np.fft.fft(rx_signal)
+        filtered_spectrum = spectrum * np.hamming(len(spectrum))
+        return np.fft.ifft(filtered_spectrum).real
+
+    @staticmethod
+    def adaptive_filter(rx_signal, reference_signal):
+        """自适应滤波算法"""
+        # 实现基于LMS的自适应滤波
+        lms_step = 0.01
+        weights = np.zeros(10)
+        for i in range(len(rx_signal)-10):
+            x = rx_signal[i:i+10]
+            error = reference_signal[i] - np.dot(weights, x)
+            weights += lms_step * error * x
+        return np.convolve(weights, rx_signal, mode='valid')
+
+    @staticmethod
+    def polarization_filter(rx_signal, sample_rate, polarization_params):
+        """极化滤波算法"""
+        # 应用极化参数
+        angle_rad = np.deg2rad(polarization_params['angle'])
+        ellipticity = polarization_params['ellipticity']
+        
+        # 构建极化滤波矩阵
+        filter_matrix = np.array([
+            [np.cos(angle_rad), -ellipticity * np.sin(angle_rad)],
+            [np.sin(angle_rad), ellipticity * np.cos(angle_rad)]
+        ])
+        
+        # 应用极化滤波
+        polarized_signal = filter_matrix @ rx_signal.reshape(2, -1)
+        return polarized_signal[0].real

.history/algo/anti_jamming_singal_algo_20250421114540.py

@@ -0,0 +1,200 @@
+import numpy as np
+from scipy import signal, fft, linalg
+from typing import Tuple, List
+
+
+class AntiJammingSignalAlgo:
+    """
+    雷达抗干扰算法库
+    支持对抗噪声干扰、欺骗干扰、DRFM干扰等
+    """
+
+    @staticmethod
+    def adaptive_filter(
+            rx_signal: np.ndarray,
+            reference_signal: np.ndarray,
+            filter_length: int = 32,
+            mu: float = 0.01
+    ) -> np.ndarray:
+        """
+        LMS自适应滤波（对抗噪声干扰）
+        :param rx_signal: 含干扰的接收信号
+        :param reference_signal: 参考信号（干扰样本）
+        :param filter_length: 滤波器阶数
+        :param mu: 收敛因子 (0 < mu < 1)
+        :return: 滤波后信号
+        """
+        n = len(rx_signal)
+        w = np.zeros(filter_length, dtype=np.complex64)
+        output = np.zeros(n, dtype=np.complex64)
+
+        for k in range(filter_length, n):
+            x = reference_signal[k - filter_length:k][::-1]
+            output[k] = rx_signal[k] - np.dot(w, x)
+            w += mu * output[k] * np.conj(x)
+
+        return output
+
+    @staticmethod
+    def pca_denoise(
+            signal_matrix: np.ndarray,
+            n_components: int = 3
+    ) -> np.ndarray:
+        """
+        基于PCA的信号增强（对抗宽带噪声）
+        :param signal_matrix: 多通道信号矩阵 [n_channels, n_samples]
+        :param n_components: 保留的主成分数量
+        :return: 降噪后信号
+        """
+        cov_matrix = np.cov(signal_matrix)
+        eig_vals, eig_vecs = linalg.eigh(cov_matrix)
+        idx = eig_vals.argsort()[::-1]
+        principal_components = eig_vecs[:, idx[:n_components]]
+        return np.dot(principal_components.T, signal_matrix)
+
+    @staticmethod
+    def cfar_detection(
+            spectrum: np.ndarray,
+            guard_cells: int = 2,
+            training_cells: int = 10,
+            threshold_factor: float = 3.0
+    ) -> np.ndarray:
+        """
+        CFAR目标检测（对抗欺骗干扰）
+        :param spectrum: 距离/多普勒谱
+        :param guard_cells: 保护单元数
+        :param training_cells: 训练单元数
+        :param threshold_factor: 阈值系数
+        :return: 目标掩码（True表示目标）
+        """
+        mask = np.zeros_like(spectrum, dtype=bool)
+        n = len(spectrum)
+
+        for i in range(n):
+            left = max(0, i - guard_cells - training_cells)
+            right = min(n, i + guard_cells + training_cells)
+            noise_est = np.concatenate([
+                spectrum[left:i - guard_cells],
+                spectrum[i + guard_cells:right]
+            ])
+            threshold = threshold_factor * np.mean(noise_est)
+            mask[i] = spectrum[i] > threshold
+
+        return mask
+
+    @staticmethod
+    def time_frequency_filter(
+            rx_signal: np.ndarray,
+            sample_rate: float,
+            jamming_freq: float,
+            bandwidth: float = 1e6
+    ) -> np.ndarray:
+        """
+        时频联合滤波（对抗点频干扰）
+        :param rx_signal: 接收信号
+        :param sample_rate: 采样率
+        :param jamming_freq: 干扰中心频率
+        :param bandwidth: 抑制带宽
+        :return: 滤波后信号
+        """
+        # STFT参数
+        nperseg = 256
+        noverlap = nperseg // 2
+
+        # 计算STFT
+        f, t, Zxx = signal.stft(rx_signal, fs=sample_rate,
+                                nperseg=nperseg, noverlap=noverlap)
+
+        # 构建干扰掩码
+        jamming_mask = (np.abs(f - jamming_freq) < bandwidth / 2)
+
+        # 干扰置零
+        Zxx_clean = Zxx.copy()
+        Zxx_clean[jamming_mask, :] = 0
+
+        # 逆STFT
+        _, clean_signal = signal.istft(Zxx_clean, fs=sample_rate,
+                                       nperseg=nperseg, noverlap=noverlap)
+        return clean_signal[:len(rx_signal)]
+
+    @staticmethod
+    def mti_filter(
+            pulse_matrix: np.ndarray,
+            clutter_rejection: float = 30.0
+    ) -> np.ndarray:
+        """
+        动目标显示(MTI)滤波（对抗地物杂波）
+        :param pulse_matrix: 多脉冲信号矩阵 [n_pulses, n_samples]
+        :param clutter_rejection: 杂波抑制深度(dB)
+        :return: 滤波后信号矩阵
+        """
+        # 构造对消器 (3脉冲对消器)
+        canceler = np.array([1, -2, 1])
+        output = np.apply_along_axis(
+            lambda x: np.convolve(x, canceler, mode='valid'),
+            0, pulse_matrix
+        )
+        return output * (10 ** (clutter_rejection / 20))
+
+    @staticmethod
+    def spoofing_detection(
+            pulse_train: List[np.ndarray],
+            prf: float,
+            max_velocity: float = 300.0
+    ) -> np.ndarray:
+        """
+        欺骗干扰检测（基于多普勒连续性）
+        :param pulse_train: 脉冲序列
+        :param prf: 脉冲重复频率
+        :param max_velocity: 最大合理速度(m/s)
+        :return: 干扰标记数组
+        """
+        n_pulses = len(pulse_train)
+        lambd = 3e8 / 10e9  # 假设雷达波长(10GHz)
+        max_doppler = 2 * max_velocity / lambd
+
+        # 计算多普勒谱
+        doppler_spectra = []
+        for pulse in pulse_train:
+            spec = np.abs(fft.fftshift(fft.fft(pulse)))
+            doppler_spectra.append(spec)
+
+        # 检测异常多普勒跳变
+        is_spoofed = np.zeros(n_pulses, dtype=bool)
+        for i in range(1, n_pulses):
+            corr = np.correlate(doppler_spectra[i - 1], doppler_spectra[i], 'same')
+            peak_shift = np.argmax(corr) - len(corr) // 2
+            if abs(peak_shift) > max_doppler / prf * len(corr):
+                is_spoofed[i] = True
+
+        return is_spoofed
+
+
+# ==================== 使用示例 ====================
+if __name__ == "__main__":
+    # 模拟含干扰信号
+    fs = 100e6
+    t = np.arange(0, 1e-3, 1 / fs)
+    true_signal = np.exp(1j * 2 * np.pi * 1e6 * t)
+    noise_jam = 0.5 * (np.random.normal(0, 1, len(t)) + 1j * np.random.normal(0, 1, len(t)))
+    spoof_jam = 0.3 * np.exp(1j * 2 * np.pi * 3e6 * t)
+    rx_signal = true_signal + noise_jam + spoof_jam
+
+    # 示例1：自适应滤波
+    filtered = AntiJammingSignalAlgo.adaptive_filter(
+        rx_signal,
+        reference_signal=noise_jam,
+        filter_length=16,
+        mu=0.05
+    )
+    print(f"自适应滤波后SNR提升: {10 * np.log10(np.var(filtered) / np.var(rx_signal - filtered)):.1f} dB")
+
+    # 示例2：CFAR检测
+    spectrum = np.abs(fft.fft(rx_signal))
+    targets = AntiJammingSignalAlgo.cfar_detection(spectrum)
+    print(f"CFAR检测到目标位置: {np.where(targets)[0]}")
+
+    # 示例3：欺骗干扰检测
+    pulse_train = [rx_signal[i * 100:(i + 1) * 100] for i in range(10)]
+    spoof_flags = AntiJammingSignalAlgo.spoofing_detection(pulse_train, prf=1e3)
+    print(f"受干扰脉冲索引: {np.where(spoof_flags)[0]}")

.history/algo/jamming_signal_algo_20250421112937.py

@@ -0,0 +1,20 @@
+import numpy as np
+
+class JammingSignalAlgo:
+    @staticmethod
+    def generate_noise_jam(bandwidth, duration, sample_rate):
+        num_samples = int(duration * sample_rate)
+        return np.random.normal(0, 1, num_samples)
+
+    @staticmethod
+    def generate_amplitude_noise_jam(bandwidth, duration, sample_rate):
+        t = np.arange(0, duration, 1/sample_rate)
+        carrier = np.sin(2 * np.pi * bandwidth * t)
+        noise = 0.5 * np.random.normal(0, 1, len(t))
+        return carrier * noise
+
+    @staticmethod
+    def generate_velocity_deceptive_jam(bandwidth, duration, sample_rate):
+        t = np.arange(0, duration, 1/sample_rate)
+        phase_shift = np.cumsum(np.random.uniform(-0.1, 0.1, len(t)))
+        return np.sin(2 * np.pi * bandwidth * t + phase_shift)

.history/algo/jamming_signal_algo_20250421112938.py

@@ -0,0 +1,20 @@
+import numpy as np
+
+class JammingSignalAlgo:
+    @staticmethod
+    def generate_noise_jam(bandwidth, duration, sample_rate):
+        num_samples = int(duration * sample_rate)
+        return np.random.normal(0, 1, num_samples)
+
+    @staticmethod
+    def generate_amplitude_noise_jam(bandwidth, duration, sample_rate):
+        t = np.arange(0, duration, 1/sample_rate)
+        carrier = np.sin(2 * np.pi * bandwidth * t)
+        noise = 0.5 * np.random.normal(0, 1, len(t))
+        return carrier * noise
+
+    @staticmethod
+    def generate_velocity_deceptive_jam(bandwidth, duration, sample_rate):
+        t = np.arange(0, duration, 1/sample_rate)
+        phase_shift = np.cumsum(np.random.uniform(-0.1, 0.1, len(t)))
+        return np.sin(2 * np.pi * bandwidth * t + phase_shift)

.history/algo/jamming_signal_algo_20250421114816.py

@@ -0,0 +1,27 @@
+import numpy as np
+
+class JammingSignalAlgo:
+    @staticmethod
+    def generate_noise_jam(bandwidth, duration, sample_rate):
+        num_samples = int(duration * sample_rate)
+        return np.random.normal(0, 1, num_samples)
+
+    @staticmethod
+    def generate_amplitude_noise_jam(bandwidth, duration, sample_rate):
+        t = np.arange(0, duration, 1/sample_rate)
+        carrier = np.sin(2 * np.pi * bandwidth * t)
+        noise = 0.5 * np.random.normal(0, 1, len(t))
+        return carrier * noise
+
+    @staticmethod
+    def generate_velocity_deceptive_jam(bandwidth, duration, sample_rate):
+        t = np.arange(0, duration, 1/sample_rate)
+        phase_shift = np.cumsum(np.random.uniform(-0.1, 0.1, len(t)))
+        return np.sin(2 * np.pi * bandwidth * t + phase_shift)
+
+    @staticmethod
+    def generate_deceptive_jam(bandwidth, duration, sample_rate):
+        t = np.arange(0, duration, 1/sample_rate)
+        delay = np.random.uniform(0.1, 0.5)  # 随机延迟0.1-0.5秒
+        amplitude = np.random.uniform(0.5, 2.0)  # 随机幅度调制
+        return amplitude * np.sin(2 * np.pi * bandwidth * (t - delay))

.history/algo/jamming_signal_algo_20250421114817.py

@@ -0,0 +1,27 @@
+import numpy as np
+
+class JammingSignalAlgo:
+    @staticmethod
+    def generate_noise_jam(bandwidth, duration, sample_rate):
+        num_samples = int(duration * sample_rate)
+        return np.random.normal(0, 1, num_samples)
+
+    @staticmethod
+    def generate_amplitude_noise_jam(bandwidth, duration, sample_rate):
+        t = np.arange(0, duration, 1/sample_rate)
+        carrier = np.sin(2 * np.pi * bandwidth * t)
+        noise = 0.5 * np.random.normal(0, 1, len(t))
+        return carrier * noise
+
+    @staticmethod
+    def generate_velocity_deceptive_jam(bandwidth, duration, sample_rate):
+        t = np.arange(0, duration, 1/sample_rate)
+        phase_shift = np.cumsum(np.random.uniform(-0.1, 0.1, len(t)))
+        return np.sin(2 * np.pi * bandwidth * t + phase_shift)
+
+    @staticmethod
+    def generate_deceptive_jam(bandwidth, duration, sample_rate):
+        t = np.arange(0, duration, 1/sample_rate)
+        delay = np.random.uniform(0.1, 0.5)  # 随机延迟0.1-0.5秒
+        amplitude = np.random.uniform(0.5, 2.0)  # 随机幅度调制
+        return amplitude * np.sin(2 * np.pi * bandwidth * (t - delay))

.history/algo/jamming_signal_algo_20250421173511.py

@@ -0,0 +1,35 @@
+import numpy as np
+
+class JammingSignalAlgo:
+    @staticmethod
+    def generate_noise_jam(bandwidth, duration, sample_rate):
+        num_samples = int(duration * sample_rate)
+        return np.random.normal(0, 1, num_samples)
+
+    @staticmethod
+    def generate_amplitude_noise_jam(bandwidth, duration, sample_rate):
+        t = np.arange(0, duration, 1/sample_rate)
+        carrier = np.sin(2 * np.pi * bandwidth * t)
+        noise = 0.5 * np.random.normal(0, 1, len(t))
+        return carrier * noise
+
+    @staticmethod
+    def generate_velocity_deceptive_jam(bandwidth, duration, sample_rate):
+        t = np.arange(0, duration, 1/sample_rate)
+        phase_shift = np.cumsum(np.random.uniform(-0.1, 0.1, len(t)))
+        return np.sin(2 * np.pi * bandwidth * t + phase_shift)
+
+    @staticmethod
+    def generate_deceptive_jam(bandwidth, duration, sample_rate):
+        t = np.arange(0, duration, 1/sample_rate)
+        delay = np.random.uniform(0.1, 0.5)  # 随机延迟0.1-0.5秒
+        amplitude = np.random.uniform(0.5, 2.0)  # 随机幅度调制
+        return amplitude * np.sin(2 * np.pi * bandwidth * (t - delay))
+
+    @staticmethod
+    def frequency_modulation(bandwidth, duration, sample_rate, modulation_index=0.5):
+        """噪声调频干扰算法"""
+        t = np.arange(0, duration, 1/sample_rate)
+        baseband = np.random.normal(0, 1, len(t))
+        modulated = np.sin(2 * np.pi * bandwidth * t + modulation_index * np.cumsum(baseband))
+        return modulated

.history/algo/jamming_signal_algo_20250421173813.py

@@ -0,0 +1,55 @@
+import numpy as np
+
+class JammingSignalAlgo:
+    @staticmethod
+    def generate_noise_jam(bandwidth, duration, sample_rate):
+        num_samples = int(duration * sample_rate)
+        return np.random.normal(0, 1, num_samples)
+
+    @staticmethod
+    def generate_amplitude_noise_jam(bandwidth, duration, sample_rate):
+        t = np.arange(0, duration, 1/sample_rate)
+        carrier = np.sin(2 * np.pi * bandwidth * t)
+        noise = 0.5 * np.random.normal(0, 1, len(t))
+        return carrier * noise
+
+    @staticmethod
+    def generate_velocity_deceptive_jam(bandwidth, duration, sample_rate):
+        t = np.arange(0, duration, 1/sample_rate)
+        phase_shift = np.cumsum(np.random.uniform(-0.1, 0.1, len(t)))
+        return np.sin(2 * np.pi * bandwidth * t + phase_shift)
+
+    @staticmethod
+    def generate_deceptive_jam(bandwidth, duration, sample_rate):
+        t = np.arange(0, duration, 1/sample_rate)
+        delay = np.random.uniform(0.1, 0.5)  # 随机延迟0.1-0.5秒
+        amplitude = np.random.uniform(0.5, 2.0)  # 随机幅度调制
+        return amplitude * np.sin(2 * np.pi * bandwidth * (t - delay))
+
+    @staticmethod
+    def frequency_modulation(bandwidth, duration, sample_rate, modulation_index=0.5):
+        """噪声调频干扰算法"""
+        t = np.arange(0, duration, 1/sample_rate)
+        baseband = np.random.normal(0, 1, len(t))
+        modulated = np.sin(2 * np.pi * bandwidth * t + modulation_index * np.cumsum(baseband))
+        return modulated
+
+    @staticmethod
+    def repeater_jamming(bandwidth, duration, sample_rate, delay=0.1, attenuation=0.5):
+        """转发式干扰算法"""
+        t = np.arange(0, duration, 1/sample_rate)
+        original_signal = np.sin(2 * np.pi * bandwidth * t)
+        return attenuation * np.roll(original_signal, int(delay * sample_rate))
+
+    @staticmethod
+    def velocity_deception(bandwidth, duration, sample_rate, doppler_shift=1000):
+        """速度欺骗干扰算法"""
+        t = np.arange(0, duration, 1/sample_rate)
+        return np.sin(2 * np.pi * (bandwidth + doppler_shift) * t)
+
+    @staticmethod
+    def range_deception(bandwidth, duration, sample_rate, fake_range=500):
+        """距离欺骗干扰算法"""
+        t = np.arange(0, duration, 1/sample_rate)
+        fake_delay = 2 * fake_range / 3e8  # 计算双程时延
+        return np.sin(2 * np.pi * bandwidth * (t - fake_delay))

.history/algo/jamming_signal_algo_20250421173814.py

@@ -0,0 +1,55 @@
+import numpy as np
+
+class JammingSignalAlgo:
+    @staticmethod
+    def generate_noise_jam(bandwidth, duration, sample_rate):
+        num_samples = int(duration * sample_rate)
+        return np.random.normal(0, 1, num_samples)
+
+    @staticmethod
+    def generate_amplitude_noise_jam(bandwidth, duration, sample_rate):
+        t = np.arange(0, duration, 1/sample_rate)
+        carrier = np.sin(2 * np.pi * bandwidth * t)
+        noise = 0.5 * np.random.normal(0, 1, len(t))
+        return carrier * noise
+
+    @staticmethod
+    def generate_velocity_deceptive_jam(bandwidth, duration, sample_rate):
+        t = np.arange(0, duration, 1/sample_rate)
+        phase_shift = np.cumsum(np.random.uniform(-0.1, 0.1, len(t)))
+        return np.sin(2 * np.pi * bandwidth * t + phase_shift)
+
+    @staticmethod
+    def generate_deceptive_jam(bandwidth, duration, sample_rate):
+        t = np.arange(0, duration, 1/sample_rate)
+        delay = np.random.uniform(0.1, 0.5)  # 随机延迟0.1-0.5秒
+        amplitude = np.random.uniform(0.5, 2.0)  # 随机幅度调制
+        return amplitude * np.sin(2 * np.pi * bandwidth * (t - delay))
+
+    @staticmethod
+    def frequency_modulation(bandwidth, duration, sample_rate, modulation_index=0.5):
+        """噪声调频干扰算法"""
+        t = np.arange(0, duration, 1/sample_rate)
+        baseband = np.random.normal(0, 1, len(t))
+        modulated = np.sin(2 * np.pi * bandwidth * t + modulation_index * np.cumsum(baseband))
+        return modulated
+
+    @staticmethod
+    def repeater_jamming(bandwidth, duration, sample_rate, delay=0.1, attenuation=0.5):
+        """转发式干扰算法"""
+        t = np.arange(0, duration, 1/sample_rate)
+        original_signal = np.sin(2 * np.pi * bandwidth * t)
+        return attenuation * np.roll(original_signal, int(delay * sample_rate))
+
+    @staticmethod
+    def velocity_deception(bandwidth, duration, sample_rate, doppler_shift=1000):
+        """速度欺骗干扰算法"""
+        t = np.arange(0, duration, 1/sample_rate)
+        return np.sin(2 * np.pi * (bandwidth + doppler_shift) * t)
+
+    @staticmethod
+    def range_deception(bandwidth, duration, sample_rate, fake_range=500):
+        """距离欺骗干扰算法"""
+        t = np.arange(0, duration, 1/sample_rate)
+        fake_delay = 2 * fake_range / 3e8  # 计算双程时延
+        return np.sin(2 * np.pi * bandwidth * (t - fake_delay))

.history/algo/jamming_signal_algo_20250421173847.py

@@ -0,0 +1,31 @@
+import numpy as np
+
+class JammingSignalAlgo:
+
+    @staticmethod
+    def frequency_modulation(bandwidth, duration, sample_rate, modulation_index=0.5):
+        """噪声调频干扰算法"""
+        t = np.arange(0, duration, 1/sample_rate)
+        baseband = np.random.normal(0, 1, len(t))
+        modulated = np.sin(2 * np.pi * bandwidth * t + modulation_index * np.cumsum(baseband))
+        return modulated
+
+    @staticmethod
+    def repeater_jamming(bandwidth, duration, sample_rate, delay=0.1, attenuation=0.5):
+        """转发式干扰算法"""
+        t = np.arange(0, duration, 1/sample_rate)
+        original_signal = np.sin(2 * np.pi * bandwidth * t)
+        return attenuation * np.roll(original_signal, int(delay * sample_rate))
+
+    @staticmethod
+    def velocity_deception(bandwidth, duration, sample_rate, doppler_shift=1000):
+        """速度欺骗干扰算法"""
+        t = np.arange(0, duration, 1/sample_rate)
+        return np.sin(2 * np.pi * (bandwidth + doppler_shift) * t)
+
+    @staticmethod
+    def range_deception(bandwidth, duration, sample_rate, fake_range=500):
+        """距离欺骗干扰算法"""
+        t = np.arange(0, duration, 1/sample_rate)
+        fake_delay = 2 * fake_range / 3e8  # 计算双程时延
+        return np.sin(2 * np.pi * bandwidth * (t - fake_delay))

.history/algo/jamming_signal_algo_20250421174049.py

@@ -0,0 +1,40 @@
+import numpy as np
+
+class JammingSignalAlgo:
+
+    @staticmethod
+    def frequency_modulation(bandwidth, duration, sample_rate, modulation_index=0.5):
+        """噪声调频干扰算法"""
+        t = np.arange(0, duration, 1/sample_rate)
+        baseband = np.random.normal(0, 1, len(t))
+        modulated = np.sin(2 * np.pi * bandwidth * t + modulation_index * np.cumsum(baseband))
+        return modulated
+
+    @staticmethod
+    def repeater_jamming(bandwidth, duration, sample_rate, delay=0.1, attenuation=0.5):
+        """转发式干扰算法"""
+        t = np.arange(0, duration, 1/sample_rate)
+        original_signal = np.sin(2 * np.pi * bandwidth * t)
+        return attenuation * np.roll(original_signal, int(delay * sample_rate))
+
+    @staticmethod
+    def velocity_deception(bandwidth, duration, sample_rate, doppler_shift=1000):
+        """速度欺骗干扰算法"""
+        t = np.arange(0, duration, 1/sample_rate)
+        return np.sin(2 * np.pi * (bandwidth + doppler_shift) * t)
+
+    @staticmethod
+    def range_deception(bandwidth, duration, sample_rate, fake_range=500):
+        """距离欺骗干扰算法"""
+        t = np.arange(0, duration, 1/sample_rate)
+        fake_delay = 2 * fake_range / 3e8  # 计算双程时延
+        return np.sin(2 * np.pi * bandwidth * (t - fake_delay))
+
+    @staticmethod
+    def amplitude_modulation(bandwidth, duration, sample_rate, modulation_depth=0.8):
+        """噪声调幅干扰算法"""
+        t = np.arange(0, duration, 1/sample_rate)
+        carrier = np.cos(2 * np.pi * bandwidth * t)
+        noise = np.random.normal(0, 1, len(t))
+        modulated = (1 + modulation_depth * noise) * carrier
+        return modulated

.history/algo/jamming_signal_algo_20250421174050.py

@@ -0,0 +1,40 @@
+import numpy as np
+
+class JammingSignalAlgo:
+
+    @staticmethod
+    def frequency_modulation(bandwidth, duration, sample_rate, modulation_index=0.5):
+        """噪声调频干扰算法"""
+        t = np.arange(0, duration, 1/sample_rate)
+        baseband = np.random.normal(0, 1, len(t))
+        modulated = np.sin(2 * np.pi * bandwidth * t + modulation_index * np.cumsum(baseband))
+        return modulated
+
+    @staticmethod
+    def repeater_jamming(bandwidth, duration, sample_rate, delay=0.1, attenuation=0.5):
+        """转发式干扰算法"""
+        t = np.arange(0, duration, 1/sample_rate)
+        original_signal = np.sin(2 * np.pi * bandwidth * t)
+        return attenuation * np.roll(original_signal, int(delay * sample_rate))
+
+    @staticmethod
+    def velocity_deception(bandwidth, duration, sample_rate, doppler_shift=1000):
+        """速度欺骗干扰算法"""
+        t = np.arange(0, duration, 1/sample_rate)
+        return np.sin(2 * np.pi * (bandwidth + doppler_shift) * t)
+
+    @staticmethod
+    def range_deception(bandwidth, duration, sample_rate, fake_range=500):
+        """距离欺骗干扰算法"""
+        t = np.arange(0, duration, 1/sample_rate)
+        fake_delay = 2 * fake_range / 3e8  # 计算双程时延
+        return np.sin(2 * np.pi * bandwidth * (t - fake_delay))
+
+    @staticmethod
+    def amplitude_modulation(bandwidth, duration, sample_rate, modulation_depth=0.8):
+        """噪声调幅干扰算法"""
+        t = np.arange(0, duration, 1/sample_rate)
+        carrier = np.cos(2 * np.pi * bandwidth * t)
+        noise = np.random.normal(0, 1, len(t))
+        modulated = (1 + modulation_depth * noise) * carrier
+        return modulated

.history/common/strategy_enum_20250421173601.py

@@ -0,0 +1,23 @@
+from enum import Enum
+
+
+class JammingPolicy(Enum):
+    FREQUENCY_MODULATION = "噪声调频"
+    AMPLITUDE_MODULATION = "噪声调幅"
+    REPEATER = "噪声直放"
+    VELOCITY_DECEPTION = "速度多假目标"
+    RANGE_DECEPTION = "距离多假目标"
+
+    @classmethod
+    def is_valid(cls, value):
+        return any(value == item.value for item in cls)
+
+
+class AntiJammingPolicy(Enum):
+    FREQUENCY_AGILITY = "频率捷变"
+    WAVEFORM_AGILITY = "波形捷变"
+    POLARIZATION_FILTER = "自适应极化滤波"
+
+    @classmethod
+    def is_valid(cls, value):
+        return any(value == item.value for item in cls)

.history/config/nacos_20250421104327.py

@@ -0,0 +1,89 @@
+import threading
+
+import nacos
+from v2.nacos import NacosNamingService, ClientConfigBuilder, GRPCConfig, Instance, SubscribeServiceParam, \
+    RegisterInstanceParam, DeregisterInstanceParam, BatchRegisterInstanceParam, GetServiceParam, ListServiceParam, \
+    ListInstanceParam, NacosConfigService, ConfigParam
+
+import asyncio
+NACOS_NAMESPACE_ID = 'fire'
+NACOS_USERNAME = 'nacos'
+NACOS_PASSWORD = 'nacos'
+NACOS_SERVER_ADDR = '47.92.123.216:8848'
+SERVICE_NAME = 'SDR'
+SERVICE_IP = '10.198.104.187'
+SERVICE_PORT = 5000
+
+class NacosConfig:
+
+
+    def __init__(self):
+        asyncio.run(self.init_nacos_config())
+    async def init_nacos_config(self):
+        self.client_config = self.create_config()
+        self.naming_client = await self.create_naming_client(self.client_config)
+        await self.register_instance(self.naming_client)
+        # await self.list_instance(self.naming_client)
+        self.client = nacos.NacosClient(NACOS_SERVER_ADDR, namespace=NACOS_NAMESPACE_ID)
+        thread = threading.Thread(target=self.send_heartbeat_in_thread, args=(self.client, SERVICE_NAME, SERVICE_IP, SERVICE_PORT))
+        thread.start()
+
+
+# 客户端配置
+    def create_config(self):
+        client_config = (ClientConfigBuilder()
+                         # .username(NACOS_USERNAME)
+                         # .password(NACOS_PASSWORD)
+                         .namespace_id(NACOS_NAMESPACE_ID)
+                         .server_address(NACOS_SERVER_ADDR)
+                         .log_level('DEBUG')
+                         .grpc_config(GRPCConfig(grpc_timeout=5000))
+                         .build())
+        return client_config
+
+# 创建命名客户端
+    async def create_naming_client(self, client_config):
+        naming_client = await NacosNamingService.create_naming_service(client_config)
+        return naming_client
+# 注册服务
+    async def register_instance(self, client):
+        response = await client.register_instance(
+                    request=RegisterInstanceParam(service_name= SERVICE_NAME, group_name='DEFAULT_GROUP', ip=SERVICE_IP,
+                        port=SERVICE_PORT,
+                        enabled=True,
+                        healthy=True, ephemeral=False))
+        if response:
+            print('------nacos register instance success！------')
+        else:
+            print('------nacos register instance fail！------')
+
+    async def list_instance(self, client):
+        service_list = await client.list_services(ListServiceParam())
+        for service in service_list.services:
+                print(service)
+
+    # 异步发送心跳
+    def send_heartbeat_in_thread(self,client, service_name, ip, port):
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        loop.run_until_complete(self.send_heartbeat(client, service_name, ip, port))
+        # def run():
+        #     try:
+        #         asyncio.run(self.send_heartbeat(client, service_name, ip, port))
+        #     except KeyboardInterrupt:
+        #         print("Heartbeat task interrupted")
+
+    async def send_heartbeat(self,client, service_name, ip, port):
+        while True:
+            try:
+                response = await asyncio.to_thread(lambda: client.send_heartbeat(service_name, ip, port))
+                print(response)
+            except Exception as e:
+                print(f"Failed to send heartbeat: {str(e)}")
+            await asyncio.sleep(10)
+
+
+
+
+
+

.history/config/nacos_20250421151740.py

@@ -0,0 +1,89 @@
+import threading
+
+import nacos
+from v2.nacos import NacosNamingService, ClientConfigBuilder, GRPCConfig, Instance, SubscribeServiceParam, \
+    RegisterInstanceParam, DeregisterInstanceParam, BatchRegisterInstanceParam, GetServiceParam, ListServiceParam, \
+    ListInstanceParam, NacosConfigService, ConfigParam
+
+import asyncio
+NACOS_NAMESPACE_ID = 'fire'
+NACOS_USERNAME = 'nacos'
+NACOS_PASSWORD = 'nacos'
+NACOS_SERVER_ADDR = '47.92.123.216:8848'
+SERVICE_NAME = 'SDR'
+SERVICE_IP = '10.198.104.187'
+SERVICE_PORT = 5000
+
+class NacosConfig:
+
+
+    def __init__(self):
+        asyncio.run(self.init_nacos_config())
+    async def init_nacos_config(self):
+        self.client_config = self.create_config()
+        self.naming_client = await self.create_naming_client(self.client_config)
+        await self.register_instance(self.naming_client)
+        # await self.list_instance(self.naming_client)
+        self.client = nacos.NacosClient(NACOS_SERVER_ADDR, namespace=NACOS_NAMESPACE_ID)
+        thread = threading.Thread(target=self.send_heartbeat_in_thread, args=(self.client, SERVICE_NAME, SERVICE_IP, SERVICE_PORT))
+        thread.start()
+
+
+# 客户端配置
+    def create_config(self):
+        client_config = (ClientConfigBuilder()
+                         # .username(NACOS_USERNAME)
+                         # .password(NACOS_PASSWORD)
+                         .namespace_id(NACOS_NAMESPACE_ID)
+                         .server_address(NACOS_SERVER_ADDR)
+                         .log_level('DEBUG')
+                         .grpc_config(GRPCConfig(grpc_timeout=5000))
+                         .build())
+        return client_config
+
+# 创建命名客户端
+    async def create_naming_client(self, client_config):
+        naming_client = await NacosNamingService.create_naming_service(client_config)
+        return naming_client
+# 注册服务
+    async def register_instance(self, client):
+        response = await client.register_instance(
+                    request=RegisterInstanceParam(service_name= SERVICE_NAME, group_name='DEFAULT_GROUP', ip=SERVICE_IP,
+                        port=SERVICE_PORT,
+                        enabled=True,
+                        healthy=True, ephemeral=False))
+        if response:
+            print('------nacos register instance success！------')
+        else:
+            print('------nacos register instance fail！------')
+
+    async def list_instance(self, client):
+        service_list = await client.list_services(ListServiceParam())
+        for service in service_list.services:
+                print(service)
+
+    # 异步发送心跳
+    def send_heartbeat_in_thread(self,client, service_name, ip, port):
+        # loop = asyncio.new_event_loop()
+        # asyncio.set_event_loop(loop)
+        # loop.run_until_complete(self.send_heartbeat(client, service_name, ip, port))
+        def run():
+            try:
+                asyncio.run(self.send_heartbeat(client, service_name, ip, port))
+            except KeyboardInterrupt:
+                print("Heartbeat task interrupted")
+
+    async def send_heartbeat(self,client, service_name, ip, port):
+        while True:
+            try:
+                response = await asyncio.to_thread(lambda: client.send_heartbeat(service_name, ip, port))
+                print(response)
+            except Exception as e:
+                print(f"Failed to send heartbeat: {str(e)}")
+            await asyncio.sleep(10)
+
+
+
+
+
+

.history/enums/strategy_enum_20250421172418.py

@@ -0,0 +1,23 @@
+from enum import Enum
+
+
+class JammingPolicy(Enum):
+    FREQUENCY_MODULATION = "噪声调频"
+    AMPLITUDE_MODULATION = "噪声调幅"
+    REPEATER = "噪声直放"
+    VELOCITY_DECEPTION = "速度多假目标"
+    RANGE_DECEPTION = "距离多假目标"
+
+    @classmethod
+    def is_valid(cls, value):
+        return any(value == item.value for item in cls)
+
+
+class AntiJammingPolicy(Enum):
+    FREQUENCY_AGILITY = "频率捷变"
+    WAVEFORM_AGILITY = "波形捷变"
+    POLARIZATION_FILTER = "自适应极化滤波"
+
+    @classmethod
+    def is_valid(cls, value):
+        return any(value == item.value for item in cls)

.history/enums/strategy_enum_20250421173038.py

@@ -0,0 +1,23 @@
+from enum import Enum
+
+
+class JammingPolicy(Enum):
+    FREQUENCY_MODULATION = "噪声调频"
+    AMPLITUDE_MODULATION = "噪声调幅"
+    REPEATER = "噪声直放"
+    VELOCITY_DECEPTION = "速度多假目标"
+    RANGE_DECEPTION = "距离多假目标"
+
+    @classmethod
+    def is_valid(cls, value):
+        return any(value == item.value for item in cls)
+
+
+class AntiJammingPolicy(Enum):
+    FREQUENCY_AGILITY = "频率捷变"
+    WAVEFORM_AGILITY = "波形捷变"
+    POLARIZATION_FILTER = "自适应极化滤波"
+
+    @classmethod
+    def is_valid(cls, value):
+        return any(value == item.value for item in cls)

.history/model/jammer_radar_20250421115854.py

@@ -0,0 +1,41 @@
+import numpy as np
+from scipy.signal import find_peaks
+# ==================== 干扰雷达类 ====================
+class JammerRadar:
+    def __init__(self, usrp, rx, tx):
+        self.usrp = usrp
+        self.rx = rx
+        self.tx = tx
+
+    def execute_countermeasures(self, rx_signal: np.ndarray, algorithm: callable, sample_rate: float) -> np.ndarray:
+        """
+        执行抗干扰信号处理
+        :param rx_signal: 接收信号
+        :param algorithm: 抗干扰算法
+        :param sample_rate: 采样率
+        """
+        processed_signal = algorithm(
+            rx_signal=rx_signal,
+            sample_rate=sample_rate
+        )
+        return processed_signal.astype(np.complex64)
+
+    #封装一个发送信号的函数
+    def send_signal(self, tx_signal, duration, center_freq, sample_rate, gain):
+        # 发送信号
+        self.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, self.tx, gain)
+        print('干扰雷达已发送信号')
+
+    # 封装一个接收信号的函数
+    def recv_signal(self, num_samples, sample_rate, center_freq):
+        rx_signal = self.usrp.recv_num_samps(num_samples, center_freq,sample_rate,self.rx)
+        print('侦查雷达已接收信号')
+        return rx_signal
+
+
+
+
+
+
+
+

.history/model/jammer_radar_20250421152020.py

@@ -0,0 +1,41 @@
+import numpy as np
+from scipy.signal import find_peaks
+# ==================== 干扰雷达类 ====================
+class JammerRadar:
+    def __init__(self, usrp, rx, tx):
+        self.usrp = usrp
+        self.rx = rx
+        self.tx = tx
+
+    def execute_countermeasures(self, rx_signal: np.ndarray, algorithm: callable, sample_rate: float) -> np.ndarray:
+        """
+        执行抗干扰信号处理
+        :param rx_signal: 接收信号
+        :param algorithm: 抗干扰算法
+        :param sample_rate: 采样率
+        """
+        processed_signal = algorithm(
+            rx_signal=rx_signal,
+            sample_rate=sample_rate
+        )
+        return processed_signal.astype(np.complex64)
+
+    #封装一个发送信号的函数
+    def send_signal(self, tx_signal, duration, center_freq, sample_rate, gain):
+        # 发送信号
+        self.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, self.tx, gain)
+        print('干扰雷达已发送信号')
+
+    # 封装一个接收信号的函数
+    def recv_signal(self, num_samples, sample_rate, center_freq):
+        rx_signal = self.usrp.recv_num_samps(num_samples, center_freq,sample_rate,self.rx)
+        print('侦查雷达已接收信号')
+        return rx_signal
+
+
+
+
+
+
+
+

.history/model/jammer_radar_20250421153506.py

@@ -0,0 +1,41 @@
+import numpy as np
+from scipy.signal import find_peaks
+# ==================== 干扰雷达类 ====================
+class JammerRadar:
+    def __init__(self, usrp, rx, tx):
+        self.usrp = usrp
+        self.rx = rx
+        self.tx = tx
+
+    def execute_countermeasures(self, rx_signal: np.ndarray, algorithm: callable, sample_rate: float) -> np.ndarray:
+        """
+        执行抗干扰信号处理
+        :param rx_signal: 接收信号
+        :param algorithm: 抗干扰算法
+        :param sample_rate: 采样率
+        """
+        processed_signal = algorithm(
+            rx_signal=rx_signal,
+            sample_rate=sample_rate
+        )
+        return processed_signal.astype(np.complex64)
+
+    #封装一个发送信号的函数
+    def send_signal(self, tx_signal, duration, center_freq, sample_rate, gain):
+        # 发送信号
+        self.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, self.tx, gain)
+        print('干扰雷达已发送信号')
+
+    # 封装一个接收信号的函数
+    def recv_signal(self, num_samples, sample_rate, center_freq):
+        rx_signal = self.usrp.recv_num_samps(num_samples, center_freq,sample_rate,self.rx)
+        print('侦查雷达已接收信号')
+        return rx_signal
+
+
+
+
+
+
+
+

.history/model/jammer_radar_20250421153801.py

@@ -0,0 +1,44 @@
+import numpy as np
+from scipy.signal import find_peaks
+# ==================== 干扰雷达类 ====================
+class JammerRadar:
+    def __init__(self, usrp, rx, tx):
+        self.usrp = usrp
+        self.rx = rx
+        self.tx = tx
+
+    def execute_countermeasures(self, rx_signal: np.ndarray, algorithm: callable, sample_rate: float, 
+                              **kwargs) -> np.ndarray:
+        """
+        执行抗干扰信号处理
+        :param rx_signal: 接收信号
+        :param algorithm: 抗干扰算法
+        :param sample_rate: 采样率
+        :param kwargs: 算法需要的额外参数（如参考信号、极化参数等）
+        """
+        processed_signal = algorithm(
+            rx_signal=rx_signal,
+            sample_rate=sample_rate,
+            **kwargs
+        )
+        return processed_signal.astype(np.complex64)
+
+    #封装一个发送信号的函数
+    def send_signal(self, tx_signal, duration, center_freq, sample_rate, gain):
+        # 发送信号
+        self.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, self.tx, gain)
+        print('干扰雷达已发送信号')
+
+    # 封装一个接收信号的函数
+    def recv_signal(self, num_samples, sample_rate, center_freq):
+        rx_signal = self.usrp.recv_num_samps(num_samples, center_freq,sample_rate,self.rx)
+        print('侦查雷达已接收信号')
+        return rx_signal
+
+
+
+
+
+
+
+

.history/model/jammer_radar_20250421153802.py

@@ -0,0 +1,44 @@
+import numpy as np
+from scipy.signal import find_peaks
+# ==================== 干扰雷达类 ====================
+class JammerRadar:
+    def __init__(self, usrp, rx, tx):
+        self.usrp = usrp
+        self.rx = rx
+        self.tx = tx
+
+    def execute_countermeasures(self, rx_signal: np.ndarray, algorithm: callable, sample_rate: float, 
+                              **kwargs) -> np.ndarray:
+        """
+        执行抗干扰信号处理
+        :param rx_signal: 接收信号
+        :param algorithm: 抗干扰算法
+        :param sample_rate: 采样率
+        :param kwargs: 算法需要的额外参数（如参考信号、极化参数等）
+        """
+        processed_signal = algorithm(
+            rx_signal=rx_signal,
+            sample_rate=sample_rate,
+            **kwargs
+        )
+        return processed_signal.astype(np.complex64)
+
+    #封装一个发送信号的函数
+    def send_signal(self, tx_signal, duration, center_freq, sample_rate, gain):
+        # 发送信号
+        self.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, self.tx, gain)
+        print('干扰雷达已发送信号')
+
+    # 封装一个接收信号的函数
+    def recv_signal(self, num_samples, sample_rate, center_freq):
+        rx_signal = self.usrp.recv_num_samps(num_samples, center_freq,sample_rate,self.rx)
+        print('侦查雷达已接收信号')
+        return rx_signal
+
+
+
+
+
+
+
+

.history/model/jammer_radar_20250421153910.py

@@ -0,0 +1,41 @@
+import numpy as np
+from scipy.signal import find_peaks
+# ==================== 干扰雷达类 ====================
+class JammerRadar:
+    def __init__(self, usrp, rx, tx):
+        self.usrp = usrp
+        self.rx = rx
+        self.tx = tx
+
+    def execute_countermeasures(self, rx_signal: np.ndarray, algorithm: callable, sample_rate: float) -> np.ndarray:
+        """
+        执行抗干扰信号处理
+        :param rx_signal: 接收信号
+        :param algorithm: 抗干扰算法
+        :param sample_rate: 采样率
+        """
+        processed_signal = algorithm(
+            rx_signal=rx_signal,
+            sample_rate=sample_rate
+        )
+        return processed_signal.astype(np.complex64)
+
+    #封装一个发送信号的函数
+    def send_signal(self, tx_signal, duration, center_freq, sample_rate, gain):
+        # 发送信号
+        self.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, self.tx, gain)
+        print('干扰雷达已发送信号')
+
+    # 封装一个接收信号的函数
+    def recv_signal(self, num_samples, sample_rate, center_freq):
+        rx_signal = self.usrp.recv_num_samps(num_samples, center_freq,sample_rate,self.rx)
+        print('侦查雷达已接收信号')
+        return rx_signal
+
+
+
+
+
+
+
+

.history/model/jammer_radar_20250421154013.py

@@ -0,0 +1,44 @@
+import numpy as np
+from scipy.signal import find_peaks
+# ==================== 干扰雷达类 ====================
+class JammerRadar:
+    def __init__(self, usrp, rx, tx):
+        self.usrp = usrp
+        self.rx = rx
+        self.tx = tx
+
+    def execute_jamming(self, algorithm: callable, bandwidth: float, duration: float, sample_rate: float) -> np.ndarray:
+        """
+        执行干扰信号生成
+        :param algorithm: 干扰算法
+        :param bandwidth: 信号带宽 (Hz)
+        :param duration: 信号持续时间 (秒)
+        :param sample_rate: 采样率 (Hz)
+        """
+        num_samples = int(duration * sample_rate)
+        jamming_signal = algorithm(
+            bandwidth=bandwidth,
+            duration=duration,
+            sample_rate=sample_rate
+        )
+        return jamming_signal.astype(np.complex64)
+
+    #封装一个发送信号的函数
+    def send_signal(self, tx_signal, duration, center_freq, sample_rate, gain):
+        # 发送信号
+        self.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, self.tx, gain)
+        print('干扰雷达已发送信号')
+
+    # 封装一个接收信号的函数
+    def recv_signal(self, num_samples, sample_rate, center_freq):
+        rx_signal = self.usrp.recv_num_samps(num_samples, center_freq,sample_rate,self.rx)
+        print('侦查雷达已接收信号')
+        return rx_signal
+
+
+
+
+
+
+
+

.history/model/jammer_radar_20250421154014.py

@@ -0,0 +1,44 @@
+import numpy as np
+from scipy.signal import find_peaks
+# ==================== 干扰雷达类 ====================
+class JammerRadar:
+    def __init__(self, usrp, rx, tx):
+        self.usrp = usrp
+        self.rx = rx
+        self.tx = tx
+
+    def execute_jamming(self, algorithm: callable, bandwidth: float, duration: float, sample_rate: float) -> np.ndarray:
+        """
+        执行干扰信号生成
+        :param algorithm: 干扰算法
+        :param bandwidth: 信号带宽 (Hz)
+        :param duration: 信号持续时间 (秒)
+        :param sample_rate: 采样率 (Hz)
+        """
+        num_samples = int(duration * sample_rate)
+        jamming_signal = algorithm(
+            bandwidth=bandwidth,
+            duration=duration,
+            sample_rate=sample_rate
+        )
+        return jamming_signal.astype(np.complex64)
+
+    #封装一个发送信号的函数
+    def send_signal(self, tx_signal, duration, center_freq, sample_rate, gain):
+        # 发送信号
+        self.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, self.tx, gain)
+        print('干扰雷达已发送信号')
+
+    # 封装一个接收信号的函数
+    def recv_signal(self, num_samples, sample_rate, center_freq):
+        rx_signal = self.usrp.recv_num_samps(num_samples, center_freq,sample_rate,self.rx)
+        print('侦查雷达已接收信号')
+        return rx_signal
+
+
+
+
+
+
+
+

.history/model/jammer_radar_20250421161502.py

@@ -0,0 +1,44 @@
+import numpy as np
+from scipy.signal import find_peaks
+# ==================== 干扰雷达类 ====================
+class JammerRadar:
+    def __init__(self, usrp, rx, tx):
+        self.usrp = usrp
+        self.rx = rx
+        self.tx = tx
+
+    def execute_jamming(self, rx_signal: np.ndarray, algorithm: callable, bandwidth: float, sample_rate: float) -> np.ndarray:
+        """
+        执行干扰信号生成
+        :param rx_signal: 接收的侦查信号
+        :param algorithm: 干扰算法
+        :param bandwidth: 信号带宽 (Hz)
+        :param sample_rate: 采样率 (Hz)
+        """
+        # 基于接收信号生成干扰
+        jamming_signal = algorithm(
+            rx_signal=rx_signal,
+            bandwidth=bandwidth,
+            sample_rate=sample_rate
+        )
+        return jamming_signal.astype(np.complex64)
+
+    #封装一个发送信号的函数
+    def send_signal(self, tx_signal, duration, center_freq, sample_rate, gain):
+        # 发送信号
+        self.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, self.tx, gain)
+        print('干扰雷达已发送信号')
+
+    # 封装一个接收信号的函数
+    def recv_signal(self, num_samples, sample_rate, center_freq):
+        rx_signal = self.usrp.recv_num_samps(num_samples, center_freq,sample_rate,self.rx)
+        print('干扰雷达已接收信号')
+        return rx_signal
+
+
+
+
+
+
+
+

.history/model/jammer_radar_20250421165314.py

@@ -0,0 +1,44 @@
+import numpy as np
+from scipy.signal import find_peaks
+# ==================== 干扰雷达类 ====================
+class JammerRadar:
+    def __init__(self, usrp, rx, tx):
+        self.usrp = usrp
+        self.rx = rx
+        self.tx = tx
+
+    def generate_jamming_signal(self, rx_signal: np.ndarray, algorithm: callable, bandwidth: float, sample_rate: float) -> np.ndarray:
+        """
+        生成干扰信号
+        :param rx_signal: 接收的侦查信号
+        :param algorithm: 干扰算法
+        :param bandwidth: 信号带宽 (Hz)
+        :param sample_rate: 采样率 (Hz)
+        """
+        # 基于接收信号生成干扰
+        jamming_signal = algorithm(
+            rx_signal=rx_signal,
+            bandwidth=bandwidth,
+            sample_rate=sample_rate
+        )
+        return jamming_signal.astype(np.complex64)
+
+    #封装一个发送信号的函数
+    def send_signal(self, tx_signal, duration, center_freq, sample_rate, gain):
+        # 发送信号
+        self.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, self.tx, gain)
+        print('干扰雷达已发送信号')
+
+    # 封装一个接收信号的函数
+    def recv_signal(self, num_samples, sample_rate, center_freq):
+        rx_signal = self.usrp.recv_num_samps(num_samples, center_freq,sample_rate,self.rx)
+        print('干扰雷达已接收信号')
+        return rx_signal
+
+
+
+
+
+
+
+

.history/model/jammer_radar_20250421170511.py

@@ -0,0 +1,49 @@
+import numpy as np
+from scipy.signal import find_peaks
+# ==================== 干扰雷达类 ====================
+class JammerRadar:
+    def __init__(self, usrp, rx, tx):
+        self.usrp = usrp
+        self.rx = rx
+        self.tx = tx
+
+    def generate_jamming_signal(self, algorithm: callable, bandwidth: float, sample_rate: float, duration: float, gain: float) -> np.ndarray:
+        """
+        自主生成干扰信号
+        :param algorithm: 干扰算法
+        :param bandwidth: 信号带宽 (Hz)
+        :param sample_rate: 采样率 (Hz)
+        :param duration: 信号持续时间 (秒)
+        :param gain: 增益 (dB)
+        """
+        # 生成基带噪声信号
+        num_samples = int(duration * sample_rate)
+        base_signal = np.random.randn(num_samples) * 0.1 * gain
+        
+        # 应用干扰算法
+        jamming_signal = algorithm(
+            base_signal=base_signal,
+            bandwidth=bandwidth,
+            sample_rate=sample_rate
+        )
+        return jamming_signal.astype(np.complex64)
+
+    #封装一个发送信号的函数
+    def send_signal(self, tx_signal, duration, center_freq, sample_rate, gain):
+        # 发送信号
+        self.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, self.tx, gain)
+        print('干扰雷达已发送信号')
+
+    # 封装一个接收信号的函数
+    def recv_signal(self, num_samples, sample_rate, center_freq):
+        rx_signal = self.usrp.recv_num_samps(num_samples, center_freq,sample_rate,self.rx)
+        print('干扰雷达已接收信号')
+        return rx_signal
+
+
+
+
+
+
+
+

.history/model/jammer_radar_20250421170836.py

@@ -0,0 +1,66 @@
+import numpy as np
+from scipy.signal import find_peaks
+# ==================== 干扰雷达类 ====================
+class JammerRadar:
+    def __init__(self, usrp, rx, tx):
+        self.usrp = usrp
+        self.rx = rx
+        self.tx = tx
+
+    def generate_jamming_signal(self, algorithm: callable, bandwidth: float, sample_rate: float, duration: float, gain: float) -> np.ndarray:
+        """
+        自主生成干扰信号
+        :param algorithm: 干扰算法
+        :param bandwidth: 信号带宽 (Hz)
+        :param sample_rate: 采样率 (Hz)
+        :param duration: 信号持续时间 (秒)
+        :param gain: 增益 (dB)
+        """
+        # 生成基带噪声信号
+        num_samples = int(duration * sample_rate)
+        base_signal = np.random.randn(num_samples) * 0.1 * gain
+        
+        # 应用干扰算法
+        jamming_signal = algorithm(
+            base_signal=base_signal,
+            bandwidth=bandwidth,
+            sample_rate=sample_rate
+        )
+        return jamming_signal.astype(np.complex64)
+
+    def execute_jamming(self, algorithm: callable, bandwidth: float, sample_rate: float, duration: float, gain: float) -> np.ndarray:
+        """
+        执行自主干扰生成
+        :param algorithm: 干扰算法
+        :param bandwidth: 信号带宽 (Hz)
+        :param sample_rate: 采样率 (Hz)
+        :param duration: 信号持续时间 (秒)
+        :param gain: 增益 (dB)
+        """
+        return self.generate_jamming_signal(
+            algorithm=algorithm,
+            bandwidth=bandwidth,
+            sample_rate=sample_rate,
+            duration=duration,
+            gain=gain
+        )
+
+    #封装一个发送信号的函数
+    def send_signal(self, tx_signal, duration, center_freq, sample_rate, gain):
+        # 发送信号
+        self.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, self.tx, gain)
+        print('干扰雷达已发送信号')
+
+    # 封装一个接收信号的函数
+    def recv_signal(self, num_samples, sample_rate, center_freq):
+        rx_signal = self.usrp.recv_num_samps(num_samples, center_freq,sample_rate,self.rx)
+        print('干扰雷达已接收信号')
+        return rx_signal
+
+
+
+
+
+
+
+

.history/model/jammer_radar_20250421174300.py

@@ -0,0 +1,66 @@
+import numpy as np
+from scipy.signal import find_peaks
+# ==================== 干扰雷达类 ====================
+class JammerRadar:
+    def __init__(self, usrp, rx, tx):
+        self.usrp = usrp
+        self.rx = rx
+        self.tx = tx
+
+    def generate_jamming_signal(self, algorithm: callable, bandwidth: float, sample_rate: float, duration: float, gain: float) -> np.ndarray:
+        """
+        自主生成干扰信号
+        :param algorithm: 干扰算法
+        :param bandwidth: 信号带宽 (Hz)
+        :param sample_rate: 采样率 (Hz)
+        :param duration: 信号持续时间 (秒)
+        :param gain: 增益 (dB)
+        """
+        # 生成基带噪声信号
+        num_samples = int(duration * sample_rate)
+        base_signal = np.random.randn(num_samples) * 0.1 * gain
+        
+        # 应用干扰算法
+        jamming_signal = algorithm(
+            base_signal=base_signal,
+            bandwidth=bandwidth,
+            sample_rate=sample_rate
+        )
+        return jamming_signal.astype(np.complex64)
+
+    def execute_jamming(self, algorithm: callable, bandwidth: float, sample_rate: float, duration: float, gain: float) -> np.ndarray:
+        """
+        执行自主干扰生成
+        :param algorithm: 干扰算法
+        :param bandwidth: 信号带宽 (Hz)
+        :param sample_rate: 采样率 (Hz)
+        :param duration: 信号持续时间 (秒)
+        :param gain: 增益 (dB)
+        """
+        return self.generate_jamming_signal(
+            algorithm=algorithm,
+            bandwidth=bandwidth,
+            sample_rate=sample_rate,
+            duration=duration,
+            gain=gain
+        )
+
+    #封装一个发送信号的函数
+    def send_signal(self, tx_signal, duration, center_freq, sample_rate, gain):
+        # 发送信号
+        self.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [self.tx], gain)
+        print('干扰雷达已发送信号')
+
+    # 封装一个接收信号的函数
+    def recv_signal(self, num_samples, sample_rate, center_freq):
+        rx_signal = self.usrp.recv_num_samps(num_samples, center_freq,sample_rate,self.rx)
+        print('干扰雷达已接收信号')
+        return rx_signal
+
+
+
+
+
+
+
+

.history/model/jammer_radar_20250421174523.py

@@ -0,0 +1,66 @@
+import numpy as np
+from scipy.signal import find_peaks
+# ==================== 干扰雷达类 ====================
+class JammerRadar:
+    def __init__(self, usrp, rx, tx):
+        self.usrp = usrp
+        self.rx = rx
+        self.tx = tx
+
+    def generate_jamming_signal(self, algorithm: callable, bandwidth: float, sample_rate: float, duration: float, gain: float) -> np.ndarray:
+        """
+        自主生成干扰信号
+        :param algorithm: 干扰算法
+        :param bandwidth: 信号带宽 (Hz)
+        :param sample_rate: 采样率 (Hz)
+        :param duration: 信号持续时间 (秒)
+        :param gain: 增益 (dB)
+        """
+        # 生成基带噪声信号
+        num_samples = int(duration * sample_rate)
+        base_signal = np.random.randn(num_samples) * 0.1 * gain
+        
+        # 应用干扰算法
+        jamming_signal = algorithm(
+            base_signal=base_signal,
+            bandwidth=bandwidth,
+            sample_rate=sample_rate
+        )
+        return jamming_signal.astype(np.complex64)
+
+    def execute_jamming(self, algorithm: callable, bandwidth: float, sample_rate: float, duration: float, gain: float) -> np.ndarray:
+        """
+        执行自主干扰生成
+        :param algorithm: 干扰算法
+        :param bandwidth: 信号带宽 (Hz)
+        :param sample_rate: 采样率 (Hz)
+        :param duration: 信号持续时间 (秒)
+        :param gain: 增益 (dB)
+        """
+        return self.generate_jamming_signal(
+            algorithm=algorithm,
+            bandwidth=bandwidth,
+            sample_rate=sample_rate,
+            duration=duration,
+            gain=gain
+        )
+
+    #封装一个发送信号的函数
+    def send_signal(self, tx_signal, duration, center_freq, sample_rate, gain):
+        # 发送信号
+        self.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [self.tx], gain)
+        print('干扰雷达已发送信号')
+
+    # 封装一个接收信号的函数
+    def recv_signal(self, num_samples, sample_rate, center_freq):
+        rx_signal = self.usrp.recv_num_samps(num_samples, center_freq, sample_rate, [self.rx])
+        print('干扰雷达已接收信号')
+        return rx_signal
+
+
+
+
+
+
+
+

.history/model/jammer_radar_20250421174748.py

@@ -0,0 +1,84 @@
+import numpy as np
+from scipy.signal import find_peaks
+# ==================== 干扰雷达类 ====================
+class JammerRadar:
+    def __init__(self, usrp, rx, tx):
+        self.usrp = usrp
+        self.rx = rx
+        self.tx = tx
+
+    def generate_jamming_signal(self, algorithm: callable, bandwidth: float, sample_rate: float, duration: float, gain: float) -> np.ndarray:
+        """
+        自主生成干扰信号
+        :param algorithm: 干扰算法
+        :param bandwidth: 信号带宽 (Hz)
+        :param sample_rate: 采样率 (Hz)
+        :param duration: 信号持续时间 (秒)
+        :param gain: 增益 (dB)
+        """
+        # 生成基带噪声信号
+        num_samples = int(duration * sample_rate)
+        base_signal = np.random.randn(num_samples) * 0.1 * gain
+        
+        # 应用干扰算法
+        jamming_signal = algorithm(
+            base_signal=base_signal,
+            bandwidth=bandwidth,
+            sample_rate=sample_rate
+        )
+        return jamming_signal.astype(np.complex64)
+
+    def execute_jamming(self, algorithm: callable, bandwidth: float, sample_rate: float, duration: float, gain: float) -> np.ndarray:
+        """
+        执行自主干扰生成
+        :param algorithm: 干扰算法
+        :param bandwidth: 信号带宽 (Hz)
+        :param sample_rate: 采样率 (Hz)
+        :param duration: 信号持续时间 (秒)
+        :param gain: 增益 (dB)
+        """
+        return self.generate_jamming_signal(
+            algorithm=algorithm,
+            bandwidth=bandwidth,
+            sample_rate=sample_rate,
+            duration=duration,
+            gain=gain
+        )
+
+    #封装一个发送信号的函数
+    def send_signal(self, tx_signal, duration, center_freq, sample_rate, gain):
+        # 发送信号
+        self.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [self.tx], gain)
+        print('干扰雷达已发送信号')
+
+    # 封装一个接收信号的函数
+    def recv_signal(self, num_samples, sample_rate, center_freq):
+        # 获取设备支持的最接近采样率
+        valid_rate = self._get_valid_sample_rate(sample_rate)
+        
+        if valid_rate != sample_rate:
+            print(f'警告：调整采样率 {sample_rate/1e6}MHz -> {valid_rate/1e6}MHz')
+            
+        rx_signal = self.usrp.recv_num_samps(num_samples, center_freq, valid_rate, [self.rx])
+        print('干扰雷达已接收信号')
+        return rx_signal
+
+    def _get_valid_sample_rate(self, requested_rate):
+        """获取设备支持的有效采样率"""
+        # USRP N210支持的有效采样率范围（单位：Hz）
+        MIN_RATE = 1e6   # 1 MHz
+        MAX_RATE = 25e6  # 25 MHz
+        
+        # 调整到最近的整数MHz
+        adjusted_rate = round(requested_rate / 1e6) * 1e6
+        
+        # 限制在设备支持的范围内
+        return max(MIN_RATE, min(adjusted_rate, MAX_RATE))
+
+
+
+
+
+
+
+

.history/model/jammer_radar_20250421174749.py

@@ -0,0 +1,84 @@
+import numpy as np
+from scipy.signal import find_peaks
+# ==================== 干扰雷达类 ====================
+class JammerRadar:
+    def __init__(self, usrp, rx, tx):
+        self.usrp = usrp
+        self.rx = rx
+        self.tx = tx
+
+    def generate_jamming_signal(self, algorithm: callable, bandwidth: float, sample_rate: float, duration: float, gain: float) -> np.ndarray:
+        """
+        自主生成干扰信号
+        :param algorithm: 干扰算法
+        :param bandwidth: 信号带宽 (Hz)
+        :param sample_rate: 采样率 (Hz)
+        :param duration: 信号持续时间 (秒)
+        :param gain: 增益 (dB)
+        """
+        # 生成基带噪声信号
+        num_samples = int(duration * sample_rate)
+        base_signal = np.random.randn(num_samples) * 0.1 * gain
+        
+        # 应用干扰算法
+        jamming_signal = algorithm(
+            base_signal=base_signal,
+            bandwidth=bandwidth,
+            sample_rate=sample_rate
+        )
+        return jamming_signal.astype(np.complex64)
+
+    def execute_jamming(self, algorithm: callable, bandwidth: float, sample_rate: float, duration: float, gain: float) -> np.ndarray:
+        """
+        执行自主干扰生成
+        :param algorithm: 干扰算法
+        :param bandwidth: 信号带宽 (Hz)
+        :param sample_rate: 采样率 (Hz)
+        :param duration: 信号持续时间 (秒)
+        :param gain: 增益 (dB)
+        """
+        return self.generate_jamming_signal(
+            algorithm=algorithm,
+            bandwidth=bandwidth,
+            sample_rate=sample_rate,
+            duration=duration,
+            gain=gain
+        )
+
+    #封装一个发送信号的函数
+    def send_signal(self, tx_signal, duration, center_freq, sample_rate, gain):
+        # 发送信号
+        self.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [self.tx], gain)
+        print('干扰雷达已发送信号')
+
+    # 封装一个接收信号的函数
+    def recv_signal(self, num_samples, sample_rate, center_freq):
+        # 获取设备支持的最接近采样率
+        valid_rate = self._get_valid_sample_rate(sample_rate)
+        
+        if valid_rate != sample_rate:
+            print(f'警告：调整采样率 {sample_rate/1e6}MHz -> {valid_rate/1e6}MHz')
+            
+        rx_signal = self.usrp.recv_num_samps(num_samples, center_freq, valid_rate, [self.rx])
+        print('干扰雷达已接收信号')
+        return rx_signal
+
+    def _get_valid_sample_rate(self, requested_rate):
+        """获取设备支持的有效采样率"""
+        # USRP N210支持的有效采样率范围（单位：Hz）
+        MIN_RATE = 1e6   # 1 MHz
+        MAX_RATE = 25e6  # 25 MHz
+        
+        # 调整到最近的整数MHz
+        adjusted_rate = round(requested_rate / 1e6) * 1e6
+        
+        # 限制在设备支持的范围内
+        return max(MIN_RATE, min(adjusted_rate, MAX_RATE))
+
+
+
+
+
+
+
+

.history/model/jammer_radar_20250421175236.py

@@ -0,0 +1,66 @@
+import numpy as np
+from scipy.signal import find_peaks
+# ==================== 干扰雷达类 ====================
+class JammerRadar:
+    def __init__(self, usrp, rx, tx):
+        self.usrp = usrp
+        self.rx = rx
+        self.tx = tx
+
+    def generate_jamming_signal(self, algorithm: callable, bandwidth: float, sample_rate: float, duration: float, gain: float) -> np.ndarray:
+        """
+        自主生成干扰信号
+        :param algorithm: 干扰算法
+        :param bandwidth: 信号带宽 (Hz)
+        :param sample_rate: 采样率 (Hz)
+        :param duration: 信号持续时间 (秒)
+        :param gain: 增益 (dB)
+        """
+        # 生成基带噪声信号
+        num_samples = int(duration * sample_rate)
+        base_signal = np.random.randn(num_samples) * 0.1 * gain
+        
+        # 应用干扰算法
+        jamming_signal = algorithm(
+            base_signal=base_signal,
+            bandwidth=bandwidth,
+            sample_rate=sample_rate
+        )
+        return jamming_signal.astype(np.complex64)
+
+    def execute_jamming(self, algorithm: callable, bandwidth: float, sample_rate: float, duration: float, gain: float) -> np.ndarray:
+        """
+        执行自主干扰生成
+        :param algorithm: 干扰算法
+        :param bandwidth: 信号带宽 (Hz)
+        :param sample_rate: 采样率 (Hz)
+        :param duration: 信号持续时间 (秒)
+        :param gain: 增益 (dB)
+        """
+        return self.generate_jamming_signal(
+            algorithm=algorithm,
+            bandwidth=bandwidth,
+            sample_rate=sample_rate,
+            duration=duration,
+            gain=gain
+        )
+
+    #封装一个发送信号的函数
+    def send_signal(self, tx_signal, duration, center_freq, sample_rate, gain):
+        # 发送信号
+        self.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [self.tx], gain)
+        print('干扰雷达已发送信号')
+
+    # 封装一个接收信号的函数
+    def recv_signal(self, num_samples, sample_rate, center_freq):
+        rx_signal = self.usrp.recv_num_samps(num_samples, center_freq, sample_rate, [self.rx])
+        print('干扰雷达已接收信号')
+        return rx_signal
+
+
+
+
+
+
+
+

.history/model/surveillance_radar_20250421115650.py

@@ -0,0 +1,74 @@
+import numpy as np
+from scipy.signal import find_peaks
+# ==================== 侦查雷达类 ====================
+class SurveillanceRadar:
+    #初始化函数，传入usrp，输入的通道，输出的通道
+    def __init__(self, usrp, rx, tx):
+        self.usrp = usrp
+        self.rx = rx
+        self.tx = tx
+
+        # 封装一个发送信号的函数
+    def send_signal(self, tx_signal, duration, center_freq, sample_rate, gain):
+        # 发送信号
+        self.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, self.tx, gain)
+        print('侦查雷达已发送信号')
+
+    # 封装一个接收信号的函数
+    def recv_signal(self, num_samples, sample_rate, center_freq):
+        rx_signal = self.usrp.recv_num_samps(num_samples, center_freq, sample_rate, self.rx)
+        print('侦查雷达已接收信号')
+        return rx_signal
+
+    def execute_jamming(self, algorithm: callable, bandwidth: float, duration: float, sample_rate: float) -> np.ndarray:
+        """
+        执行干扰信号生成
+        :param algorithm: 算法函数
+        :param bandwidth: 信号带宽 (Hz)
+        :param duration: 信号持续时间 (秒)
+        :param sample_rate: 采样率 (Hz)
+        """
+        num_samples = int(duration * sample_rate)
+        jamming_signal = algorithm(
+            bandwidth=bandwidth,
+            duration=duration,
+            sample_rate=sample_rate
+        )
+        return jamming_signal.astype(np.complex64)
+    # 分析信号，获取目标距离
+    def analyze_signal(self, rx_signal: np.ndarray, sample_rate: float,
+                     cfar_threshold: float = 20.0) -> list:
+        """
+        分析接收信号并返回目标距离列表
+        :param rx_signal: 接收信号（复数形式）
+        :param sample_rate: 采样率（Hz）
+        :param cfar_threshold: CFAR检测阈值（dB）
+        :return: 目标距离列表（米）
+        """
+        # 1. 去斜处理（Dechirping）
+        mixed = rx_signal * np.conj(self.tx_signal[:len(rx_signal)])
+
+        # 2. 加窗处理（Hamming窗）
+        window = np.hamming(len(mixed))
+        windowed = mixed * window
+
+        # 3. 距离FFT
+        range_fft = np.fft.fft(windowed)
+        spectrum_db = 20 * np.log10(np.abs(range_fft) + 1e-10)  # 转换为dB
+
+        # 4. 计算距离轴
+        freq_bins = np.fft.fftfreq(len(spectrum_db), 1/sample_rate)
+        ranges = (self.c * self.T * freq_bins) / (2 * self.B)
+
+        # 5. CFAR目标检测（简化版）
+        noise_floor = np.median(spectrum_db)
+        peaks, _ = find_peaks(spectrum_db, height=noise_floor + cfar_threshold)
+
+        # 6. 提取目标距离（取前向部分）
+        valid_peaks = peaks[peaks <= len(ranges)//2]
+        print(f"检测到目标距离：{[abs(ranges[p]) for p in valid_peaks]} 米")
+        return [abs(ranges[p]) for p in valid_peaks]
+
+
+
+

.history/model/surveillance_radar_20250421152020.py

@@ -0,0 +1,74 @@
+import numpy as np
+from scipy.signal import find_peaks
+# ==================== 侦查雷达类 ====================
+class SurveillanceRadar:
+    #初始化函数，传入usrp，输入的通道，输出的通道
+    def __init__(self, usrp, rx, tx):
+        self.usrp = usrp
+        self.rx = rx
+        self.tx = tx
+
+        # 封装一个发送信号的函数
+    def send_signal(self, tx_signal, duration, center_freq, sample_rate, gain):
+        # 发送信号
+        self.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, self.tx, gain)
+        print('侦查雷达已发送信号')
+
+    # 封装一个接收信号的函数
+    def recv_signal(self, num_samples, sample_rate, center_freq):
+        rx_signal = self.usrp.recv_num_samps(num_samples, center_freq, sample_rate, self.rx)
+        print('侦查雷达已接收信号')
+        return rx_signal
+
+    def execute_jamming(self, algorithm: callable, bandwidth: float, duration: float, sample_rate: float) -> np.ndarray:
+        """
+        执行干扰信号生成
+        :param algorithm: 算法函数
+        :param bandwidth: 信号带宽 (Hz)
+        :param duration: 信号持续时间 (秒)
+        :param sample_rate: 采样率 (Hz)
+        """
+        num_samples = int(duration * sample_rate)
+        jamming_signal = algorithm(
+            bandwidth=bandwidth,
+            duration=duration,
+            sample_rate=sample_rate
+        )
+        return jamming_signal.astype(np.complex64)
+    # 分析信号，获取目标距离
+    def analyze_signal(self, rx_signal: np.ndarray, sample_rate: float,
+                     cfar_threshold: float = 20.0) -> list:
+        """
+        分析接收信号并返回目标距离列表
+        :param rx_signal: 接收信号（复数形式）
+        :param sample_rate: 采样率（Hz）
+        :param cfar_threshold: CFAR检测阈值（dB）
+        :return: 目标距离列表（米）
+        """
+        # 1. 去斜处理（Dechirping）
+        mixed = rx_signal * np.conj(self.tx_signal[:len(rx_signal)])
+
+        # 2. 加窗处理（Hamming窗）
+        window = np.hamming(len(mixed))
+        windowed = mixed * window
+
+        # 3. 距离FFT
+        range_fft = np.fft.fft(windowed)
+        spectrum_db = 20 * np.log10(np.abs(range_fft) + 1e-10)  # 转换为dB
+
+        # 4. 计算距离轴
+        freq_bins = np.fft.fftfreq(len(spectrum_db), 1/sample_rate)
+        ranges = (self.c * self.T * freq_bins) / (2 * self.B)
+
+        # 5. CFAR目标检测（简化版）
+        noise_floor = np.median(spectrum_db)
+        peaks, _ = find_peaks(spectrum_db, height=noise_floor + cfar_threshold)
+
+        # 6. 提取目标距离（取前向部分）
+        valid_peaks = peaks[peaks <= len(ranges)//2]
+        print(f"检测到目标距离：{[abs(ranges[p]) for p in valid_peaks]} 米")
+        return [abs(ranges[p]) for p in valid_peaks]
+
+
+
+

.history/model/surveillance_radar_20250421154044.py

@@ -0,0 +1,73 @@
+import numpy as np
+from scipy.signal import find_peaks
+# ==================== 侦查雷达类 ====================
+class SurveillanceRadar:
+    #初始化函数，传入usrp，输入的通道，输出的通道
+    def __init__(self, usrp, rx, tx):
+        self.usrp = usrp
+        self.rx = rx
+        self.tx = tx
+
+        # 封装一个发送信号的函数
+    def send_signal(self, tx_signal, duration, center_freq, sample_rate, gain):
+        # 发送信号
+        self.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, self.tx, gain)
+        print('侦查雷达已发送信号')
+
+    # 封装一个接收信号的函数
+    def recv_signal(self, num_samples, sample_rate, center_freq):
+        rx_signal = self.usrp.recv_num_samps(num_samples, center_freq, sample_rate, self.rx)
+        print('侦查雷达已接收信号')
+        return rx_signal
+
+    def execute_anti_jamming(self, rx_signal: np.ndarray, algorithm: callable, sample_rate: float, **kwargs) -> np.ndarray:
+        """
+        执行抗干扰信号处理
+        :param rx_signal: 接收信号
+        :param algorithm: 抗干扰算法
+        :param sample_rate: 采样率
+        :param kwargs: 算法需要的额外参数
+        """
+        processed_signal = algorithm(
+            rx_signal=rx_signal,
+            sample_rate=sample_rate,
+            **kwargs
+        )
+        return processed_signal.astype(np.complex64)
+    # 分析信号，获取目标距离
+    def analyze_signal(self, rx_signal: np.ndarray, sample_rate: float,
+                     cfar_threshold: float = 20.0) -> list:
+        """
+        分析接收信号并返回目标距离列表
+        :param rx_signal: 接收信号（复数形式）
+        :param sample_rate: 采样率（Hz）
+        :param cfar_threshold: CFAR检测阈值（dB）
+        :return: 目标距离列表（米）
+        """
+        # 1. 去斜处理（Dechirping）
+        mixed = rx_signal * np.conj(self.tx_signal[:len(rx_signal)])
+
+        # 2. 加窗处理（Hamming窗）
+        window = np.hamming(len(mixed))
+        windowed = mixed * window
+
+        # 3. 距离FFT
+        range_fft = np.fft.fft(windowed)
+        spectrum_db = 20 * np.log10(np.abs(range_fft) + 1e-10)  # 转换为dB
+
+        # 4. 计算距离轴
+        freq_bins = np.fft.fftfreq(len(spectrum_db), 1/sample_rate)
+        ranges = (self.c * self.T * freq_bins) / (2 * self.B)
+
+        # 5. CFAR目标检测（简化版）
+        noise_floor = np.median(spectrum_db)
+        peaks, _ = find_peaks(spectrum_db, height=noise_floor + cfar_threshold)
+
+        # 6. 提取目标距离（取前向部分）
+        valid_peaks = peaks[peaks <= len(ranges)//2]
+        print(f"检测到目标距离：{[abs(ranges[p]) for p in valid_peaks]} 米")
+        return [abs(ranges[p]) for p in valid_peaks]
+
+
+
+

.history/model/surveillance_radar_20250421161545.py

@@ -0,0 +1,78 @@
+import numpy as np
+from scipy.signal import find_peaks
+# ==================== 侦查雷达类 ====================
+class SurveillanceRadar:
+    #初始化函数，传入usrp，输入的通道，输出的通道
+    def __init__(self, usrp, rx, tx):
+        self.usrp = usrp
+        self.rx = rx
+        self.tx = tx
+
+        # 封装一个发送信号的函数
+    def send_signal(self, tx_signal, duration, center_freq, sample_rate, gain):
+        # 发送信号并返回发射信号
+        self.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, self.tx, gain)
+        print('侦查雷达已发送信号')
+        return tx_signal
+
+    # 封装一个接收信号的函数
+    def recv_signal(self, num_samples, sample_rate, center_freq):
+        rx_signal = self.usrp.recv_num_samps(num_samples, center_freq, sample_rate, self.rx)
+        print('侦查雷达已接收信号')
+        return rx_signal
+
+    def process_transmit_signal(self, tx_signal: np.ndarray, algorithm: callable, sample_rate: float) -> np.ndarray:
+        """
+        发射端信号处理
+        :param tx_signal: 发射信号
+        :param algorithm: 发射端抗干扰算法
+        :param sample_rate: 采样率
+        """
+        return algorithm(tx_signal=tx_signal, sample_rate=sample_rate)
+
+    def execute_anti_jamming(self, rx_signal: np.ndarray, algorithm: callable, sample_rate: float, **kwargs) -> np.ndarray:
+        """
+        接收端抗干扰处理
+        :param rx_signal: 接收信号
+        :param algorithm: 接收端抗干扰算法
+        :param sample_rate: 采样率
+        """
+        processed_signal = algorithm(rx_signal=rx_signal, sample_rate=sample_rate, **kwargs)
+        return processed_signal.astype(np.complex64)
+    # 分析信号，获取目标距离
+    def analyze_signal(self, rx_signal: np.ndarray, sample_rate: float,
+                     cfar_threshold: float = 20.0) -> list:
+        """
+        分析接收信号并返回目标距离列表
+        :param rx_signal: 接收信号（复数形式）
+        :param sample_rate: 采样率（Hz）
+        :param cfar_threshold: CFAR检测阈值（dB）
+        :return: 目标距离列表（米）
+        """
+        # 1. 去斜处理（Dechirping）
+        mixed = rx_signal * np.conj(self.tx_signal[:len(rx_signal)])
+
+        # 2. 加窗处理（Hamming窗）
+        window = np.hamming(len(mixed))
+        windowed = mixed * window
+
+        # 3. 距离FFT
+        range_fft = np.fft.fft(windowed)
+        spectrum_db = 20 * np.log10(np.abs(range_fft) + 1e-10)  # 转换为dB
+
+        # 4. 计算距离轴
+        freq_bins = np.fft.fftfreq(len(spectrum_db), 1/sample_rate)
+        ranges = (self.c * self.T * freq_bins) / (2 * self.B)
+
+        # 5. CFAR目标检测（简化版）
+        noise_floor = np.median(spectrum_db)
+        peaks, _ = find_peaks(spectrum_db, height=noise_floor + cfar_threshold)
+
+        # 6. 提取目标距离（取前向部分）
+        valid_peaks = peaks[peaks <= len(ranges)//2]
+        print(f"检测到目标距离：{[abs(ranges[p]) for p in valid_peaks]} 米")
+        return [abs(ranges[p]) for p in valid_peaks]
+
+
+
+

.history/model/surveillance_radar_20250421165346.py

@@ -0,0 +1,78 @@
+import numpy as np
+from scipy.signal import find_peaks
+# ==================== 侦查雷达类 ====================
+class SurveillanceRadar:
+    #初始化函数，传入usrp，输入的通道，输出的通道
+    def __init__(self, usrp, rx, tx):
+        self.usrp = usrp
+        self.rx = rx
+        self.tx = tx
+
+        # 封装一个发送信号的函数
+    def send_signal(self, tx_signal, duration, center_freq, sample_rate, gain):
+        # 发送信号并返回发射信号
+        self.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, self.tx, gain)
+        print('侦查雷达已发送信号')
+        return tx_signal
+
+    # 封装一个接收信号的函数
+    def recv_signal(self, num_samples, sample_rate, center_freq):
+        rx_signal = self.usrp.recv_num_samps(num_samples, center_freq, sample_rate, self.rx)
+        print('侦查雷达已接收信号')
+        return rx_signal
+
+    def process_transmit_signal(self, tx_signal: np.ndarray, algorithm: callable, sample_rate: float) -> np.ndarray:
+        """
+        发射端信号处理
+        :param tx_signal: 发射信号
+        :param algorithm: 发射端抗干扰算法
+        :param sample_rate: 采样率
+        """
+        return algorithm(tx_signal=tx_signal, sample_rate=sample_rate)
+
+    def apply_anti_jamming_processing(self, rx_signal: np.ndarray, algorithm: callable, sample_rate: float, **kwargs) -> np.ndarray:
+        """
+        应用抗干扰信号处理
+        :param rx_signal: 接收信号
+        :param algorithm: 接收端抗干扰算法
+        :param sample_rate: 采样率
+        """
+        processed_signal = algorithm(rx_signal=rx_signal, sample_rate=sample_rate, **kwargs)
+        return processed_signal.astype(np.complex64)
+    # 分析信号，获取目标距离
+    def analyze_signal(self, rx_signal: np.ndarray, sample_rate: float,
+                     cfar_threshold: float = 20.0) -> list:
+        """
+        分析接收信号并返回目标距离列表
+        :param rx_signal: 接收信号（复数形式）
+        :param sample_rate: 采样率（Hz）
+        :param cfar_threshold: CFAR检测阈值（dB）
+        :return: 目标距离列表（米）
+        """
+        # 1. 去斜处理（Dechirping）
+        mixed = rx_signal * np.conj(self.tx_signal[:len(rx_signal)])
+
+        # 2. 加窗处理（Hamming窗）
+        window = np.hamming(len(mixed))
+        windowed = mixed * window
+
+        # 3. 距离FFT
+        range_fft = np.fft.fft(windowed)
+        spectrum_db = 20 * np.log10(np.abs(range_fft) + 1e-10)  # 转换为dB
+
+        # 4. 计算距离轴
+        freq_bins = np.fft.fftfreq(len(spectrum_db), 1/sample_rate)
+        ranges = (self.c * self.T * freq_bins) / (2 * self.B)
+
+        # 5. CFAR目标检测（简化版）
+        noise_floor = np.median(spectrum_db)
+        peaks, _ = find_peaks(spectrum_db, height=noise_floor + cfar_threshold)
+
+        # 6. 提取目标距离（取前向部分）
+        valid_peaks = peaks[peaks <= len(ranges)//2]
+        print(f"检测到目标距离：{[abs(ranges[p]) for p in valid_peaks]} 米")
+        return [abs(ranges[p]) for p in valid_peaks]
+
+
+
+

.history/model/surveillance_radar_20250421165347.py

@@ -0,0 +1,78 @@
+import numpy as np
+from scipy.signal import find_peaks
+# ==================== 侦查雷达类 ====================
+class SurveillanceRadar:
+    #初始化函数，传入usrp，输入的通道，输出的通道
+    def __init__(self, usrp, rx, tx):
+        self.usrp = usrp
+        self.rx = rx
+        self.tx = tx
+
+        # 封装一个发送信号的函数
+    def send_signal(self, tx_signal, duration, center_freq, sample_rate, gain):
+        # 发送信号并返回发射信号
+        self.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, self.tx, gain)
+        print('侦查雷达已发送信号')
+        return tx_signal
+
+    # 封装一个接收信号的函数
+    def recv_signal(self, num_samples, sample_rate, center_freq):
+        rx_signal = self.usrp.recv_num_samps(num_samples, center_freq, sample_rate, self.rx)
+        print('侦查雷达已接收信号')
+        return rx_signal
+
+    def process_transmit_signal(self, tx_signal: np.ndarray, algorithm: callable, sample_rate: float) -> np.ndarray:
+        """
+        发射端信号处理
+        :param tx_signal: 发射信号
+        :param algorithm: 发射端抗干扰算法
+        :param sample_rate: 采样率
+        """
+        return algorithm(tx_signal=tx_signal, sample_rate=sample_rate)
+
+    def apply_anti_jamming_processing(self, rx_signal: np.ndarray, algorithm: callable, sample_rate: float, **kwargs) -> np.ndarray:
+        """
+        应用抗干扰信号处理
+        :param rx_signal: 接收信号
+        :param algorithm: 接收端抗干扰算法
+        :param sample_rate: 采样率
+        """
+        processed_signal = algorithm(rx_signal=rx_signal, sample_rate=sample_rate, **kwargs)
+        return processed_signal.astype(np.complex64)
+    # 分析信号，获取目标距离
+    def analyze_signal(self, rx_signal: np.ndarray, sample_rate: float,
+                     cfar_threshold: float = 20.0) -> list:
+        """
+        分析接收信号并返回目标距离列表
+        :param rx_signal: 接收信号（复数形式）
+        :param sample_rate: 采样率（Hz）
+        :param cfar_threshold: CFAR检测阈值（dB）
+        :return: 目标距离列表（米）
+        """
+        # 1. 去斜处理（Dechirping）
+        mixed = rx_signal * np.conj(self.tx_signal[:len(rx_signal)])
+
+        # 2. 加窗处理（Hamming窗）
+        window = np.hamming(len(mixed))
+        windowed = mixed * window
+
+        # 3. 距离FFT
+        range_fft = np.fft.fft(windowed)
+        spectrum_db = 20 * np.log10(np.abs(range_fft) + 1e-10)  # 转换为dB
+
+        # 4. 计算距离轴
+        freq_bins = np.fft.fftfreq(len(spectrum_db), 1/sample_rate)
+        ranges = (self.c * self.T * freq_bins) / (2 * self.B)
+
+        # 5. CFAR目标检测（简化版）
+        noise_floor = np.median(spectrum_db)
+        peaks, _ = find_peaks(spectrum_db, height=noise_floor + cfar_threshold)
+
+        # 6. 提取目标距离（取前向部分）
+        valid_peaks = peaks[peaks <= len(ranges)//2]
+        print(f"检测到目标距离：{[abs(ranges[p]) for p in valid_peaks]} 米")
+        return [abs(ranges[p]) for p in valid_peaks]
+
+
+
+

.history/model/surveillance_radar_20250421174237.py

@@ -0,0 +1,79 @@
+import numpy as np
+from scipy.signal import find_peaks
+# ==================== 侦查雷达类 ====================
+class SurveillanceRadar:
+    #初始化函数，传入usrp，输入的通道，输出的通道
+    def __init__(self, usrp, rx, tx):
+        self.usrp = usrp
+        self.rx = rx
+        self.tx = tx
+
+        # 封装一个发送信号的函数
+    def send_signal(self, tx_signal, duration, center_freq, sample_rate, gain):
+        # 发送信号并返回发射信号
+        self.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [self.tx], gain)
+        print('侦查雷达已发送信号')
+        return tx_signal
+
+    # 封装一个接收信号的函数
+    def recv_signal(self, num_samples, sample_rate, center_freq):
+        rx_signal = self.usrp.recv_num_samps(num_samples, center_freq, sample_rate, self.rx)
+        print('侦查雷达已接收信号')
+        return rx_signal
+
+    def process_transmit_signal(self, tx_signal: np.ndarray, algorithm: callable, sample_rate: float) -> np.ndarray:
+        """
+        发射端信号处理
+        :param tx_signal: 发射信号
+        :param algorithm: 发射端抗干扰算法
+        :param sample_rate: 采样率
+        """
+        return algorithm(tx_signal=tx_signal, sample_rate=sample_rate)
+
+    def apply_anti_jamming_processing(self, rx_signal: np.ndarray, algorithm: callable, sample_rate: float, **kwargs) -> np.ndarray:
+        """
+        应用抗干扰信号处理
+        :param rx_signal: 接收信号
+        :param algorithm: 接收端抗干扰算法
+        :param sample_rate: 采样率
+        """
+        processed_signal = algorithm(rx_signal=rx_signal, sample_rate=sample_rate, **kwargs)
+        return processed_signal.astype(np.complex64)
+    # 分析信号，获取目标距离
+    def analyze_signal(self, rx_signal: np.ndarray, sample_rate: float,
+                     cfar_threshold: float = 20.0) -> list:
+        """
+        分析接收信号并返回目标距离列表
+        :param rx_signal: 接收信号（复数形式）
+        :param sample_rate: 采样率（Hz）
+        :param cfar_threshold: CFAR检测阈值（dB）
+        :return: 目标距离列表（米）
+        """
+        # 1. 去斜处理（Dechirping）
+        mixed = rx_signal * np.conj(self.tx_signal[:len(rx_signal)])
+
+        # 2. 加窗处理（Hamming窗）
+        window = np.hamming(len(mixed))
+        windowed = mixed * window
+
+        # 3. 距离FFT
+        range_fft = np.fft.fft(windowed)
+        spectrum_db = 20 * np.log10(np.abs(range_fft) + 1e-10)  # 转换为dB
+
+        # 4. 计算距离轴
+        freq_bins = np.fft.fftfreq(len(spectrum_db), 1/sample_rate)
+        ranges = (self.c * self.T * freq_bins) / (2 * self.B)
+
+        # 5. CFAR目标检测（简化版）
+        noise_floor = np.median(spectrum_db)
+        peaks, _ = find_peaks(spectrum_db, height=noise_floor + cfar_threshold)
+
+        # 6. 提取目标距离（取前向部分）
+        valid_peaks = peaks[peaks <= len(ranges)//2]
+        print(f"检测到目标距离：{[abs(ranges[p]) for p in valid_peaks]} 米")
+        return [abs(ranges[p]) for p in valid_peaks]
+
+
+
+
+

.history/model/surveillance_radar_20250421174238.py

@@ -0,0 +1,78 @@
+import numpy as np
+from scipy.signal import find_peaks
+# ==================== 侦查雷达类 ====================
+class SurveillanceRadar:
+    #初始化函数，传入usrp，输入的通道，输出的通道
+    def __init__(self, usrp, rx, tx):
+        self.usrp = usrp
+        self.rx = rx
+        self.tx = tx
+
+        # 封装一个发送信号的函数
+    def send_signal(self, tx_signal, duration, center_freq, sample_rate, gain):
+        # 发送信号并返回发射信号
+        self.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [self.tx], gain)
+        print('侦查雷达已发送信号')
+        return tx_signal
+
+    # 封装一个接收信号的函数
+    def recv_signal(self, num_samples, sample_rate, center_freq):
+        rx_signal = self.usrp.recv_num_samps(num_samples, center_freq, sample_rate, self.rx)
+        print('侦查雷达已接收信号')
+        return rx_signal
+
+    def process_transmit_signal(self, tx_signal: np.ndarray, algorithm: callable, sample_rate: float) -> np.ndarray:
+        """
+        发射端信号处理
+        :param tx_signal: 发射信号
+        :param algorithm: 发射端抗干扰算法
+        :param sample_rate: 采样率
+        """
+        return algorithm(tx_signal=tx_signal, sample_rate=sample_rate)
+
+    def apply_anti_jamming_processing(self, rx_signal: np.ndarray, algorithm: callable, sample_rate: float, **kwargs) -> np.ndarray:
+        """
+        应用抗干扰信号处理
+        :param rx_signal: 接收信号
+        :param algorithm: 接收端抗干扰算法
+        :param sample_rate: 采样率
+        """
+        processed_signal = algorithm(rx_signal=rx_signal, sample_rate=sample_rate, **kwargs)
+        return processed_signal.astype(np.complex64)
+    # 分析信号，获取目标距离
+    def analyze_signal(self, rx_signal: np.ndarray, sample_rate: float,
+                     cfar_threshold: float = 20.0) -> list:
+        """
+        分析接收信号并返回目标距离列表
+        :param rx_signal: 接收信号（复数形式）
+        :param sample_rate: 采样率（Hz）
+        :param cfar_threshold: CFAR检测阈值（dB）
+        :return: 目标距离列表（米）
+        """
+        # 1. 去斜处理（Dechirping）
+        mixed = rx_signal * np.conj(self.tx_signal[:len(rx_signal)])
+
+        # 2. 加窗处理（Hamming窗）
+        window = np.hamming(len(mixed))
+        windowed = mixed * window
+
+        # 3. 距离FFT
+        range_fft = np.fft.fft(windowed)
+        spectrum_db = 20 * np.log10(np.abs(range_fft) + 1e-10)  # 转换为dB
+
+        # 4. 计算距离轴
+        freq_bins = np.fft.fftfreq(len(spectrum_db), 1/sample_rate)
+        ranges = (self.c * self.T * freq_bins) / (2 * self.B)
+
+        # 5. CFAR目标检测（简化版）
+        noise_floor = np.median(spectrum_db)
+        peaks, _ = find_peaks(spectrum_db, height=noise_floor + cfar_threshold)
+
+        # 6. 提取目标距离（取前向部分）
+        valid_peaks = peaks[peaks <= len(ranges)//2]
+        print(f"检测到目标距离：{[abs(ranges[p]) for p in valid_peaks]} 米")
+        return [abs(ranges[p]) for p in valid_peaks]
+
+
+
+

.history/model/surveillance_radar_20250421174457.py

@@ -0,0 +1,78 @@
+import numpy as np
+from scipy.signal import find_peaks
+# ==================== 侦查雷达类 ====================
+class SurveillanceRadar:
+    #初始化函数，传入usrp，输入的通道，输出的通道
+    def __init__(self, usrp, rx, tx):
+        self.usrp = usrp
+        self.rx = rx
+        self.tx = tx
+
+        # 封装一个发送信号的函数
+    def send_signal(self, tx_signal, duration, center_freq, sample_rate, gain):
+        # 发送信号并返回发射信号
+        self.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [self.tx], gain)
+        print('侦查雷达已发送信号')
+        return tx_signal
+
+    # 封装一个接收信号的函数
+    def recv_signal(self, num_samples, sample_rate, center_freq):
+        rx_signal = self.usrp.recv_num_samps(num_samples, center_freq, sample_rate, [self.rx])
+        print('侦查雷达已接收信号')
+        return rx_signal
+
+    def process_transmit_signal(self, tx_signal: np.ndarray, algorithm: callable, sample_rate: float) -> np.ndarray:
+        """
+        发射端信号处理
+        :param tx_signal: 发射信号
+        :param algorithm: 发射端抗干扰算法
+        :param sample_rate: 采样率
+        """
+        return algorithm(tx_signal=tx_signal, sample_rate=sample_rate)
+
+    def apply_anti_jamming_processing(self, rx_signal: np.ndarray, algorithm: callable, sample_rate: float, **kwargs) -> np.ndarray:
+        """
+        应用抗干扰信号处理
+        :param rx_signal: 接收信号
+        :param algorithm: 接收端抗干扰算法
+        :param sample_rate: 采样率
+        """
+        processed_signal = algorithm(rx_signal=rx_signal, sample_rate=sample_rate, **kwargs)
+        return processed_signal.astype(np.complex64)
+    # 分析信号，获取目标距离
+    def analyze_signal(self, rx_signal: np.ndarray, sample_rate: float,
+                     cfar_threshold: float = 20.0) -> list:
+        """
+        分析接收信号并返回目标距离列表
+        :param rx_signal: 接收信号（复数形式）
+        :param sample_rate: 采样率（Hz）
+        :param cfar_threshold: CFAR检测阈值（dB）
+        :return: 目标距离列表（米）
+        """
+        # 1. 去斜处理（Dechirping）
+        mixed = rx_signal * np.conj(self.tx_signal[:len(rx_signal)])
+
+        # 2. 加窗处理（Hamming窗）
+        window = np.hamming(len(mixed))
+        windowed = mixed * window
+
+        # 3. 距离FFT
+        range_fft = np.fft.fft(windowed)
+        spectrum_db = 20 * np.log10(np.abs(range_fft) + 1e-10)  # 转换为dB
+
+        # 4. 计算距离轴
+        freq_bins = np.fft.fftfreq(len(spectrum_db), 1/sample_rate)
+        ranges = (self.c * self.T * freq_bins) / (2 * self.B)
+
+        # 5. CFAR目标检测（简化版）
+        noise_floor = np.median(spectrum_db)
+        peaks, _ = find_peaks(spectrum_db, height=noise_floor + cfar_threshold)
+
+        # 6. 提取目标距离（取前向部分）
+        valid_peaks = peaks[peaks <= len(ranges)//2]
+        print(f"检测到目标距离：{[abs(ranges[p]) for p in valid_peaks]} 米")
+        return [abs(ranges[p]) for p in valid_peaks]
+
+
+
+

.history/model/surveillance_radar_20250421174458.py

@@ -0,0 +1,78 @@
+import numpy as np
+from scipy.signal import find_peaks
+# ==================== 侦查雷达类 ====================
+class SurveillanceRadar:
+    #初始化函数，传入usrp，输入的通道，输出的通道
+    def __init__(self, usrp, rx, tx):
+        self.usrp = usrp
+        self.rx = rx
+        self.tx = tx
+
+        # 封装一个发送信号的函数
+    def send_signal(self, tx_signal, duration, center_freq, sample_rate, gain):
+        # 发送信号并返回发射信号
+        self.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [self.tx], gain)
+        print('侦查雷达已发送信号')
+        return tx_signal
+
+    # 封装一个接收信号的函数
+    def recv_signal(self, num_samples, sample_rate, center_freq):
+        rx_signal = self.usrp.recv_num_samps(num_samples, center_freq, sample_rate, [self.rx])
+        print('侦查雷达已接收信号')
+        return rx_signal
+
+    def process_transmit_signal(self, tx_signal: np.ndarray, algorithm: callable, sample_rate: float) -> np.ndarray:
+        """
+        发射端信号处理
+        :param tx_signal: 发射信号
+        :param algorithm: 发射端抗干扰算法
+        :param sample_rate: 采样率
+        """
+        return algorithm(tx_signal=tx_signal, sample_rate=sample_rate)
+
+    def apply_anti_jamming_processing(self, rx_signal: np.ndarray, algorithm: callable, sample_rate: float, **kwargs) -> np.ndarray:
+        """
+        应用抗干扰信号处理
+        :param rx_signal: 接收信号
+        :param algorithm: 接收端抗干扰算法
+        :param sample_rate: 采样率
+        """
+        processed_signal = algorithm(rx_signal=rx_signal, sample_rate=sample_rate, **kwargs)
+        return processed_signal.astype(np.complex64)
+    # 分析信号，获取目标距离
+    def analyze_signal(self, rx_signal: np.ndarray, sample_rate: float,
+                     cfar_threshold: float = 20.0) -> list:
+        """
+        分析接收信号并返回目标距离列表
+        :param rx_signal: 接收信号（复数形式）
+        :param sample_rate: 采样率（Hz）
+        :param cfar_threshold: CFAR检测阈值（dB）
+        :return: 目标距离列表（米）
+        """
+        # 1. 去斜处理（Dechirping）
+        mixed = rx_signal * np.conj(self.tx_signal[:len(rx_signal)])
+
+        # 2. 加窗处理（Hamming窗）
+        window = np.hamming(len(mixed))
+        windowed = mixed * window
+
+        # 3. 距离FFT
+        range_fft = np.fft.fft(windowed)
+        spectrum_db = 20 * np.log10(np.abs(range_fft) + 1e-10)  # 转换为dB
+
+        # 4. 计算距离轴
+        freq_bins = np.fft.fftfreq(len(spectrum_db), 1/sample_rate)
+        ranges = (self.c * self.T * freq_bins) / (2 * self.B)
+
+        # 5. CFAR目标检测（简化版）
+        noise_floor = np.median(spectrum_db)
+        peaks, _ = find_peaks(spectrum_db, height=noise_floor + cfar_threshold)
+
+        # 6. 提取目标距离（取前向部分）
+        valid_peaks = peaks[peaks <= len(ranges)//2]
+        print(f"检测到目标距离：{[abs(ranges[p]) for p in valid_peaks]} 米")
+        return [abs(ranges[p]) for p in valid_peaks]
+
+
+
+

.history/service/service_20250421111630.py

@@ -0,0 +1,145 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", "自适应极化滤波"
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量，用于存储设备状态，初始化为0
+    _rlock = threading.RLock()  # 可重入锁，用于线程锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.status = 1  # 初始化成功，状态置为1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        jamming_policy = payload['jamming_policy']
+        anti_jamming_policy = payload['anti_jamming_policy']
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        Service.send()
+        # 根据策略选择算法
+        jam_algorithm = Service._get_algorithm_mapping(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 生成实际干扰信号和抗干扰处理
+        surveillance_signal = jam_algorithm(
+            bandwidth=100e6,
+            duration=0.1,
+            sample_rate=1e6,
+            jamming_type='blanket'
+        ) if jam_algorithm else np.random.randn(100)
+        
+        processed_signal = anti_jam_algorithm(
+            rx_signal=surveillance_signal,
+            sample_rate=1e6,
+            jamming_freq=100e6
+        ) if anti_jam_algorithm else surveillance_signal
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": surveillance_signal.tolist(),
+                                    "anti_jamming_signal": surveillance_signal_back.tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def demo():
+        # 实例化侦查雷达和干扰雷达
+        surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+        jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+        return surveillance_radar, jammer_radar
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 策略与算法映射关系
+        algorithm_map = {
+            "噪声调频": JammingSignalAlgo.generate_noise_jam,
+            "距离多假目标": JammingSignalAlgo.generate_deceptive_jam,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter,
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter
+        }
+        return algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()

.history/service/service_20250421111631.py

@@ -0,0 +1,145 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", "自适应极化滤波"
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量，用于存储设备状态，初始化为0
+    _rlock = threading.RLock()  # 可重入锁，用于线程锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.status = 1  # 初始化成功，状态置为1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        jamming_policy = payload['jamming_policy']
+        anti_jamming_policy = payload['anti_jamming_policy']
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        Service.send()
+        # 根据策略选择算法
+        jam_algorithm = Service._get_algorithm_mapping(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 生成实际干扰信号和抗干扰处理
+        surveillance_signal = jam_algorithm(
+            bandwidth=100e6,
+            duration=0.1,
+            sample_rate=1e6,
+            jamming_type='blanket'
+        ) if jam_algorithm else np.random.randn(100)
+        
+        processed_signal = anti_jam_algorithm(
+            rx_signal=surveillance_signal,
+            sample_rate=1e6,
+            jamming_freq=100e6
+        ) if anti_jam_algorithm else surveillance_signal
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": surveillance_signal.tolist(),
+                                    "anti_jamming_signal": surveillance_signal_back.tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def demo():
+        # 实例化侦查雷达和干扰雷达
+        surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+        jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+        return surveillance_radar, jammer_radar
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 策略与算法映射关系
+        algorithm_map = {
+            "噪声调频": JammingSignalAlgo.generate_noise_jam,
+            "距离多假目标": JammingSignalAlgo.generate_deceptive_jam,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter,
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter
+        }
+        return algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()

.history/service/service_20250421112027.py

@@ -0,0 +1,149 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", "自适应极化滤波"
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量，用于存储设备状态，初始化为0
+    _rlock = threading.RLock()  # 可重入锁，用于线程锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.status = 1  # 初始化成功，状态置为1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 实例化侦查雷达和干扰雷达
+        surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+        jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+        
+        jamming_policy = payload['jamming_policy']
+        anti_jamming_policy = payload['anti_jamming_policy']
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        Service.send()
+        # 根据策略选择算法
+        jam_algorithm = Service._get_algorithm_mapping(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 生成实际干扰信号和抗干扰处理
+        surveillance_signal = surveillance_radar.execute_jamming(
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            duration=0.1,
+            sample_rate=1e6
+        ) if jam_algorithm else np.random.randn(100)
+        
+        processed_signal = jammer_radar.execute_countermeasures(
+            rx_signal=surveillance_signal,
+            algorithm=anti_jam_algorithm,
+            sample_rate=1e6
+        ) if anti_jam_algorithm else surveillance_signal
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": surveillance_signal.tolist(),
+                                    "anti_jamming_signal": surveillance_signal_back.tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def demo():
+        # 实例化侦查雷达和干扰雷达
+        surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+        jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+        return surveillance_radar, jammer_radar
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 策略与算法映射关系
+        algorithm_map = {
+            "噪声调频": JammingSignalAlgo.generate_noise_jam,
+            "距离多假目标": JammingSignalAlgo.generate_deceptive_jam,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter,
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter
+        }
+        return algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()

.history/service/service_20250421112359.py

@@ -0,0 +1,141 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", "自适应极化滤波"
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量，用于存储设备状态，初始化为0
+    _rlock = threading.RLock()  # 可重入锁，用于线程锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.status = 1  # 初始化成功，状态置为1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 实例化侦查雷达和干扰雷达
+        surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+        jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+        
+        jamming_policy = payload['jamming_policy']
+        anti_jamming_policy = payload['anti_jamming_policy']
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_algorithm_mapping(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 生成实际干扰信号和抗干扰处理
+        surveillance_signal = surveillance_radar.execute_jamming(
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            duration=0.1,
+            sample_rate=1e6
+        ) if jam_algorithm else np.random.randn(100)
+        
+        processed_signal = jammer_radar.execute_countermeasures(
+            rx_signal=surveillance_signal,
+            algorithm=anti_jam_algorithm,
+            sample_rate=1e6
+        ) if anti_jam_algorithm else surveillance_signal
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": surveillance_signal.tolist(),
+                                    "anti_jamming_signal": surveillance_signal_back.tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 策略与算法映射关系
+        algorithm_map = {
+            "噪声调频": JammingSignalAlgo.generate_noise_jam,
+            "距离多假目标": JammingSignalAlgo.generate_deceptive_jam,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter,
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter
+        }
+        return algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()

.history/service/service_20250421112517.py

@@ -0,0 +1,145 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", "自适应极化滤波"
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload['jamming_policy']
+        anti_jamming_policy = payload['anti_jamming_policy']
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_algorithm_mapping(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 生成实际干扰信号和抗干扰处理
+        surveillance_signal = surveillance_radar.execute_jamming(
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            duration=0.1,
+            sample_rate=1e6
+        ) if jam_algorithm else np.random.randn(100)
+        
+        processed_signal = jammer_radar.execute_countermeasures(
+            rx_signal=surveillance_signal,
+            algorithm=anti_jam_algorithm,
+            sample_rate=1e6
+        ) if anti_jam_algorithm else surveillance_signal
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": surveillance_signal.tolist(),
+                                    "anti_jamming_signal": surveillance_signal_back.tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 策略与算法映射关系
+        algorithm_map = {
+            "噪声调频": JammingSignalAlgo.generate_noise_jam,
+            "距离多假目标": JammingSignalAlgo.generate_deceptive_jam,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter,
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter
+        }
+        return algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()

.history/service/service_20250421112518.py

@@ -0,0 +1,145 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", "自适应极化滤波"
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload['jamming_policy']
+        anti_jamming_policy = payload['anti_jamming_policy']
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_algorithm_mapping(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 生成实际干扰信号和抗干扰处理
+        surveillance_signal = surveillance_radar.execute_jamming(
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            duration=0.1,
+            sample_rate=1e6
+        ) if jam_algorithm else np.random.randn(100)
+        
+        processed_signal = jammer_radar.execute_countermeasures(
+            rx_signal=surveillance_signal,
+            algorithm=anti_jam_algorithm,
+            sample_rate=1e6
+        ) if anti_jam_algorithm else surveillance_signal
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": surveillance_signal.tolist(),
+                                    "anti_jamming_signal": surveillance_signal_back.tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 策略与算法映射关系
+        algorithm_map = {
+            "噪声调频": JammingSignalAlgo.generate_noise_jam,
+            "距离多假目标": JammingSignalAlgo.generate_deceptive_jam,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter,
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter
+        }
+        return algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()

.history/service/service_20250421112641.py

@@ -0,0 +1,145 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", "自适应极化滤波"
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload['jamming_policy']
+        anti_jamming_policy = payload['anti_jamming_policy']
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_algorithm_mapping(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 生成实际干扰信号和抗干扰处理
+        surveillance_signal = surveillance_radar.execute_jamming(
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            duration=0.1,
+            sample_rate=1e6
+        ) if jam_algorithm else np.random.randn(100)
+        
+        processed_signal = jammer_radar.execute_countermeasures(
+            rx_signal=surveillance_signal,
+            algorithm=anti_jam_algorithm,
+            sample_rate=1e6
+        ) if anti_jam_algorithm else surveillance_signal
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": surveillance_signal.tolist(),
+                                    "anti_jamming_signal": surveillance_signal_back.tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 策略与算法映射关系
+        algorithm_map = {
+            "噪声调频": JammingSignalAlgo.generate_noise_jam,
+            "距离多假目标": JammingSignalAlgo.generate_deceptive_jam,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter,
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter
+        }
+        return algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()

.history/service/service_20250421113046.py

@@ -0,0 +1,149 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", "自适应极化滤波"
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload['jamming_policy']
+        anti_jamming_policy = payload['anti_jamming_policy']
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_algorithm_mapping(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 生成实际干扰信号和抗干扰处理
+        surveillance_signal = surveillance_radar.execute_jamming(
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            duration=0.1,
+            sample_rate=1e6
+        ) if jam_algorithm else np.random.randn(100)
+        
+        processed_signal = jammer_radar.execute_countermeasures(
+            rx_signal=surveillance_signal,
+            algorithm=anti_jam_algorithm,
+            sample_rate=1e6
+        ) if anti_jam_algorithm else surveillance_signal
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": surveillance_signal.tolist(),
+                                    "anti_jamming_signal": surveillance_signal_back.tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 策略与算法映射关系
+        algorithm_map = {
+            "噪声调频": JammingSignalAlgo.generate_noise_jam,
+            "噪声调幅": JammingSignalAlgo.generate_amplitude_noise_jam,
+            "噪声直放": JammingSignalAlgo.generate_noise_jam,
+            "速度多假目标": JammingSignalAlgo.generate_velocity_deceptive_jam,
+            "距离多假目标": JammingSignalAlgo.generate_deceptive_jam,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter,
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        return algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()

.history/service/service_20250421113106.py

@@ -0,0 +1,149 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", "自适应极化滤波"
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload['jamming_policy']
+        anti_jamming_policy = payload['anti_jamming_policy']
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_algorithm_mapping(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 生成实际干扰信号和抗干扰处理
+        surveillance_signal = surveillance_radar.execute_jamming(
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            duration=0.1,
+            sample_rate=1e6
+        ) if jam_algorithm else np.random.randn(100)
+        
+        processed_signal = jammer_radar.execute_countermeasures(
+            rx_signal=surveillance_signal,
+            algorithm=anti_jam_algorithm,
+            sample_rate=1e6
+        ) if anti_jam_algorithm else surveillance_signal
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": surveillance_signal.tolist(),
+                                    "anti_jamming_signal": processed_signal.tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 策略与算法映射关系
+        algorithm_map = {
+            "噪声调频": JammingSignalAlgo.generate_noise_jam,
+            "噪声调幅": JammingSignalAlgo.generate_amplitude_noise_jam,
+            "噪声直放": JammingSignalAlgo.generate_noise_jam,
+            "速度多假目标": JammingSignalAlgo.generate_velocity_deceptive_jam,
+            "距离多假目标": JammingSignalAlgo.generate_deceptive_jam,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter,
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        return algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()

.history/service/service_20250421113810.py

@@ -0,0 +1,150 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", "自适应极化滤波"
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload['jamming_policy']
+        anti_jamming_policy = payload['anti_jamming_policy']
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_algorithm_mapping(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 生成实际干扰信号和抗干扰处理
+        surveillance_signal = surveillance_radar.execute_jamming(
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            duration=0.1,
+            sample_rate=1e6
+        ) if jam_algorithm else np.random.randn(100)
+        
+        processed_signal = jammer_radar.execute_countermeasures(
+            rx_signal=surveillance_signal,
+            algorithm=anti_jam_algorithm,
+            sample_rate=1e6
+        ) if anti_jam_algorithm else surveillance_signal
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": surveillance_signal.tolist(),
+                                    "anti_jamming_signal": processed_signal.tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 策略与算法映射关系
+        algorithm_map = {
+            "噪声调频": JammingSignalAlgo.generate_noise_jam,
+            "噪声调幅": JammingSignalAlgo.generate_amplitude_noise_jam,
+            "噪声直放": JammingSignalAlgo.generate_noise_jam,
+            "速度多假目标": JammingSignalAlgo.generate_velocity_deceptive_jam,
+            "距离多假目标": JammingSignalAlgo.generate_deceptive_jam,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter,
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        return algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()

.history/service/service_20250421113900.py

@@ -0,0 +1,151 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", "自适应极化滤波"
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload['jamming_policy']
+        anti_jamming_policy = payload['anti_jamming_policy']
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_algorithm_mapping(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 生成实际干扰信号和抗干扰处理
+        surveillance_signal = surveillance_radar.execute_jamming(
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            duration=0.1,
+            sample_rate=1e6
+        ) if jam_algorithm else np.random.randn(100)
+        
+        processed_signal = jammer_radar.execute_countermeasures(
+            rx_signal=surveillance_signal,
+            algorithm=anti_jam_algorithm,
+            sample_rate=1e6
+        ) if anti_jam_algorithm else surveillance_signal
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": surveillance_signal.tolist(),
+                                    "anti_jamming_signal": processed_signal.tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 策略与算法映射关系
+        algorithm_map = {
+            "噪声调频": JammingSignalAlgo.generate_noise_jam,
+            "噪声调幅": JammingSignalAlgo.generate_amplitude_noise_jam,
+            "噪声直放": JammingSignalAlgo.generate_noise_jam,
+            "速度多假目标": JammingSignalAlgo.generate_velocity_deceptive_jam,
+            "距离多假目标": JammingSignalAlgo.generate_deceptive_jam,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter,
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        return algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()
+    Service.data({"jamming_policy": "噪声调频", "anti_jamming_policy": "频率捷变"})

.history/service/service_20250421115425.py

@@ -0,0 +1,152 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+from algo.anti_jamming_signal_algo import AntiJammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", "自适应极化滤波"
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload['jamming_policy']
+        anti_jamming_policy = payload['anti_jamming_policy']
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_algorithm_mapping(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 生成实际干扰信号和抗干扰处理
+        surveillance_signal = surveillance_radar.execute_jamming(
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            duration=0.1,
+            sample_rate=1e6
+        ) if jam_algorithm else np.random.randn(100)
+        
+        processed_signal = jammer_radar.execute_countermeasures(
+            rx_signal=surveillance_signal,
+            algorithm=anti_jam_algorithm,
+            sample_rate=1e6
+        ) if anti_jam_algorithm else surveillance_signal
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": surveillance_signal.tolist(),
+                                    "anti_jamming_signal": processed_signal.tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 策略与算法映射关系
+        algorithm_map = {
+            "噪声调频": JammingSignalAlgo.generate_noise_jam,
+            "噪声调幅": JammingSignalAlgo.generate_amplitude_noise_jam,
+            "噪声直放": JammingSignalAlgo.generate_noise_jam,
+            "速度多假目标": JammingSignalAlgo.generate_velocity_deceptive_jam,
+            "距离多假目标": JammingSignalAlgo.generate_deceptive_jam,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter,
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        return algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()
+    Service.data({"jamming_policy": "噪声调频", "anti_jamming_policy": "频率捷变"})

.history/service/service_20250421150714.py

@@ -0,0 +1,152 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+from algo.anti_jamming_signal_algo import AntiJammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", "自适应极化滤波"
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = args.get('jamming_policy')
+        anti_jamming_policy = args.get('anti_jamming_policy')
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_algorithm_mapping(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 生成实际干扰信号和抗干扰处理
+        surveillance_signal = surveillance_radar.execute_jamming(
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            duration=0.1,
+            sample_rate=1e6
+        ) if jam_algorithm else np.random.randn(100)
+        
+        processed_signal = jammer_radar.execute_countermeasures(
+            rx_signal=surveillance_signal,
+            algorithm=anti_jam_algorithm,
+            sample_rate=1e6
+        ) if anti_jam_algorithm else surveillance_signal
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": surveillance_signal.tolist(),
+                                    "anti_jamming_signal": processed_signal.tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 策略与算法映射关系
+        algorithm_map = {
+            "噪声调频": JammingSignalAlgo.generate_noise_jam,
+            "噪声调幅": JammingSignalAlgo.generate_amplitude_noise_jam,
+            "噪声直放": JammingSignalAlgo.generate_noise_jam,
+            "速度多假目标": JammingSignalAlgo.generate_velocity_deceptive_jam,
+            "距离多假目标": JammingSignalAlgo.generate_deceptive_jam,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter,
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        return algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()
+    Service.data({"jamming_policy": "噪声调频", "anti_jamming_policy": "频率捷变"})

.history/service/service_20250421150715.py

@@ -0,0 +1,152 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+from algo.anti_jamming_signal_algo import AntiJammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", "自适应极化滤波"
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = args.get('jamming_policy')
+        anti_jamming_policy = args.get('anti_jamming_policy')
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_algorithm_mapping(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 生成实际干扰信号和抗干扰处理
+        surveillance_signal = surveillance_radar.execute_jamming(
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            duration=0.1,
+            sample_rate=1e6
+        ) if jam_algorithm else np.random.randn(100)
+        
+        processed_signal = jammer_radar.execute_countermeasures(
+            rx_signal=surveillance_signal,
+            algorithm=anti_jam_algorithm,
+            sample_rate=1e6
+        ) if anti_jam_algorithm else surveillance_signal
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": surveillance_signal.tolist(),
+                                    "anti_jamming_signal": processed_signal.tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 策略与算法映射关系
+        algorithm_map = {
+            "噪声调频": JammingSignalAlgo.generate_noise_jam,
+            "噪声调幅": JammingSignalAlgo.generate_amplitude_noise_jam,
+            "噪声直放": JammingSignalAlgo.generate_noise_jam,
+            "速度多假目标": JammingSignalAlgo.generate_velocity_deceptive_jam,
+            "距离多假目标": JammingSignalAlgo.generate_deceptive_jam,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter,
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        return algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()
+    Service.data({"jamming_policy": "噪声调频", "anti_jamming_policy": "频率捷变"})

.history/service/service_20250421150810.py

@@ -0,0 +1,152 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+from algo.anti_jamming_signal_algo import AntiJammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", "自适应极化滤波"
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload.get('jamming_policy')
+        anti_jamming_policy = payload.get('anti_jamming_policy')
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_algorithm_mapping(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 生成实际干扰信号和抗干扰处理
+        surveillance_signal = surveillance_radar.execute_jamming(
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            duration=0.1,
+            sample_rate=1e6
+        ) if jam_algorithm else np.random.randn(100)
+        
+        processed_signal = jammer_radar.execute_countermeasures(
+            rx_signal=surveillance_signal,
+            algorithm=anti_jam_algorithm,
+            sample_rate=1e6
+        ) if anti_jam_algorithm else surveillance_signal
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": surveillance_signal.tolist(),
+                                    "anti_jamming_signal": processed_signal.tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 策略与算法映射关系
+        algorithm_map = {
+            "噪声调频": JammingSignalAlgo.generate_noise_jam,
+            "噪声调幅": JammingSignalAlgo.generate_amplitude_noise_jam,
+            "噪声直放": JammingSignalAlgo.generate_noise_jam,
+            "速度多假目标": JammingSignalAlgo.generate_velocity_deceptive_jam,
+            "距离多假目标": JammingSignalAlgo.generate_deceptive_jam,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter,
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        return algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()
+    Service.data({"jamming_policy": "噪声调频", "anti_jamming_policy": "频率捷变"})

.history/service/service_20250421150811.py

@@ -0,0 +1,152 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+from algo.anti_jamming_signal_algo import AntiJammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", "自适应极化滤波"
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload.get('jamming_policy')
+        anti_jamming_policy = payload.get('anti_jamming_policy')
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_algorithm_mapping(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 生成实际干扰信号和抗干扰处理
+        surveillance_signal = surveillance_radar.execute_jamming(
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            duration=0.1,
+            sample_rate=1e6
+        ) if jam_algorithm else np.random.randn(100)
+        
+        processed_signal = jammer_radar.execute_countermeasures(
+            rx_signal=surveillance_signal,
+            algorithm=anti_jam_algorithm,
+            sample_rate=1e6
+        ) if anti_jam_algorithm else surveillance_signal
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": surveillance_signal.tolist(),
+                                    "anti_jamming_signal": processed_signal.tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 策略与算法映射关系
+        algorithm_map = {
+            "噪声调频": JammingSignalAlgo.generate_noise_jam,
+            "噪声调幅": JammingSignalAlgo.generate_amplitude_noise_jam,
+            "噪声直放": JammingSignalAlgo.generate_noise_jam,
+            "速度多假目标": JammingSignalAlgo.generate_velocity_deceptive_jam,
+            "距离多假目标": JammingSignalAlgo.generate_deceptive_jam,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter,
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        return algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()
+    Service.data({"jamming_policy": "噪声调频", "anti_jamming_policy": "频率捷变"})

.history/service/service_20250421152112.py

@@ -0,0 +1,157 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+from algo.anti_jamming_signal_algo import AntiJammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", "自适应极化滤波"
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload.get('jamming_policy')
+        anti_jamming_policy = payload.get('anti_jamming_policy')
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_algorithm_mapping(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 生成实际干扰信号和抗干扰处理
+        surveillance_signal = surveillance_radar.execute_jamming(
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            duration=0.1,
+            sample_rate=1e6
+        ) if jam_algorithm else np.random.randn(100)
+        
+        processed_signal = jammer_radar.execute_countermeasures(
+            rx_signal=surveillance_signal,
+            algorithm=anti_jam_algorithm,
+            sample_rate=1e6
+        ) if anti_jam_algorithm else surveillance_signal
+        
+        # 类型检查并转换复数信号为实数
+        if np.iscomplexobj(processed_signal):
+            processed_signal = np.real(processed_signal)
+        
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": surveillance_signal.tolist(),
+                                    "anti_jamming_signal": processed_signal.tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 策略与算法映射关系
+        algorithm_map = {
+            "噪声调频": JammingSignalAlgo.generate_noise_jam,
+            "噪声调幅": JammingSignalAlgo.generate_amplitude_noise_jam,
+            "噪声直放": JammingSignalAlgo.generate_noise_jam,
+            "速度多假目标": JammingSignalAlgo.generate_velocity_deceptive_jam,
+            "距离多假目标": JammingSignalAlgo.generate_deceptive_jam,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter,
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        return algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()
+    Service.data({"jamming_policy": "噪声调频", "anti_jamming_policy": "频率捷变"})

.history/service/service_20250421152700.py

@@ -0,0 +1,157 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+from algo.anti_jamming_signal_algo import AntiJammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", "自适应极化滤波"
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload.get('jamming_policy')
+        anti_jamming_policy = payload.get('anti_jamming_policy')
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_algorithm_mapping(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 生成实际干扰信号和抗干扰处理
+        surveillance_signal = surveillance_radar.execute_jamming(
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            duration=0.1,
+            sample_rate=1e6
+        ) if jam_algorithm else np.random.randn(100)
+        
+        processed_signal = jammer_radar.execute_countermeasures(
+            rx_signal=surveillance_signal,
+            algorithm=anti_jam_algorithm,
+            sample_rate=1e6
+        ) if anti_jam_algorithm else surveillance_signal
+        
+        # 类型检查并转换复数信号为实数
+        if np.iscomplexobj(processed_signal):
+            processed_signal = np.real(processed_signal)
+        
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": surveillance_signal.tolist(),
+                                    "anti_jamming_signal": np.real(processed_signal).tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 策略与算法映射关系
+        algorithm_map = {
+            "噪声调频": JammingSignalAlgo.generate_noise_jam,
+            "噪声调幅": JammingSignalAlgo.generate_amplitude_noise_jam,
+            "噪声直放": JammingSignalAlgo.generate_noise_jam,
+            "速度多假目标": JammingSignalAlgo.generate_velocity_deceptive_jam,
+            "距离多假目标": JammingSignalAlgo.generate_deceptive_jam,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter,
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        return algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()
+    Service.data({"jamming_policy": "噪声调频", "anti_jamming_policy": "频率捷变"})

.history/service/service_20250421153017.py

@@ -0,0 +1,157 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+from algo.anti_jamming_signal_algo import AntiJammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", "自适应极化滤波"
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload.get('jamming_policy')
+        anti_jamming_policy = payload.get('anti_jamming_policy')
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_algorithm_mapping(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 生成实际干扰信号和抗干扰处理
+        surveillance_signal = surveillance_radar.execute_jamming(
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            duration=0.1,
+            sample_rate=1e6
+        ) if jam_algorithm else np.random.randn(100)
+        
+        processed_signal = jammer_radar.execute_countermeasures(
+            rx_signal=surveillance_signal,
+            algorithm=anti_jam_algorithm,
+            sample_rate=1e6
+        ) if anti_jam_algorithm else surveillance_signal
+        
+        # 类型检查并转换复数信号为实数
+        if np.iscomplexobj(processed_signal):
+            processed_signal = np.real(processed_signal)
+        
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": np.real(surveillance_signal).tolist(),
+                                    "anti_jamming_signal": np.real(processed_signal).tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 策略与算法映射关系
+        algorithm_map = {
+            "噪声调频": JammingSignalAlgo.generate_noise_jam,
+            "噪声调幅": JammingSignalAlgo.generate_amplitude_noise_jam,
+            "噪声直放": JammingSignalAlgo.generate_noise_jam,
+            "速度多假目标": JammingSignalAlgo.generate_velocity_deceptive_jam,
+            "距离多假目标": JammingSignalAlgo.generate_deceptive_jam,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter,
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        return algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()
+    Service.data({"jamming_policy": "噪声调频", "anti_jamming_policy": "频率捷变"})

.history/service/service_20250421153506.py

@@ -0,0 +1,157 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+from algo.anti_jamming_signal_algo import AntiJammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", "自适应极化滤波"
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload.get('jamming_policy')
+        anti_jamming_policy = payload.get('anti_jamming_policy')
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_algorithm_mapping(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 生成实际干扰信号和抗干扰处理
+        surveillance_signal = surveillance_radar.execute_jamming(
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            duration=0.1,
+            sample_rate=1e6
+        ) if jam_algorithm else np.random.randn(100)
+        
+        processed_signal = jammer_radar.execute_countermeasures(
+            rx_signal=surveillance_signal,
+            algorithm=anti_jam_algorithm,
+            sample_rate=1e6
+        ) if anti_jam_algorithm else surveillance_signal
+        
+        # 类型检查并转换复数信号为实数
+        if np.iscomplexobj(processed_signal):
+            processed_signal = np.real(processed_signal)
+        
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": np.real(surveillance_signal).tolist(),
+                                    "anti_jamming_signal": np.real(processed_signal).tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 策略与算法映射关系
+        algorithm_map = {
+            "噪声调频": JammingSignalAlgo.generate_noise_jam,
+            "噪声调幅": JammingSignalAlgo.generate_amplitude_noise_jam,
+            "噪声直放": JammingSignalAlgo.generate_noise_jam,
+            "速度多假目标": JammingSignalAlgo.generate_velocity_deceptive_jam,
+            "距离多假目标": JammingSignalAlgo.generate_deceptive_jam,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter,
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        return algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()
+    Service.data({"jamming_policy": "噪声调频", "anti_jamming_policy": "频率捷变"})

.history/service/service_20250421154408.py

@@ -0,0 +1,157 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+from algo.anti_jamming_signal_algo import AntiJammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", "自适应极化滤波"
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload.get('jamming_policy')
+        anti_jamming_policy = payload.get('anti_jamming_policy')
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_algorithm_mapping(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 生成实际干扰信号和抗干扰处理
+        surveillance_signal = jammer_radar.execute_jamming(
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            duration=0.1,
+            sample_rate=1e6
+        ) if jam_algorithm else np.random.randn(100)
+        
+        processed_signal = surveillance_radar.execute_anti_jamming(
+            rx_signal=surveillance_signal,
+            algorithm=anti_jam_algorithm,
+            sample_rate=1e6
+        ) if anti_jam_algorithm else surveillance_signal
+        
+        # 类型检查并转换复数信号为实数
+        if np.iscomplexobj(processed_signal):
+            processed_signal = np.real(processed_signal)
+        
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": np.real(surveillance_signal).tolist(),
+                                    "anti_jamming_signal": np.real(processed_signal).tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 策略与算法映射关系
+        algorithm_map = {
+            "噪声调频": JammingSignalAlgo.generate_noise_jam,
+            "噪声调幅": JammingSignalAlgo.generate_amplitude_noise_jam,
+            "噪声直放": JammingSignalAlgo.generate_noise_jam,
+            "速度多假目标": JammingSignalAlgo.generate_velocity_deceptive_jam,
+            "距离多假目标": JammingSignalAlgo.generate_deceptive_jam,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter,
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        return algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()
+    Service.data({"jamming_policy": "噪声调频", "anti_jamming_policy": "频率捷变"})

.history/service/service_20250421154409.py

@@ -0,0 +1,157 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+from algo.anti_jamming_signal_algo import AntiJammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", "自适应极化滤波"
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload.get('jamming_policy')
+        anti_jamming_policy = payload.get('anti_jamming_policy')
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_algorithm_mapping(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 生成实际干扰信号和抗干扰处理
+        surveillance_signal = jammer_radar.execute_jamming(
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            duration=0.1,
+            sample_rate=1e6
+        ) if jam_algorithm else np.random.randn(100)
+        
+        processed_signal = surveillance_radar.execute_anti_jamming(
+            rx_signal=surveillance_signal,
+            algorithm=anti_jam_algorithm,
+            sample_rate=1e6
+        ) if anti_jam_algorithm else surveillance_signal
+        
+        # 类型检查并转换复数信号为实数
+        if np.iscomplexobj(processed_signal):
+            processed_signal = np.real(processed_signal)
+        
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": np.real(surveillance_signal).tolist(),
+                                    "anti_jamming_signal": np.real(processed_signal).tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 策略与算法映射关系
+        algorithm_map = {
+            "噪声调频": JammingSignalAlgo.generate_noise_jam,
+            "噪声调幅": JammingSignalAlgo.generate_amplitude_noise_jam,
+            "噪声直放": JammingSignalAlgo.generate_noise_jam,
+            "速度多假目标": JammingSignalAlgo.generate_velocity_deceptive_jam,
+            "距离多假目标": JammingSignalAlgo.generate_deceptive_jam,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter,
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        return algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()
+    Service.data({"jamming_policy": "噪声调频", "anti_jamming_policy": "频率捷变"})

.history/service/service_20250421161401.py

@@ -0,0 +1,177 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+from algo.anti_jamming_signal_algo import AntiJammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", "自适应极化滤波"
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload.get('jamming_policy')
+        anti_jamming_policy = payload.get('anti_jamming_policy')
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_algorithm_mapping(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 1. 侦查雷达发送原始信号
+        tx_signal = surveillance_radar.send_signal(
+            tx_signal=np.random.randn(100),
+            duration=0.1,
+            center_freq=100e6,
+            sample_rate=1e6,
+            gain=20
+        )
+        
+        # 2. 干扰雷达接收信号并生成干扰
+        jammed_signal = jammer_radar.execute_jamming(
+            rx_signal=tx_signal,
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            sample_rate=1e6
+        ) if jam_algorithm else tx_signal
+        
+        # 3. 分阶段应用抗干扰算法
+        # 发射端抗干扰（波形捷变等）
+        tx_processed = surveillance_radar.execute_anti_jamming(
+            rx_signal=tx_signal,
+            algorithm=Service._get_tx_algorithm(anti_jamming_policy),
+            sample_rate=1e6
+        )
+        
+        # 接收端抗干扰（频率捷变等）
+        processed_signal = surveillance_radar.execute_anti_jamming(
+            rx_signal=jammed_signal,
+            algorithm=anti_jam_algorithm,
+            sample_rate=1e6
+        ) if anti_jam_algorithm else jammed_signal
+        
+        # 类型检查并转换复数信号为实数
+        if np.iscomplexobj(processed_signal):
+            processed_signal = np.real(processed_signal)
+        
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": np.real(surveillance_signal).tolist(),
+                                    "anti_jamming_signal": np.real(processed_signal).tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 接收端抗干扰算法映射
+        rx_algorithm_map = {
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter,
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        return rx_algorithm_map.get(policy)
+
+    @staticmethod
+    def _get_tx_algorithm(policy: str) -> callable:
+        # 发射端抗干扰算法映射
+        tx_algorithm_map = {
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter
+        }
+        return tx_algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()
+    Service.data({"jamming_policy": "噪声调频", "anti_jamming_policy": "频率捷变"})

.history/service/service_20250421161402.py

@@ -0,0 +1,177 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+from algo.anti_jamming_signal_algo import AntiJammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", "自适应极化滤波"
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload.get('jamming_policy')
+        anti_jamming_policy = payload.get('anti_jamming_policy')
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_algorithm_mapping(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 1. 侦查雷达发送原始信号
+        tx_signal = surveillance_radar.send_signal(
+            tx_signal=np.random.randn(100),
+            duration=0.1,
+            center_freq=100e6,
+            sample_rate=1e6,
+            gain=20
+        )
+        
+        # 2. 干扰雷达接收信号并生成干扰
+        jammed_signal = jammer_radar.execute_jamming(
+            rx_signal=tx_signal,
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            sample_rate=1e6
+        ) if jam_algorithm else tx_signal
+        
+        # 3. 分阶段应用抗干扰算法
+        # 发射端抗干扰（波形捷变等）
+        tx_processed = surveillance_radar.execute_anti_jamming(
+            rx_signal=tx_signal,
+            algorithm=Service._get_tx_algorithm(anti_jamming_policy),
+            sample_rate=1e6
+        )
+        
+        # 接收端抗干扰（频率捷变等）
+        processed_signal = surveillance_radar.execute_anti_jamming(
+            rx_signal=jammed_signal,
+            algorithm=anti_jam_algorithm,
+            sample_rate=1e6
+        ) if anti_jam_algorithm else jammed_signal
+        
+        # 类型检查并转换复数信号为实数
+        if np.iscomplexobj(processed_signal):
+            processed_signal = np.real(processed_signal)
+        
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": np.real(surveillance_signal).tolist(),
+                                    "anti_jamming_signal": np.real(processed_signal).tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 接收端抗干扰算法映射
+        rx_algorithm_map = {
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter,
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        return rx_algorithm_map.get(policy)
+
+    @staticmethod
+    def _get_tx_algorithm(policy: str) -> callable:
+        # 发射端抗干扰算法映射
+        tx_algorithm_map = {
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter
+        }
+        return tx_algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()
+    Service.data({"jamming_policy": "噪声调频", "anti_jamming_policy": "频率捷变"})

.history/service/service_20250421161905.py

@@ -0,0 +1,178 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+from algo.anti_jamming_signal_algo import AntiJammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变",
+     "自适应极化滤波"
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload.get('jamming_policy')
+        anti_jamming_policy = payload.get('anti_jamming_policy')
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_algorithm_mapping(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 1. 侦查雷达发送原始信号
+        tx_signal = surveillance_radar.send_signal(
+            tx_signal=np.random.randn(100),
+            duration=0.1,
+            center_freq=100e6,
+            sample_rate=1e6,
+            gain=20
+        )
+        
+        # 2. 干扰雷达接收信号并生成干扰
+        jammed_signal = jammer_radar.execute_jamming(
+            rx_signal=tx_signal,
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            sample_rate=1e6
+        ) if jam_algorithm else tx_signal
+        
+        # 3. 分阶段应用抗干扰算法
+        # 发射端抗干扰（波形捷变等）
+        tx_processed = surveillance_radar.execute_anti_jamming(
+            rx_signal=tx_signal,
+            algorithm=Service._get_tx_algorithm(anti_jamming_policy),
+            sample_rate=1e6
+        )
+        
+        # 接收端抗干扰（频率捷变等）
+        processed_signal = surveillance_radar.execute_anti_jamming(
+            rx_signal=jammed_signal,
+            algorithm=anti_jam_algorithm,
+            sample_rate=1e6
+        ) if anti_jam_algorithm else jammed_signal
+        
+        # 类型检查并转换复数信号为实数
+        if np.iscomplexobj(processed_signal):
+            processed_signal = np.real(processed_signal)
+        
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": np.real(surveillance_signal).tolist(),
+                                    "anti_jamming_signal": np.real(processed_signal).tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 接收端抗干扰算法映射
+        rx_algorithm_map = {
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        return rx_algorithm_map.get(policy)
+
+    @staticmethod
+    def _get_tx_algorithm(policy: str) -> callable:
+        # 发射端抗干扰算法映射
+        tx_algorithm_map = {
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter
+        }
+        return tx_algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()
+    Service.data({"jamming_policy": "噪声调频", "anti_jamming_policy": "频率捷变"})

.history/service/service_20250421162257.py

@@ -0,0 +1,177 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+from algo.anti_jamming_signal_algo import AntiJammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变",
+     "自适应极化滤波"
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload.get('jamming_policy')
+        anti_jamming_policy = payload.get('anti_jamming_policy')
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_algorithm_mapping(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 1. 应用发射端抗干扰算法（波形/频率捷变）
+        tx_processed = surveillance_radar.process_transmit_signal(
+            tx_signal=np.random.randn(100),
+            algorithm=Service._get_tx_algorithm(anti_jamming_policy),
+            sample_rate=1e6
+        )
+        
+        # 2. 发送经过处理的发射信号
+        tx_signal = surveillance_radar.send_signal(
+            tx_signal=tx_processed,
+            duration=0.1,
+            center_freq=100e6,
+            sample_rate=1e6,
+            gain=20
+        )
+        
+        # 3. 干扰雷达接收信号并生成干扰
+        jammed_signal = jammer_radar.execute_jamming(
+            rx_signal=tx_signal,
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            sample_rate=1e6
+        ) if jam_algorithm else tx_signal
+        
+        # 接收端抗干扰（频率捷变等）
+        processed_signal = surveillance_radar.execute_anti_jamming(
+            rx_signal=jammed_signal,
+            algorithm=anti_jam_algorithm,
+            sample_rate=1e6
+        ) if anti_jam_algorithm else jammed_signal
+        
+        # 类型检查并转换复数信号为实数
+        if np.iscomplexobj(processed_signal):
+            processed_signal = np.real(processed_signal)
+        
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": np.real(jammed_signal).tolist(),
+                                    "anti_jamming_signal": np.real(processed_signal).tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 接收端抗干扰算法映射
+        rx_algorithm_map = {
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        return rx_algorithm_map.get(policy)
+
+    @staticmethod
+    def _get_tx_algorithm(policy: str) -> callable:
+        # 发射端抗干扰算法映射
+        tx_algorithm_map = {
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter
+        }
+        return tx_algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()
+    Service.data({"jamming_policy": "噪声调频", "anti_jamming_policy": "频率捷变"})

.history/service/service_20250421162258.py

@@ -0,0 +1,177 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+from algo.anti_jamming_signal_algo import AntiJammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变",
+     "自适应极化滤波"
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload.get('jamming_policy')
+        anti_jamming_policy = payload.get('anti_jamming_policy')
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_algorithm_mapping(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 1. 应用发射端抗干扰算法（波形/频率捷变）
+        tx_processed = surveillance_radar.process_transmit_signal(
+            tx_signal=np.random.randn(100),
+            algorithm=Service._get_tx_algorithm(anti_jamming_policy),
+            sample_rate=1e6
+        )
+        
+        # 2. 发送经过处理的发射信号
+        tx_signal = surveillance_radar.send_signal(
+            tx_signal=tx_processed,
+            duration=0.1,
+            center_freq=100e6,
+            sample_rate=1e6,
+            gain=20
+        )
+        
+        # 3. 干扰雷达接收信号并生成干扰
+        jammed_signal = jammer_radar.execute_jamming(
+            rx_signal=tx_signal,
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            sample_rate=1e6
+        ) if jam_algorithm else tx_signal
+        
+        # 接收端抗干扰（频率捷变等）
+        processed_signal = surveillance_radar.execute_anti_jamming(
+            rx_signal=jammed_signal,
+            algorithm=anti_jam_algorithm,
+            sample_rate=1e6
+        ) if anti_jam_algorithm else jammed_signal
+        
+        # 类型检查并转换复数信号为实数
+        if np.iscomplexobj(processed_signal):
+            processed_signal = np.real(processed_signal)
+        
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": np.real(jammed_signal).tolist(),
+                                    "anti_jamming_signal": np.real(processed_signal).tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 接收端抗干扰算法映射
+        rx_algorithm_map = {
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        return rx_algorithm_map.get(policy)
+
+    @staticmethod
+    def _get_tx_algorithm(policy: str) -> callable:
+        # 发射端抗干扰算法映射
+        tx_algorithm_map = {
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter
+        }
+        return tx_algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()
+    Service.data({"jamming_policy": "噪声调频", "anti_jamming_policy": "频率捷变"})

.history/service/service_20250421163012.py

@@ -0,0 +1,179 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+from algo.anti_jamming_signal_algo import AntiJammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", # 作用于发射端
+     "自适应极化滤波" # 作用于接收端
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload.get('jamming_policy')
+        anti_jamming_policy = payload.get('anti_jamming_policy')
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_algorithm_mapping(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 1. 应用发射端抗干扰算法（波形/频率捷变）
+        tx_processed = surveillance_radar.process_transmit_signal(
+            tx_signal=np.random.randn(100),
+            algorithm=Service._get_tx_algorithm(anti_jamming_policy),
+            sample_rate=1e6
+        )
+        
+        # 2. 发送经过处理的发射信号
+        tx_signal = surveillance_radar.send_signal(
+            tx_signal=tx_processed,
+            duration=0.1,
+            center_freq=100e6,
+            sample_rate=1e6,
+            gain=20
+        )
+        
+        # 3. 干扰雷达接收信号并生成干扰
+        jammed_signal = jammer_radar.execute_jamming(
+            rx_signal=tx_signal,
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            sample_rate=1e6
+        ) if jam_algorithm else tx_signal
+        
+        # 接收端抗干扰（频率捷变等）
+        processed_signal = surveillance_radar.execute_anti_jamming(
+            rx_signal=jammed_signal,
+            algorithm=anti_jam_algorithm,
+            sample_rate=1e6
+        ) if anti_jam_algorithm else jammed_signal
+        
+        # 类型检查并转换复数信号为实数
+        if np.iscomplexobj(processed_signal):
+            processed_signal = np.real(processed_signal)
+        
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": np.real(jammed_signal).tolist(),
+                                    "anti_jamming_signal": np.real(processed_signal).tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 接收端抗干扰算法映射（自动处理非发射端策略）
+        rx_algorithm_map = {
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        # 排除已在发射端处理的策略
+        tx_policies = {"波形捷变", "频率捷变"}
+        return None if policy in tx_policies else rx_algorithm_map.get(policy)
+
+    @staticmethod
+    def _get_tx_algorithm(policy: str) -> callable:
+        # 发射端抗干扰算法映射
+        tx_algorithm_map = {
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter
+        }
+        return tx_algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()
+    Service.data({"jamming_policy": "噪声调频", "anti_jamming_policy": "频率捷变"})

.history/service/service_20250421163835.py

@@ -0,0 +1,183 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+from algo.anti_jamming_signal_algo import AntiJammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", # 作用于发射端
+     "自适应极化滤波" # 作用于接收端
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload.get('jamming_policy')
+        anti_jamming_policy = payload.get('anti_jamming_policy')
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_algorithm_mapping(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 1. 应用发射端抗干扰算法（波形/频率捷变）
+        tx_original = np.random.randn(100)
+        if anti_jamming_policy in {"波形捷变", "频率捷变"}:
+            tx_processed = surveillance_radar.process_transmit_signal(
+                tx_signal=tx_original,
+                algorithm=Service._get_tx_algorithm(anti_jamming_policy),
+                sample_rate=1e6
+            )
+        else:
+            tx_processed = tx_original
+        
+        # 2. 发送经过处理的发射信号
+        tx_signal = surveillance_radar.send_signal(
+            tx_signal=tx_processed,
+            duration=0.1,
+            center_freq=100e6,
+            sample_rate=1e6,
+            gain=20
+        )
+        
+        # 3. 干扰雷达接收信号并生成干扰
+        jammed_signal = jammer_radar.execute_jamming(
+            rx_signal=tx_signal,
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            sample_rate=1e6
+        ) if jam_algorithm else tx_signal
+        
+        # 接收端抗干扰（频率捷变等）
+        processed_signal = surveillance_radar.execute_anti_jamming(
+            rx_signal=jammed_signal,
+            algorithm=anti_jam_algorithm,
+            sample_rate=1e6
+        ) if anti_jam_algorithm else jammed_signal
+        
+        # 类型检查并转换复数信号为实数
+        if np.iscomplexobj(processed_signal):
+            processed_signal = np.real(processed_signal)
+        
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": np.real(jammed_signal).tolist(),
+                                    "anti_jamming_signal": np.real(processed_signal).tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 接收端抗干扰算法映射（自动处理非发射端策略）
+        rx_algorithm_map = {
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        # 排除已在发射端处理的策略
+        tx_policies = {"波形捷变", "频率捷变"}
+        return None if policy in tx_policies else rx_algorithm_map.get(policy)
+
+    @staticmethod
+    def _get_tx_algorithm(policy: str) -> callable:
+        # 发射端抗干扰算法映射
+        tx_algorithm_map = {
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter
+        }
+        return tx_algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()
+    Service.data({"jamming_policy": "噪声调频", "anti_jamming_policy": "频率捷变"})

.history/service/service_20250421163836.py

@@ -0,0 +1,183 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+from algo.anti_jamming_signal_algo import AntiJammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", # 作用于发射端
+     "自适应极化滤波" # 作用于接收端
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload.get('jamming_policy')
+        anti_jamming_policy = payload.get('anti_jamming_policy')
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_algorithm_mapping(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 1. 应用发射端抗干扰算法（波形/频率捷变）
+        tx_original = np.random.randn(100)
+        if anti_jamming_policy in {"波形捷变", "频率捷变"}:
+            tx_processed = surveillance_radar.process_transmit_signal(
+                tx_signal=tx_original,
+                algorithm=Service._get_tx_algorithm(anti_jamming_policy),
+                sample_rate=1e6
+            )
+        else:
+            tx_processed = tx_original
+        
+        # 2. 发送经过处理的发射信号
+        tx_signal = surveillance_radar.send_signal(
+            tx_signal=tx_processed,
+            duration=0.1,
+            center_freq=100e6,
+            sample_rate=1e6,
+            gain=20
+        )
+        
+        # 3. 干扰雷达接收信号并生成干扰
+        jammed_signal = jammer_radar.execute_jamming(
+            rx_signal=tx_signal,
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            sample_rate=1e6
+        ) if jam_algorithm else tx_signal
+        
+        # 接收端抗干扰（频率捷变等）
+        processed_signal = surveillance_radar.execute_anti_jamming(
+            rx_signal=jammed_signal,
+            algorithm=anti_jam_algorithm,
+            sample_rate=1e6
+        ) if anti_jam_algorithm else jammed_signal
+        
+        # 类型检查并转换复数信号为实数
+        if np.iscomplexobj(processed_signal):
+            processed_signal = np.real(processed_signal)
+        
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": np.real(jammed_signal).tolist(),
+                                    "anti_jamming_signal": np.real(processed_signal).tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 接收端抗干扰算法映射（自动处理非发射端策略）
+        rx_algorithm_map = {
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        # 排除已在发射端处理的策略
+        tx_policies = {"波形捷变", "频率捷变"}
+        return None if policy in tx_policies else rx_algorithm_map.get(policy)
+
+    @staticmethod
+    def _get_tx_algorithm(policy: str) -> callable:
+        # 发射端抗干扰算法映射
+        tx_algorithm_map = {
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter
+        }
+        return tx_algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()
+    Service.data({"jamming_policy": "噪声调频", "anti_jamming_policy": "频率捷变"})

.history/service/service_20250421164037.py

@@ -0,0 +1,184 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+from algo.anti_jamming_signal_algo import AntiJammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", # 作用于发射端
+     "自适应极化滤波" # 作用于接收端
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload.get('jamming_policy')
+        anti_jamming_policy = payload.get('anti_jamming_policy')
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_algorithm_mapping(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 1. 应用发射端抗干扰算法（波形/频率捷变）
+        tx_original = np.random.randn(100)
+        if anti_jamming_policy in {"波形捷变", "频率捷变"}:
+            tx_processed = surveillance_radar.process_transmit_signal(
+                tx_signal=tx_original,
+                algorithm=Service._get_tx_algorithm(anti_jamming_policy),
+                sample_rate=1e6
+            )
+        else:
+            tx_processed = tx_original
+        
+        # 2. 发送经过处理的发射信号
+        tx_signal = surveillance_radar.send_signal(
+            tx_signal=tx_processed,
+            duration=0.1,
+            center_freq=100e6,
+            sample_rate=1e6,
+            gain=20
+        )
+        
+        # 3. 干扰雷达接收信号并生成干扰
+        jammed_signal = jammer_radar.execute_jamming(
+            rx_signal=tx_signal,
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            sample_rate=1e6
+        ) if jam_algorithm else tx_signal
+        
+        # 接收端抗干扰（频率捷变等）
+        processed_signal = surveillance_radar.execute_anti_jamming(
+            rx_signal=jammed_signal,
+            algorithm=anti_jam_algorithm,
+            sample_rate=1e6,
+            polarization_params={'angle': 45, 'ellipticity': 0.5}
+        ) if anti_jam_algorithm else jammed_signal
+        
+        # 类型检查并转换复数信号为实数
+        if np.iscomplexobj(processed_signal):
+            processed_signal = np.real(processed_signal)
+        
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": np.real(jammed_signal).tolist(),
+                                    "anti_jamming_signal": np.real(processed_signal).tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 接收端抗干扰算法映射（自动处理非发射端策略）
+        rx_algorithm_map = {
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        # 排除已在发射端处理的策略
+        tx_policies = {"波形捷变", "频率捷变"}
+        return None if policy in tx_policies else rx_algorithm_map.get(policy)
+
+    @staticmethod
+    def _get_tx_algorithm(policy: str) -> callable:
+        # 发射端抗干扰算法映射
+        tx_algorithm_map = {
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter
+        }
+        return tx_algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()
+    Service.data({"jamming_policy": "噪声调频", "anti_jamming_policy": "频率捷变"})

.history/service/service_20250421164419.py

@@ -0,0 +1,186 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+from algo.anti_jamming_signal_algo import AntiJammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", # 作用于发射端
+     "自适应极化滤波" # 作用于接收端
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload.get('jamming_policy')
+        anti_jamming_policy = payload.get('anti_jamming_policy')
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_algorithm_mapping(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 1. 应用发射端抗干扰算法（波形/频率捷变）
+        tx_original = np.random.randn(100)
+        if anti_jamming_policy in {"波形捷变", "频率捷变"}:
+            tx_processed = surveillance_radar.process_transmit_signal(
+                tx_signal=tx_original,
+                algorithm=Service._get_tx_algorithm(anti_jamming_policy),
+                sample_rate=1e6
+            )
+        else:
+            tx_processed = tx_original
+        
+        # 2. 发送经过处理的发射信号
+        tx_signal = surveillance_radar.send_signal(
+            tx_signal=tx_processed,
+            duration=0.1,
+            center_freq=100e6,
+            sample_rate=1e6,
+            gain=20
+        )
+        
+        # 3. 干扰雷达接收信号并生成干扰
+        jammed_signal = jammer_radar.execute_jamming(
+            rx_signal=tx_signal,
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            sample_rate=1e6
+        ) if jam_algorithm else tx_signal
+        
+        # 接收端抗干扰处理（仅限接收端策略）
+        processed_signal = jammed_signal
+        if anti_jam_algorithm:
+            processed_signal = surveillance_radar.execute_anti_jamming(
+                rx_signal=jammed_signal,
+                algorithm=anti_jam_algorithm,
+                sample_rate=1e6,
+                polarization_params={'angle': 45, 'ellipticity': 0.5}
+            )
+        
+        # 类型检查并转换复数信号为实数
+        if np.iscomplexobj(processed_signal):
+            processed_signal = np.real(processed_signal)
+        
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": np.real(jammed_signal).tolist(),
+                                    "anti_jamming_signal": np.real(processed_signal).tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 接收端抗干扰算法映射（自动处理非发射端策略）
+        rx_algorithm_map = {
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        # 排除已在发射端处理的策略
+        tx_policies = {"波形捷变", "频率捷变"}
+        return None if policy in tx_policies else rx_algorithm_map.get(policy)
+
+    @staticmethod
+    def _get_tx_algorithm(policy: str) -> callable:
+        # 发射端抗干扰算法映射
+        tx_algorithm_map = {
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter
+        }
+        return tx_algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()
+    Service.data({"jamming_policy": "噪声调频", "anti_jamming_policy": "频率捷变"})

.history/service/service_20250421164420.py

@@ -0,0 +1,186 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+from algo.anti_jamming_signal_algo import AntiJammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", # 作用于发射端
+     "自适应极化滤波" # 作用于接收端
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload.get('jamming_policy')
+        anti_jamming_policy = payload.get('anti_jamming_policy')
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_algorithm_mapping(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 1. 应用发射端抗干扰算法（波形/频率捷变）
+        tx_original = np.random.randn(100)
+        if anti_jamming_policy in {"波形捷变", "频率捷变"}:
+            tx_processed = surveillance_radar.process_transmit_signal(
+                tx_signal=tx_original,
+                algorithm=Service._get_tx_algorithm(anti_jamming_policy),
+                sample_rate=1e6
+            )
+        else:
+            tx_processed = tx_original
+        
+        # 2. 发送经过处理的发射信号
+        tx_signal = surveillance_radar.send_signal(
+            tx_signal=tx_processed,
+            duration=0.1,
+            center_freq=100e6,
+            sample_rate=1e6,
+            gain=20
+        )
+        
+        # 3. 干扰雷达接收信号并生成干扰
+        jammed_signal = jammer_radar.execute_jamming(
+            rx_signal=tx_signal,
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            sample_rate=1e6
+        ) if jam_algorithm else tx_signal
+        
+        # 接收端抗干扰处理（仅限接收端策略）
+        processed_signal = jammed_signal
+        if anti_jam_algorithm:
+            processed_signal = surveillance_radar.execute_anti_jamming(
+                rx_signal=jammed_signal,
+                algorithm=anti_jam_algorithm,
+                sample_rate=1e6,
+                polarization_params={'angle': 45, 'ellipticity': 0.5}
+            )
+        
+        # 类型检查并转换复数信号为实数
+        if np.iscomplexobj(processed_signal):
+            processed_signal = np.real(processed_signal)
+        
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": np.real(jammed_signal).tolist(),
+                                    "anti_jamming_signal": np.real(processed_signal).tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 接收端抗干扰算法映射（自动处理非发射端策略）
+        rx_algorithm_map = {
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        # 排除已在发射端处理的策略
+        tx_policies = {"波形捷变", "频率捷变"}
+        return None if policy in tx_policies else rx_algorithm_map.get(policy)
+
+    @staticmethod
+    def _get_tx_algorithm(policy: str) -> callable:
+        # 发射端抗干扰算法映射
+        tx_algorithm_map = {
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter
+        }
+        return tx_algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()
+    Service.data({"jamming_policy": "噪声调频", "anti_jamming_policy": "频率捷变"})

.history/service/service_20250421165021.py

@@ -0,0 +1,198 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+from algo.anti_jamming_signal_algo import AntiJammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", # 作用于发射端
+     "自适应极化滤波" # 作用于接收端
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload.get('jamming_policy')
+        anti_jamming_policy = payload.get('anti_jamming_policy')
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_jam_algorithm(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping(anti_jamming_policy)
+
+        # 1. 应用发射端抗干扰算法（波形/频率捷变）
+        tx_original = np.random.randn(100)
+        if anti_jamming_policy in {"波形捷变", "频率捷变"}:
+            tx_processed = surveillance_radar.process_transmit_signal(
+                tx_signal=tx_original,
+                algorithm=Service._get_tx_algorithm(anti_jamming_policy),
+                sample_rate=1e6
+            )
+        else:
+            tx_processed = tx_original
+        
+        # 2. 发送经过处理的发射信号
+        tx_signal = surveillance_radar.send_signal(
+            tx_signal=tx_processed,
+            duration=0.1,
+            center_freq=100e6,
+            sample_rate=1e6,
+            gain=20
+        )
+        
+        # 3. 干扰雷达接收信号并生成干扰
+        jammed_signal = jammer_radar.execute_jamming(
+            rx_signal=tx_signal,
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            sample_rate=1e6
+        ) if jam_algorithm else tx_signal
+        
+        # 接收端抗干扰处理（仅限接收端策略）
+        processed_signal = jammed_signal
+        if anti_jam_algorithm:
+            processed_signal = surveillance_radar.execute_anti_jamming(
+                rx_signal=jammed_signal,
+                algorithm=anti_jam_algorithm,
+                sample_rate=1e6,
+                polarization_params={'angle': 45, 'ellipticity': 0.5}
+            )
+        
+        # 类型检查并转换复数信号为实数
+        if np.iscomplexobj(processed_signal):
+            processed_signal = np.real(processed_signal)
+        
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": np.real(jammed_signal).tolist(),
+                                    "anti_jamming_signal": np.real(processed_signal).tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_jam_algorithm(policy: str) -> callable:
+        # 干扰算法映射
+        jam_algorithm_map = {
+            "噪声调频": JammingSignalAlgo.frequency_modulation,
+            "噪声调幅": JammingSignalAlgo.amplitude_modulation,
+            "噪声直放": JammingSignalAlgo.repeater_jamming,
+            "速度多假目标": JammingSignalAlgo.velocity_deception,
+            "距离多假目标": JammingSignalAlgo.range_deception
+        }
+        return jam_algorithm_map.get(policy)
+
+    @staticmethod
+    def _get_algorithm_mapping(policy: str) -> callable:
+        # 接收端抗干扰算法映射（自动处理非发射端策略）
+        rx_algorithm_map = {
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        # 排除已在发射端处理的策略
+        tx_policies = {"波形捷变", "频率捷变"}
+        return None if policy in tx_policies else rx_algorithm_map.get(policy)
+
+    @staticmethod
+    def _get_tx_algorithm(policy: str) -> callable:
+        # 发射端抗干扰算法映射
+        tx_algorithm_map = {
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter
+        }
+        return tx_algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()
+    Service.data({"jamming_policy": "噪声调频", "anti_jamming_policy": "频率捷变"})

.history/service/service_20250421165238.py

@@ -0,0 +1,198 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+from algo.anti_jamming_signal_algo import AntiJammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", # 作用于发射端
+     "自适应极化滤波" # 作用于接收端
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload.get('jamming_policy')
+        anti_jamming_policy = payload.get('anti_jamming_policy')
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_jamming_algorithm_method(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping_method(anti_jamming_policy)
+
+        # 1. 应用发射端抗干扰算法（波形/频率捷变）
+        tx_original = np.random.randn(100)
+        if anti_jamming_policy in {"波形捷变", "频率捷变"}:
+            tx_processed = surveillance_radar.process_transmit_signal(
+                tx_signal=tx_original,
+                algorithm=Service._get_tx_algorithm_method(anti_jamming_policy),
+                sample_rate=1e6
+            )
+        else:
+            tx_processed = tx_original
+        
+        # 2. 发送经过处理的发射信号
+        tx_signal = surveillance_radar.send_signal(
+            tx_signal=tx_processed,
+            duration=0.1,
+            center_freq=100e6,
+            sample_rate=1e6,
+            gain=20
+        )
+        
+        # 3. 干扰雷达接收信号并生成干扰
+        jammed_signal = jammer_radar.execute_jamming(
+            rx_signal=tx_signal,
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            sample_rate=1e6
+        ) if jam_algorithm else tx_signal
+        
+        # 接收端抗干扰处理（仅限接收端策略）
+        processed_signal = jammed_signal
+        if anti_jam_algorithm:
+            processed_signal = surveillance_radar.execute_anti_jamming(
+                rx_signal=jammed_signal,
+                algorithm=anti_jam_algorithm,
+                sample_rate=1e6,
+                polarization_params={'angle': 45, 'ellipticity': 0.5}
+            )
+        
+        # 类型检查并转换复数信号为实数
+        if np.iscomplexobj(processed_signal):
+            processed_signal = np.real(processed_signal)
+        
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": np.real(jammed_signal).tolist(),
+                                    "anti_jamming_signal": np.real(processed_signal).tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_jamming_algorithm_method(policy: str) -> callable:
+        # 干扰算法映射
+        jam_algorithm_map = {
+            "噪声调频": JammingSignalAlgo.frequency_modulation,
+            "噪声调幅": JammingSignalAlgo.amplitude_modulation,
+            "噪声直放": JammingSignalAlgo.repeater_jamming,
+            "速度多假目标": JammingSignalAlgo.velocity_deception,
+            "距离多假目标": JammingSignalAlgo.range_deception
+        }
+        return jam_algorithm_map.get(policy)
+
+    @staticmethod
+    def _get_algorithm_mapping_method(policy: str) -> callable:
+        # 接收端抗干扰算法映射（自动处理非发射端策略）
+        rx_algorithm_map = {
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        # 排除已在发射端处理的策略
+        tx_policies = {"波形捷变", "频率捷变"}
+        return None if policy in tx_policies else rx_algorithm_map.get(policy)
+
+    @staticmethod
+    def _get_tx_algorithm_method(policy: str) -> callable:
+        # 发射端抗干扰算法映射
+        tx_algorithm_map = {
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter
+        }
+        return tx_algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()
+    Service.data({"jamming_policy": "噪声调频", "anti_jamming_policy": "频率捷变"})

.history/service/service_20250421165239.py

@@ -0,0 +1,198 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+from algo.anti_jamming_signal_algo import AntiJammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", # 作用于发射端
+     "自适应极化滤波" # 作用于接收端
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload.get('jamming_policy')
+        anti_jamming_policy = payload.get('anti_jamming_policy')
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_jamming_algorithm_method(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping_method(anti_jamming_policy)
+
+        # 1. 应用发射端抗干扰算法（波形/频率捷变）
+        tx_original = np.random.randn(100)
+        if anti_jamming_policy in {"波形捷变", "频率捷变"}:
+            tx_processed = surveillance_radar.process_transmit_signal(
+                tx_signal=tx_original,
+                algorithm=Service._get_tx_algorithm_method(anti_jamming_policy),
+                sample_rate=1e6
+            )
+        else:
+            tx_processed = tx_original
+        
+        # 2. 发送经过处理的发射信号
+        tx_signal = surveillance_radar.send_signal(
+            tx_signal=tx_processed,
+            duration=0.1,
+            center_freq=100e6,
+            sample_rate=1e6,
+            gain=20
+        )
+        
+        # 3. 干扰雷达接收信号并生成干扰
+        jammed_signal = jammer_radar.execute_jamming(
+            rx_signal=tx_signal,
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            sample_rate=1e6
+        ) if jam_algorithm else tx_signal
+        
+        # 接收端抗干扰处理（仅限接收端策略）
+        processed_signal = jammed_signal
+        if anti_jam_algorithm:
+            processed_signal = surveillance_radar.execute_anti_jamming(
+                rx_signal=jammed_signal,
+                algorithm=anti_jam_algorithm,
+                sample_rate=1e6,
+                polarization_params={'angle': 45, 'ellipticity': 0.5}
+            )
+        
+        # 类型检查并转换复数信号为实数
+        if np.iscomplexobj(processed_signal):
+            processed_signal = np.real(processed_signal)
+        
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": np.real(jammed_signal).tolist(),
+                                    "anti_jamming_signal": np.real(processed_signal).tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_jamming_algorithm_method(policy: str) -> callable:
+        # 干扰算法映射
+        jam_algorithm_map = {
+            "噪声调频": JammingSignalAlgo.frequency_modulation,
+            "噪声调幅": JammingSignalAlgo.amplitude_modulation,
+            "噪声直放": JammingSignalAlgo.repeater_jamming,
+            "速度多假目标": JammingSignalAlgo.velocity_deception,
+            "距离多假目标": JammingSignalAlgo.range_deception
+        }
+        return jam_algorithm_map.get(policy)
+
+    @staticmethod
+    def _get_algorithm_mapping_method(policy: str) -> callable:
+        # 接收端抗干扰算法映射（自动处理非发射端策略）
+        rx_algorithm_map = {
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        # 排除已在发射端处理的策略
+        tx_policies = {"波形捷变", "频率捷变"}
+        return None if policy in tx_policies else rx_algorithm_map.get(policy)
+
+    @staticmethod
+    def _get_tx_algorithm_method(policy: str) -> callable:
+        # 发射端抗干扰算法映射
+        tx_algorithm_map = {
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter
+        }
+        return tx_algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()
+    Service.data({"jamming_policy": "噪声调频", "anti_jamming_policy": "频率捷变"})

.history/service/service_20250421165538.py

@@ -0,0 +1,199 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+from algo.anti_jamming_signal_algo import AntiJammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", # 作用于发射端
+     "自适应极化滤波" # 作用于接收端
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload.get('jamming_policy')
+        anti_jamming_policy = payload.get('anti_jamming_policy')
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_jamming_algorithm_method(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping_method(anti_jamming_policy)
+
+        # 1. 应用发射端抗干扰算法（波形/频率捷变）
+        tx_original = np.random.randn(100)
+        if anti_jamming_policy in {"波形捷变", "频率捷变"}:
+            tx_processed = surveillance_radar.process_transmit_signal(
+                tx_signal=tx_original,
+                algorithm=Service._get_tx_algorithm_method(anti_jamming_policy),
+                sample_rate=1e6
+            )
+        else:
+            tx_processed = tx_original
+        
+        # 2. 发送经过处理的发射信号
+        tx_signal = surveillance_radar.send_signal(
+            tx_signal=tx_processed,
+            duration=0.1,
+            center_freq=100e6,
+            sample_rate=1e6,
+            gain=20
+        )
+        
+        # 3. 干扰雷达接收信号并生成干扰
+        jammed_signal = jammer_radar.execute_jamming(
+            rx_signal=tx_signal,
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            sample_rate=1e6
+        ) if jam_algorithm else tx_signal
+        
+        # 接收端抗干扰处理（仅限接收端策略）
+        processed_signal = jammed_signal
+        if anti_jam_algorithm:
+            processed_signal = surveillance_radar.execute_anti_jamming(
+                rx_signal=jammed_signal,
+                algorithm=anti_jam_algorithm,
+                sample_rate=1e6,
+                polarization_params={'angle': 45, 'ellipticity': 0.5}
+            )
+        
+        # 类型检查并转换复数信号为实数
+        if np.iscomplexobj(processed_signal):
+            processed_signal = np.real(processed_signal)
+        
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": np.real(jammed_signal).tolist(),
+                                    "anti_jamming_signal": np.real(processed_signal).tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_jamming_algorithm_method(policy: str) -> callable:
+        # 干扰算法映射
+        jam_algorithm_map = {
+            "噪声调频": JammingSignalAlgo.frequency_modulation,
+            "噪声调幅": JammingSignalAlgo.amplitude_modulation,
+            "噪声直放": JammingSignalAlgo.repeater_jamming,
+            "速度多假目标": JammingSignalAlgo.velocity_deception,
+            "距离多假目标": JammingSignalAlgo.range_deception
+        }
+        return jam_algorithm_map.get(policy)
+
+    @staticmethod
+    def _get_anti_jamming_algorithm(policy: str, algorithm_type: str) -> callable:
+        """
+        统一抗干扰策略路由方法
+        :param policy: 策略名称
+        :param algorithm_type: 算法类型['tx'发射端/'rx'接收端]
+        """
+        tx_algorithm_map = {
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter
+        }
+        rx_algorithm_map = {
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        
+        if algorithm_type == 'tx':
+            return tx_algorithm_map.get(policy)
+        elif algorithm_type == 'rx':
+            return None if policy in {"波形捷变", "频率捷变"} else rx_algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()
+    Service.data({"jamming_policy": "噪声调频", "anti_jamming_policy": "频率捷变"})

.history/service/service_20250421165539.py

@@ -0,0 +1,199 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+from algo.anti_jamming_signal_algo import AntiJammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", # 作用于发射端
+     "自适应极化滤波" # 作用于接收端
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload.get('jamming_policy')
+        anti_jamming_policy = payload.get('anti_jamming_policy')
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_jamming_algorithm_method(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping_method(anti_jamming_policy)
+
+        # 1. 应用发射端抗干扰算法（波形/频率捷变）
+        tx_original = np.random.randn(100)
+        if anti_jamming_policy in {"波形捷变", "频率捷变"}:
+            tx_processed = surveillance_radar.process_transmit_signal(
+                tx_signal=tx_original,
+                algorithm=Service._get_tx_algorithm_method(anti_jamming_policy),
+                sample_rate=1e6
+            )
+        else:
+            tx_processed = tx_original
+        
+        # 2. 发送经过处理的发射信号
+        tx_signal = surveillance_radar.send_signal(
+            tx_signal=tx_processed,
+            duration=0.1,
+            center_freq=100e6,
+            sample_rate=1e6,
+            gain=20
+        )
+        
+        # 3. 干扰雷达接收信号并生成干扰
+        jammed_signal = jammer_radar.execute_jamming(
+            rx_signal=tx_signal,
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            sample_rate=1e6
+        ) if jam_algorithm else tx_signal
+        
+        # 接收端抗干扰处理（仅限接收端策略）
+        processed_signal = jammed_signal
+        if anti_jam_algorithm:
+            processed_signal = surveillance_radar.execute_anti_jamming(
+                rx_signal=jammed_signal,
+                algorithm=anti_jam_algorithm,
+                sample_rate=1e6,
+                polarization_params={'angle': 45, 'ellipticity': 0.5}
+            )
+        
+        # 类型检查并转换复数信号为实数
+        if np.iscomplexobj(processed_signal):
+            processed_signal = np.real(processed_signal)
+        
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": np.real(jammed_signal).tolist(),
+                                    "anti_jamming_signal": np.real(processed_signal).tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_jamming_algorithm_method(policy: str) -> callable:
+        # 干扰算法映射
+        jam_algorithm_map = {
+            "噪声调频": JammingSignalAlgo.frequency_modulation,
+            "噪声调幅": JammingSignalAlgo.amplitude_modulation,
+            "噪声直放": JammingSignalAlgo.repeater_jamming,
+            "速度多假目标": JammingSignalAlgo.velocity_deception,
+            "距离多假目标": JammingSignalAlgo.range_deception
+        }
+        return jam_algorithm_map.get(policy)
+
+    @staticmethod
+    def _get_anti_jamming_algorithm(policy: str, algorithm_type: str) -> callable:
+        """
+        统一抗干扰策略路由方法
+        :param policy: 策略名称
+        :param algorithm_type: 算法类型['tx'发射端/'rx'接收端]
+        """
+        tx_algorithm_map = {
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter
+        }
+        rx_algorithm_map = {
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        
+        if algorithm_type == 'tx':
+            return tx_algorithm_map.get(policy)
+        elif algorithm_type == 'rx':
+            return None if policy in {"波形捷变", "频率捷变"} else rx_algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()
+    Service.data({"jamming_policy": "噪声调频", "anti_jamming_policy": "频率捷变"})

.history/service/service_20250421165947.py

@@ -0,0 +1,198 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+from algo.anti_jamming_signal_algo import AntiJammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", # 作用于发射端
+     "自适应极化滤波" # 作用于接收端
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload.get('jamming_policy')
+        anti_jamming_policy = payload.get('anti_jamming_policy')
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_jamming_algorithm_method(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping_method(anti_jamming_policy)
+
+        # 1. 应用发射端抗干扰算法（波形/频率捷变）
+        tx_original = np.random.randn(100)
+        if anti_jamming_policy in {"波形捷变", "频率捷变"}:
+            tx_processed = surveillance_radar.process_transmit_signal(
+                tx_signal=tx_original,
+                algorithm=Service._get_tx_algorithm_method(anti_jamming_policy),
+                sample_rate=1e6
+            )
+        else:
+            tx_processed = tx_original
+        
+        # 2. 发送经过处理的发射信号
+        tx_signal = surveillance_radar.send_signal(
+            tx_signal=tx_processed,
+            duration=0.1,
+            center_freq=100e6,
+            sample_rate=1e6,
+            gain=20
+        )
+        
+        # 3. 干扰雷达接收信号并生成干扰
+        jammed_signal = jammer_radar.execute_jamming(
+            rx_signal=tx_signal,
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            sample_rate=1e6
+        ) if jam_algorithm else tx_signal
+        
+        # 接收端抗干扰处理（仅限接收端策略）
+        processed_signal = jammed_signal
+        if anti_jam_algorithm:
+            processed_signal = surveillance_radar.execute_anti_jamming(
+                rx_signal=jammed_signal,
+                algorithm=anti_jam_algorithm,
+                sample_rate=1e6,
+                polarization_params={'angle': 45, 'ellipticity': 0.5}
+            )
+        
+        # 类型检查并转换复数信号为实数
+        if np.iscomplexobj(processed_signal):
+            processed_signal = np.real(processed_signal)
+        
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": np.real(jammed_signal).tolist(),
+                                    "anti_jamming_signal": np.real(processed_signal).tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_jamming_algorithm_method(policy: str) -> callable:
+        # 干扰算法映射
+        jam_algorithm_map = {
+            "噪声调频": JammingSignalAlgo.frequency_modulation,
+            "噪声调幅": JammingSignalAlgo.amplitude_modulation,
+            "噪声直放": JammingSignalAlgo.repeater_jamming,
+            "速度多假目标": JammingSignalAlgo.velocity_deception,
+            "距离多假目标": JammingSignalAlgo.range_deception
+        }
+        return jam_algorithm_map.get(policy)
+
+    @staticmethod
+    def _get_algorithm_mapping_method(policy: str) -> callable:
+        # 接收端抗干扰算法映射（自动处理非发射端策略）
+        rx_algorithm_map = {
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        # 排除已在发射端处理的策略
+        tx_policies = {"波形捷变", "频率捷变"}
+        return None if policy in tx_policies else rx_algorithm_map.get(policy)
+
+    @staticmethod
+    def _get_tx_algorithm_method(policy: str) -> callable:
+        # 发射端抗干扰算法映射
+        tx_algorithm_map = {
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter
+        }
+        return tx_algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()
+    Service.data({"jamming_policy": "噪声调频", "anti_jamming_policy": "频率捷变"})

.history/service/service_20250421165948.py

@@ -0,0 +1,198 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+from algo.anti_jamming_signal_algo import AntiJammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", # 作用于发射端
+     "自适应极化滤波" # 作用于接收端
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload.get('jamming_policy')
+        anti_jamming_policy = payload.get('anti_jamming_policy')
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_jamming_algorithm_method(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping_method(anti_jamming_policy)
+
+        # 1. 应用发射端抗干扰算法（波形/频率捷变）
+        tx_original = np.random.randn(100)
+        if anti_jamming_policy in {"波形捷变", "频率捷变"}:
+            tx_processed = surveillance_radar.process_transmit_signal(
+                tx_signal=tx_original,
+                algorithm=Service._get_tx_algorithm_method(anti_jamming_policy),
+                sample_rate=1e6
+            )
+        else:
+            tx_processed = tx_original
+        
+        # 2. 发送经过处理的发射信号
+        tx_signal = surveillance_radar.send_signal(
+            tx_signal=tx_processed,
+            duration=0.1,
+            center_freq=100e6,
+            sample_rate=1e6,
+            gain=20
+        )
+        
+        # 3. 干扰雷达接收信号并生成干扰
+        jammed_signal = jammer_radar.execute_jamming(
+            rx_signal=tx_signal,
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            sample_rate=1e6
+        ) if jam_algorithm else tx_signal
+        
+        # 接收端抗干扰处理（仅限接收端策略）
+        processed_signal = jammed_signal
+        if anti_jam_algorithm:
+            processed_signal = surveillance_radar.execute_anti_jamming(
+                rx_signal=jammed_signal,
+                algorithm=anti_jam_algorithm,
+                sample_rate=1e6,
+                polarization_params={'angle': 45, 'ellipticity': 0.5}
+            )
+        
+        # 类型检查并转换复数信号为实数
+        if np.iscomplexobj(processed_signal):
+            processed_signal = np.real(processed_signal)
+        
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": np.real(jammed_signal).tolist(),
+                                    "anti_jamming_signal": np.real(processed_signal).tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_jamming_algorithm_method(policy: str) -> callable:
+        # 干扰算法映射
+        jam_algorithm_map = {
+            "噪声调频": JammingSignalAlgo.frequency_modulation,
+            "噪声调幅": JammingSignalAlgo.amplitude_modulation,
+            "噪声直放": JammingSignalAlgo.repeater_jamming,
+            "速度多假目标": JammingSignalAlgo.velocity_deception,
+            "距离多假目标": JammingSignalAlgo.range_deception
+        }
+        return jam_algorithm_map.get(policy)
+
+    @staticmethod
+    def _get_algorithm_mapping_method(policy: str) -> callable:
+        # 接收端抗干扰算法映射（自动处理非发射端策略）
+        rx_algorithm_map = {
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        # 排除已在发射端处理的策略
+        tx_policies = {"波形捷变", "频率捷变"}
+        return None if policy in tx_policies else rx_algorithm_map.get(policy)
+
+    @staticmethod
+    def _get_tx_algorithm_method(policy: str) -> callable:
+        # 发射端抗干扰算法映射
+        tx_algorithm_map = {
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter
+        }
+        return tx_algorithm_map.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()
+    Service.data({"jamming_policy": "噪声调频", "anti_jamming_policy": "频率捷变"})

.history/service/service_20250421170031.py

@@ -0,0 +1,199 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+from algo.anti_jamming_signal_algo import AntiJammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", # 作用于发射端
+     "自适应极化滤波" # 作用于接收端
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload.get('jamming_policy')
+        anti_jamming_policy = payload.get('anti_jamming_policy')
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_jamming_algorithm_method(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping_method(anti_jamming_policy)
+
+        # 1. 应用发射端抗干扰算法（波形/频率捷变）
+        tx_original = np.random.randn(100)
+        if anti_jamming_policy in {"波形捷变", "频率捷变"}:
+            tx_processed = surveillance_radar.process_transmit_signal(
+                tx_signal=tx_original,
+                algorithm=Service._get_tx_algorithm_method(anti_jamming_policy),
+                sample_rate=1e6
+            )
+        else:
+            tx_processed = tx_original
+        
+        # 2. 发送经过处理的发射信号
+        tx_signal = surveillance_radar.send_signal(
+            tx_signal=tx_processed,
+            duration=0.1,
+            center_freq=100e6,
+            sample_rate=1e6,
+            gain=20
+        )
+        
+        # 3. 干扰雷达接收信号并生成干扰
+        jammed_signal = jammer_radar.execute_jamming(
+            rx_signal=tx_signal,
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            sample_rate=1e6
+        ) if jam_algorithm else tx_signal
+        
+        # 接收端抗干扰处理（仅限接收端策略）
+        processed_signal = jammed_signal
+        if anti_jam_algorithm:
+            processed_signal = surveillance_radar.execute_anti_jamming(
+                rx_signal=jammed_signal,
+                algorithm=anti_jam_algorithm,
+                sample_rate=1e6,
+                polarization_params={'angle': 45, 'ellipticity': 0.5}
+            )
+        
+        # 类型检查并转换复数信号为实数
+        if np.iscomplexobj(processed_signal):
+            processed_signal = np.real(processed_signal)
+        
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": np.real(jammed_signal).tolist(),
+                                    "anti_jamming_signal": np.real(processed_signal).tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_jamming_algorithm_method(policy: str) -> callable:
+        # 干扰算法映射
+        jam_algorithm_map = {
+            "噪声调频": JammingSignalAlgo.frequency_modulation,
+            "噪声调幅": JammingSignalAlgo.amplitude_modulation,
+            "噪声直放": JammingSignalAlgo.repeater_jamming,
+            "速度多假目标": JammingSignalAlgo.velocity_deception,
+            "距离多假目标": JammingSignalAlgo.range_deception
+        }
+        return jam_algorithm_map.get(policy)
+
+    @staticmethod
+    def _get_anti_jamming_algorithm(policy: str, algorithm_type: str) -> callable:
+        """
+        统一抗干扰策略路由方法
+        :param policy: 策略名称
+        :param algorithm_type: 算法类型['tx'发射端/'rx'接收端]
+        """
+        tx_algorithms = {
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter
+        }
+        rx_algorithms = {
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        
+        if algorithm_type == 'tx':
+            return tx_algorithms.get(policy)
+        elif algorithm_type == 'rx':
+            return None if policy in {"波形捷变", "频率捷变"} else rx_algorithms.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()
+    Service.data({"jamming_policy": "噪声调频", "anti_jamming_policy": "频率捷变"})

.history/service/service_20250421170032.py

@@ -0,0 +1,199 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+from algo.anti_jamming_signal_algo import AntiJammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", # 作用于发射端
+     "自适应极化滤波" # 作用于接收端
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload.get('jamming_policy')
+        anti_jamming_policy = payload.get('anti_jamming_policy')
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_jamming_algorithm_method(jamming_policy)
+        anti_jam_algorithm = Service._get_algorithm_mapping_method(anti_jamming_policy)
+
+        # 1. 应用发射端抗干扰算法（波形/频率捷变）
+        tx_original = np.random.randn(100)
+        if anti_jamming_policy in {"波形捷变", "频率捷变"}:
+            tx_processed = surveillance_radar.process_transmit_signal(
+                tx_signal=tx_original,
+                algorithm=Service._get_tx_algorithm_method(anti_jamming_policy),
+                sample_rate=1e6
+            )
+        else:
+            tx_processed = tx_original
+        
+        # 2. 发送经过处理的发射信号
+        tx_signal = surveillance_radar.send_signal(
+            tx_signal=tx_processed,
+            duration=0.1,
+            center_freq=100e6,
+            sample_rate=1e6,
+            gain=20
+        )
+        
+        # 3. 干扰雷达接收信号并生成干扰
+        jammed_signal = jammer_radar.execute_jamming(
+            rx_signal=tx_signal,
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            sample_rate=1e6
+        ) if jam_algorithm else tx_signal
+        
+        # 接收端抗干扰处理（仅限接收端策略）
+        processed_signal = jammed_signal
+        if anti_jam_algorithm:
+            processed_signal = surveillance_radar.execute_anti_jamming(
+                rx_signal=jammed_signal,
+                algorithm=anti_jam_algorithm,
+                sample_rate=1e6,
+                polarization_params={'angle': 45, 'ellipticity': 0.5}
+            )
+        
+        # 类型检查并转换复数信号为实数
+        if np.iscomplexobj(processed_signal):
+            processed_signal = np.real(processed_signal)
+        
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": np.real(jammed_signal).tolist(),
+                                    "anti_jamming_signal": np.real(processed_signal).tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_jamming_algorithm_method(policy: str) -> callable:
+        # 干扰算法映射
+        jam_algorithm_map = {
+            "噪声调频": JammingSignalAlgo.frequency_modulation,
+            "噪声调幅": JammingSignalAlgo.amplitude_modulation,
+            "噪声直放": JammingSignalAlgo.repeater_jamming,
+            "速度多假目标": JammingSignalAlgo.velocity_deception,
+            "距离多假目标": JammingSignalAlgo.range_deception
+        }
+        return jam_algorithm_map.get(policy)
+
+    @staticmethod
+    def _get_anti_jamming_algorithm(policy: str, algorithm_type: str) -> callable:
+        """
+        统一抗干扰策略路由方法
+        :param policy: 策略名称
+        :param algorithm_type: 算法类型['tx'发射端/'rx'接收端]
+        """
+        tx_algorithms = {
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter
+        }
+        rx_algorithms = {
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        
+        if algorithm_type == 'tx':
+            return tx_algorithms.get(policy)
+        elif algorithm_type == 'rx':
+            return None if policy in {"波形捷变", "频率捷变"} else rx_algorithms.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()
+    Service.data({"jamming_policy": "噪声调频", "anti_jamming_policy": "频率捷变"})

.history/service/service_20250421170202.py

@@ -0,0 +1,199 @@
+import json
+import uhd
+import numpy as np
+import threading
+
+from dto.response_dto import ResponseDTO
+from model.surveillance_radar import SurveillanceRadar
+from model.jammer_radar import JammerRadar
+from algo.jamming_signal_algo import JammingSignalAlgo
+from algo.anti_jamming_signal_algo import AntiJammingSignalAlgo
+
+# 定义一组通道常量
+CHANNEL_1 = 0
+CHANNEL_2 = 1
+CHANNEL_3 = 2
+CHANNEL_4 = 3
+
+# 定义干扰、抗干扰策略集合，确保集合中的元素为合法的字符串常量
+JAMMING_POLICY = {
+    "噪声调频", "噪声调幅", "噪声直放", "速度多假目标", "距离多假目标"
+}
+ANTI_JAMMING_POLICY = {
+    "频率捷变", "波形捷变", # 作用于发射端
+     "自适应极化滤波" # 作用于接收端
+}
+
+
+class Service:
+    usrp = None  # 静态类变量
+    status = 0  # 静态类变量
+    surveillance_radar = None  # 侦查雷达实例
+    jammer_radar = None  # 干扰雷达实例
+    _rlock = threading.RLock()  # 可重入锁
+
+    @staticmethod
+    def initialize_usrp():
+        with Service._rlock:
+            Service.get_sdr_status()
+            if Service.status == 1:
+                print('USRP设备已经初始化')
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            try:
+                Service.usrp = uhd.usrp.MultiUSRP()
+                print('------SDR Devices initialize success！------')
+                Service.surveillance_radar = SurveillanceRadar(Service.usrp, rx=CHANNEL_1, tx=CHANNEL_1)
+                Service.jammer_radar = JammerRadar(Service.usrp, rx=CHANNEL_2, tx=CHANNEL_2)
+                Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 初始化失败，状态置为0
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+    @staticmethod
+    def get_sdr_status():
+        with Service._rlock:
+            if Service.status == 0:
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常',{"status": Service.status, "Error": "SDR设备未初始化"}).to_json()
+            try:
+                samples = Service.usrp.recv_num_samps(1, 100e6, 1e6, [0], 50)
+                if samples is None:
+                    Service.status = 0  # 获取状态失败，状态置为0
+                else:
+                    Service.status = 1
+                return ResponseDTO.SUCCESS({"status": Service.status}).to_json()
+            except Exception as e:
+                print('SDR设备异常', e)
+                Service.status = 0  # 获取状态失败，状态置为0
+                Service.usrp = None  # 重置USRP对象
+                return ResponseDTO.ERROR_MS_DATA('SDR设备异常', {"status": Service.status, "Error": str(e)}).to_json()
+
+
+    @staticmethod
+    def data(payload):
+        # 使用已初始化的雷达实例
+        surveillance_radar = Service.surveillance_radar
+        jammer_radar = Service.jammer_radar
+        
+        jamming_policy = payload.get('jamming_policy')
+        anti_jamming_policy = payload.get('anti_jamming_policy')
+        # 判断策略是否合法
+        if jamming_policy not in JAMMING_POLICY or anti_jamming_policy not in ANTI_JAMMING_POLICY:
+            return ResponseDTO.ERROR_MS_DATA('策略不合法', {"status": Service.status, "Error": "策略不合法"}).to_json()
+        # 打印对应策略
+        print(' jamming_policy:', jamming_policy)
+        print(' anti_jamming_policy:', anti_jamming_policy)
+        # 根据策略选择算法
+        jam_algorithm = Service._get_jamming_algorithm_method(jamming_policy)
+        anti_jam_algorithm = Service._get_anti_jamming_algorithm(anti_jamming_policy, 'rx')
+
+        # 1. 应用发射端抗干扰算法（波形/频率捷变）
+        tx_original = np.random.randn(100)
+        if anti_jamming_policy in {"波形捷变", "频率捷变"}:
+            tx_processed = surveillance_radar.process_transmit_signal(
+                tx_signal=tx_original,
+                algorithm=Service._get_tx_algorithm_method(anti_jamming_policy),
+                sample_rate=1e6
+            )
+        else:
+            tx_processed = tx_original
+        
+        # 2. 发送经过处理的发射信号
+        tx_signal = surveillance_radar.send_signal(
+            tx_signal=tx_processed,
+            duration=0.1,
+            center_freq=100e6,
+            sample_rate=1e6,
+            gain=20
+        )
+        
+        # 3. 干扰雷达接收信号并生成干扰
+        jammed_signal = jammer_radar.execute_jamming(
+            rx_signal=tx_signal,
+            algorithm=jam_algorithm,
+            bandwidth=100e6,
+            sample_rate=1e6
+        ) if jam_algorithm else tx_signal
+        
+        # 接收端抗干扰处理（仅限接收端策略）
+        processed_signal = jammed_signal
+        if anti_jam_algorithm:
+            processed_signal = surveillance_radar.execute_anti_jamming(
+                rx_signal=jammed_signal,
+                algorithm=anti_jam_algorithm,
+                sample_rate=1e6,
+                polarization_params={'angle': 45, 'ellipticity': 0.5}
+            )
+        
+        # 类型检查并转换复数信号为实数
+        if np.iscomplexobj(processed_signal):
+            processed_signal = np.real(processed_signal)
+        
+        # 返回结果
+        return ResponseDTO.SUCCESS({"jamming_signal": np.real(jammed_signal).tolist(),
+                                    "anti_jamming_signal": np.real(processed_signal).tolist(),
+                                    "status": Service.status}).to_json()
+
+    @staticmethod
+    def send():
+        try:
+            # 设置中心频率、采样率和增益
+            center_freq = 100e6  # 2.4 GHz
+            sample_rate = 1e6  # 1 MS/s
+            duration = 10  # 以秒为单位
+            gain = 20  # [dB] 建议一开始设置小一点，按照实际情况调整
+            # 生成发送信号
+            num_samples = 100
+            tx_signal = np.random.randn(num_samples) + 0.1j * np.random.randn(num_samples)  # 修复部分
+
+            # 发送信号
+            Service.usrp.send_waveform(tx_signal, duration, center_freq, sample_rate, [0], gain)
+
+            # 接收信号
+            rx_signal = Service.usrp.recv_num_samps(num_samples, center_freq, sample_rate)
+            print('信号已发送:')
+            print(rx_signal)
+            print('信号已接收')
+        except Exception as e:
+            print('发送或接收信号异常', e)
+            Service.status = 0  # 发送或接收信号失败，状态置为0
+            Service.usrp = None  # 重置USRP对象
+
+    @staticmethod
+    def _get_jamming_algorithm_method(policy: str) -> callable:
+        # 干扰算法映射
+        jam_algorithm_map = {
+            "噪声调频": JammingSignalAlgo.frequency_modulation,
+            "噪声调幅": JammingSignalAlgo.amplitude_modulation,
+            "噪声直放": JammingSignalAlgo.repeater_jamming,
+            "速度多假目标": JammingSignalAlgo.velocity_deception,
+            "距离多假目标": JammingSignalAlgo.range_deception
+        }
+        return jam_algorithm_map.get(policy)
+
+    @staticmethod
+    def _get_anti_jamming_algorithm(policy: str, algorithm_type: str) -> callable:
+        """
+        统一抗干扰策略路由方法
+        :param policy: 策略名称
+        :param algorithm_type: 算法类型['tx'发射端/'rx'接收端]
+        """
+        tx_algorithms = {
+            "波形捷变": AntiJammingSignalAlgo.adaptive_filter,
+            "频率捷变": AntiJammingSignalAlgo.time_frequency_filter
+        }
+        rx_algorithms = {
+            "自适应极化滤波": AntiJammingSignalAlgo.polarization_filter
+        }
+        
+        if algorithm_type == 'tx':
+            return tx_algorithms.get(policy)
+        elif algorithm_type == 'rx':
+            return None if policy in {"波形捷变", "频率捷变"} else rx_algorithms.get(policy)
+
+
+# main方法
+if __name__ == '__main__':
+    Service.initialize_usrp()
+    Service.data({"jamming_policy": "噪声调频", "anti_jamming_policy": "频率捷变"})