#参照这个程序设计一个GPS对抗程序,并给出全部代码
import sys
import numpy as np
from PyQt5.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout,
QGridLayout, QGroupBox, QLabel, QSlider, QComboBox, QPushButton,
QDoubleSpinBox, QCheckBox, QFrame)
from PyQt5.QtCore import Qt, QTimer
from PyQt5.QtGui import QFont, QPalette, QColor
import matplotlib.pyplot as plt
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
from matplotlib.figure import Figure
# 添加中文字体支持
plt.rcParams['font.sans-serif'] = ['SimHei', 'Microsoft YaHei', 'SimSun', 'Arial Unicode MS'] # 设置中文字体
plt.rcParams['axes.unicode_minus'] = False # 解决负号显示问题
# ... 其余代码保持不变 ...
class CommunicationSystem:
def __init__(self):
self.signal_freq = 100 # MHz
self.signal_amplitude = 1.0
self.modulation_type = "FM" # FM, AM or PM
self.modulation_index = 0.5
self.snr = 20 # dB
self.noise_amplitude = 0.1
# 干扰参数
self.jamming_type = "None" # None, Noise, Sweep, Pulse, Tone
self.jamming_amplitude = 0.5
self.jamming_freq = 110 # MHz
self.jamming_sweep_start = 90 # MHz
self.jamming_sweep_end = 110 # MHz
self.jamming_sweep_rate = 0.5 # MHz/ms
# 系统参数
self.sample_rate = 1000 # 采样率 (MS/s)
self.duration = 1 # 信号持续时间 (ms)
def generate_signal(self):
"""生成通信信号"""
t = np.linspace(0, self.duration, int(self.sample_rate * self.duration))
carrier = np.sin(2 * np.pi * self.signal_freq * t)
# 调制信号
if self.modulation_type == "FM":
modulating_signal = np.sin(2 * np.pi * 1 * t) # 1 kHz调制信号
signal = np.sin(2 * np.pi * self.signal_freq * t +
self.modulation_index * modulating_signal)
elif self.modulation_type == "AM":
modulating_signal = 0.5 * np.sin(2 * np.pi * 1 * t) + 0.5
signal = self.signal_amplitude * carrier * modulating_signal
else: # PM
modulating_signal = np.sin(2 * np.pi * 1 * t)
signal = np.sin(2 * np.pi * self.signal_freq * t +
self.modulation_index * modulating_signal)
return t, signal
def generate_noise(self, signal):
"""生成噪声"""
noise_power = self.noise_amplitude * np.random.normal(0, 1, len(signal))
return signal + noise_power
def generate_jamming(self, t):
"""生成干扰信号"""
if self.jamming_type == "None":
return np.zeros_like(t)
elif self.jamming_type == "Noise":
return self.jamming_amplitude * np.random.normal(0, 1, len(t))
elif self.jamming_type == "Tone":
return self.jamming_amplitude * np.sin(2 * np.pi * self.jamming_freq * t)
elif self.jamming_type == "Sweep":
freq_sweep = np.linspace(self.jamming_sweep_start,
self.jamming_sweep_end,
len(t))
return self.jamming_amplitude * np.sin(2 * np.pi * freq_sweep * t)
elif self.jamming_type == "Pulse":
jamming_signal = np.zeros_like(t)
pulse_width = 0.1 # 脉冲宽度 (ms)
pulse_start = 0.3 # 脉冲开始时间 (ms)
pulse_end = pulse_start + pulse_width
pulse_indices = np.where((t >= pulse_start) & (t <= pulse_end))[0]
jamming_signal[pulse_indices] = self.jamming_amplitude * np.sin(
2 * np.pi * self.jamming_freq * t[pulse_indices])
return jamming_signal
return np.zeros_like(t)
def generate_combined_signal(self):
"""生成带干扰的通信信号"""
t, signal = self.generate_signal()
noisy_signal = self.generate_noise(signal)
jamming_signal = self.generate_jamming(t)
combined_signal = noisy_signal + jamming_signal
return t, signal, noisy_signal, jamming_signal, combined_signal
def calculate_spectrum(self, signal):
"""计算信号的频谱"""
n = len(signal)
spectrum = np.fft.fft(signal)
freq = np.fft.fftfreq(n, d=1.0 / self.sample_rate)
return freq[:n // 2], np.abs(spectrum[:n // 2])
def calculate_snr(self, signal, noise):
"""计算信噪比"""
signal_power = np.sum(signal ** 2)
noise_power = np.sum(noise ** 2)
if noise_power == 0:
return float('inf')
snr = 10 * np.log10(signal_power / noise_power)
return snr
class DigitalDashboard(QMainWindow):
def __init__(self):
super().__init__()
self.setWindowTitle("超短波通信对抗仿真系统")
self.setGeometry(100, 50, 1400, 900)
# 初始化通信系统
self.comm_system = CommunicationSystem()
# 设置深色主题
self.set_dark_theme()
# 创建主控件
self.main_widget = QWidget()
self.setCentralWidget(self.main_widget)
# 主布局
main_layout = QVBoxLayout(self.main_widget)
main_layout.setSpacing(15)
main_layout.setContentsMargins(20, 20, 20, 20)
# 标题
title_label = QLabel("超短波通信对抗仿真系统")
title_label.setFont(QFont("Arial", 24, QFont.Bold))
title_label.setStyleSheet("color: #1E90FF;")
title_label.setAlignment(Qt.AlignCenter)
main_layout.addWidget(title_label)
# 创建控制面板
control_panel = self.create_control_panel()
main_layout.addWidget(control_panel)
# 创建波形显示区域
waveform_panel = self.create_waveform_panel()
main_layout.addWidget(waveform_panel, 1)
# 创建频谱显示区域
spectrum_panel = self.create_spectrum_panel()
main_layout.addWidget(spectrum_panel, 1)
# 创建状态显示
status_panel = self.create_status_panel()
main_layout.addWidget(status_panel)
# 初始化数据
self.update_simulation()
# 设置定时器用于实时更新
self.timer = QTimer(self)
self.timer.timeout.connect(self.update_simulation)
self.timer.start(100) # 每100ms更新一次
def set_dark_theme(self):
"""设置深色主题"""
dark_palette = QPalette()
dark_palette.setColor(QPalette.Window, QColor(25, 35, 45))
dark_palette.setColor(QPalette.WindowText, Qt.white)
dark_palette.setColor(QPalette.Base, QColor(35, 45, 55))
dark_palette.setColor(QPalette.AlternateBase, QColor(45, 55, 65))
dark_palette.setColor(QPalette.ToolTipBase, Qt.white)
dark_palette.setColor(QPalette.ToolTipText, Qt.white)
dark_palette.setColor(QPalette.Text, Qt.white)
dark_palette.setColor(QPalette.Button, QColor(50, 65, 80))
dark_palette.setColor(QPalette.ButtonText, Qt.white)
dark_palette.setColor(QPalette.BrightText, Qt.red)
dark_palette.setColor(QPalette.Highlight, QColor(30, 144, 255))
dark_palette.setColor(QPalette.HighlightedText, Qt.black)
self.setPalette(dark_palette)
self.setStyleSheet("""
QGroupBox {
font-size: 14px;
font-weight: bold;
border: 2px solid #1E90FF;
border-radius: 8px;
margin-top: 1ex;
color: #1E90FF;
}
QGroupBox::title {
subcontrol-origin: margin;
subcontrol-position: top center;
padding: 0 5px;
}
QSlider::groove:horizontal {
border: 1px solid #4A708B;
height: 8px;
background: #2F4F4F;
margin: 2px 0;
border-radius: 4px;
}
QSlider::handle:horizontal {
background: #1E90FF;
border: 1px solid #4A708B;
width: 18px;
margin: -4px 0;
border-radius: 9px;
}
QPushButton {
background-color: #1E90FF;
color: white;
border: none;
border-radius: 4px;
padding: 5px 10px;
font-weight: bold;
}
QPushButton:hover {
background-color: #00BFFF;
}
QLabel {
color: white;
}
""")
def create_control_panel(self):
"""创建控制面板"""
panel = QGroupBox("通信对抗控制面板")
layout = QGridLayout()
panel.setLayout(layout)
# 通信参数控制
comm_label = QLabel("通信参数:")
comm_label.setFont(QFont("Arial", 12, QFont.Bold))
layout.addWidget(comm_label, 0, 0)
# 信号频率
freq_label = QLabel("信号频率 (MHz):")
self.freq_spin = QDoubleSpinBox()
self.freq_spin.setRange(30, 300)
self.freq_spin.setValue(self.comm_system.signal_freq)
self.freq_spin.setSingleStep(1)
self.freq_spin.valueChanged.connect(self.update_freq)
layout.addWidget(freq_label, 1, 0)
layout.addWidget(self.freq_spin, 1, 1)
# 信号幅度
amp_label = QLabel("信号幅度:")
self.amp_slider = QSlider(Qt.Horizontal)
self.amp_slider.setRange(0, 100)
self.amp_slider.setValue(int(self.comm_system.signal_amplitude * 100))
self.amp_slider.valueChanged.connect(self.update_amp)
layout.addWidget(amp_label, 2, 0)
layout.addWidget(self.amp_slider, 2, 1)
# 调制方式
mod_label = QLabel("调制方式:")
self.mod_combo = QComboBox()
self.mod_combo.addItems(["FM", "AM", "PM"])
self.mod_combo.setCurrentText(self.comm_system.modulation_type)
self.mod_combo.currentTextChanged.connect(self.update_modulation)
layout.addWidget(mod_label, 3, 0)
layout.addWidget(self.mod_combo, 3, 1)
# 调制指数
mod_idx_label = QLabel("调制指数:")
self.mod_idx_slider = QSlider(Qt.Horizontal)
self.mod_idx_slider.setRange(0, 100)
self.mod_idx_slider.setValue(int(self.comm_system.modulation_index * 100))
self.mod_idx_slider.valueChanged.connect(self.update_mod_idx)
layout.addWidget(mod_idx_label, 4, 0)
layout.addWidget(self.mod_idx_slider, 4, 1)
# 干扰参数控制
jam_label = QLabel("干扰参数:")
jam_label.setFont(QFont("Arial", 12, QFont.Bold))
layout.addWidget(jam_label, 0, 2)
# 干扰类型
jam_type_label = QLabel("干扰类型:")
self.jam_type_combo = QComboBox()
self.jam_type_combo.addItems(["None", "Noise", "Tone", "Sweep", "Pulse"])
self.jam_type_combo.setCurrentText(self.comm_system.jamming_type)
self.jam_type_combo.currentTextChanged.connect(self.update_jam_type)
layout.addWidget(jam_type_label, 1, 2)
layout.addWidget(self.jam_type_combo, 1, 3)
# 干扰幅度
jam_amp_label = QLabel("干扰幅度:")
self.jam_amp_slider = QSlider(Qt.Horizontal)
self.jam_amp_slider.setRange(0, 100)
self.jam_amp_slider.setValue(int(self.comm_system.jamming_amplitude * 100))
self.jam_amp_slider.valueChanged.connect(self.update_jam_amp)
layout.addWidget(jam_amp_label, 2, 2)
layout.addWidget(self.jam_amp_slider, 2, 3)
# 干扰频率
jam_freq_label = QLabel("干扰频率 (MHz):")
self.jam_freq_spin = QDoubleSpinBox()
self.jam_freq_spin.setRange(30, 300)
self.jam_freq_spin.setValue(self.comm_system.jamming_freq)
self.jam_freq_spin.setSingleStep(1)
self.jam_freq_spin.valueChanged.connect(self.update_jam_freq)
layout.addWidget(jam_freq_label, 3, 2)
layout.addWidget(self.jam_freq_spin, 3, 3)
# 扫频范围
sweep_start_label = QLabel("扫频起点 (MHz):")
self.sweep_start_spin = QDoubleSpinBox()
self.sweep_start_spin.setRange(30, 300)
self.sweep_start_spin.setValue(self.comm_system.jamming_sweep_start)
self.sweep_start_spin.setSingleStep(1)
self.sweep_start_spin.valueChanged.connect(self.update_sweep_start)
layout.addWidget(sweep_start_label, 4, 2)
layout.addWidget(self.sweep_start_spin, 4, 3)
sweep_end_label = QLabel("扫频终点 (MHz):")
self.sweep_end_spin = QDoubleSpinBox()
self.sweep_end_spin.setRange(30, 300)
self.sweep_end_spin.setValue(self.comm_system.jamming_sweep_end)
self.sweep_end_spin.setSingleStep(1)
self.sweep_end_spin.valueChanged.connect(self.update_sweep_end)
layout.addWidget(sweep_end_label, 5, 2)
layout.addWidget(self.sweep_end_spin, 5, 3)
# 系统参数
sys_label = QLabel("系统参数:")
sys_label.setFont(QFont("Arial", 12, QFont.Bold))
layout.addWidget(sys_label, 0, 4)
# 采样率
sample_rate_label = QLabel("采样率 (MS/s):")
self.sample_rate_spin = QDoubleSpinBox()
self.sample_rate_spin.setRange(100, 2000)
self.sample_rate_spin.setValue(self.comm_system.sample_rate)
self.sample_rate_spin.setSingleStep(100)
self.sample_rate_spin.valueChanged.connect(self.update_sample_rate)
layout.addWidget(sample_rate_label, 1, 4)
layout.addWidget(self.sample_rate_spin, 1, 5)
# 噪声幅度
noise_amp_label = QLabel("噪声幅度:")
self.noise_amp_slider = QSlider(Qt.Horizontal)
self.noise_amp_slider.setRange(0, 100)
self.noise_amp_slider.setValue(int(self.comm_system.noise_amplitude * 100))
self.noise_amp_slider.valueChanged.connect(self.update_noise_amp)
layout.addWidget(noise_amp_label, 2, 4)
layout.addWidget(self.noise_amp_slider, 2, 5)
# 控制按钮
self.reset_btn = QPushButton("重置参数")
self.reset_btn.clicked.connect(self.reset_params)
layout.addWidget(self.reset_btn, 6, 0, 1, 2)
self.auto_jam_btn = QPushButton("自动干扰")
self.auto_jam_btn.clicked.connect(self.toggle_auto_jam)
layout.addWidget(self.auto_jam_btn, 6, 2, 1, 2)
self.optimize_btn = QPushButton("优化通信")
self.optimize_btn.clicked.connect(self.optimize_communication)
layout.addWidget(self.optimize_btn, 6, 4, 1, 2)
self.auto_jam_active = False
return panel
def create_waveform_panel(self):
"""创建波形显示面板"""
panel = QGroupBox("通信波形与干扰波形")
layout = QHBoxLayout()
panel.setLayout(layout)
# 原始信号波形图
self.signal_fig = Figure(figsize=(10, 4), dpi=100)
self.signal_canvas = FigureCanvas(self.signal_fig)
self.signal_ax = self.signal_fig.add_subplot(111)
self.signal_ax.set_title("原始通信信号")
self.signal_ax.set_xlabel("时间 (ms)")
self.signal_ax.set_ylabel("幅度")
self.signal_ax.grid(True, linestyle='--', alpha=0.6)
layout.addWidget(self.signal_canvas)
# 干扰信号波形图
self.jamming_fig = Figure(figsize=(10, 4), dpi=100)
self.jamming_canvas = FigureCanvas(self.jamming_fig)
self.jamming_ax = self.jamming_fig.add_subplot(111)
self.jamming_ax.set_title("干扰信号")
self.jamming_ax.set_xlabel("时间 (ms)")
self.jamming_ax.set_ylabel("幅度")
self.jamming_ax.grid(True, linestyle='--', alpha=0.6)
layout.addWidget(self.jamming_canvas)
# 合成信号波形图
self.combined_fig = Figure(figsize=(10, 4), dpi=100)
self.combined_canvas = FigureCanvas(self.combined_fig)
self.combined_ax = self.combined_fig.add_subplot(111)
self.combined_ax.set_title("合成信号 (通信 + 干扰)")
self.combined_ax.set_xlabel("时间 (ms)")
self.combined_ax.set_ylabel("幅度")
self.combined_ax.grid(True, linestyle='--', alpha=0.6)
layout.addWidget(self.combined_canvas)
return panel
def create_spectrum_panel(self):
"""创建频谱显示面板"""
panel = QGroupBox("信号频谱分析")
layout = QHBoxLayout()
panel.setLayout(layout)
# 原始信号频谱图
self.spectrum_fig = Figure(figsize=(10, 4), dpi=100)
self.spectrum_canvas = FigureCanvas(self.spectrum_fig)
self.spectrum_ax = self.spectrum_fig.add_subplot(111)
self.spectrum_ax.set_title("信号频谱")
self.spectrum_ax.set_xlabel("频率 (MHz)")
self.spectrum_ax.set_ylabel("幅度")
self.spectrum_ax.grid(True, linestyle='--', alpha=0.6)
layout.addWidget(self.spectrum_canvas)
# 合成信号频谱图
self.combined_spectrum_fig = Figure(figsize=(10, 4), dpi=100)
self.combined_spectrum_canvas = FigureCanvas(self.combined_spectrum_fig)
self.combined_spectrum_ax = self.combined_spectrum_fig.add_subplot(111)
self.combined_spectrum_ax.set_title("合成信号频谱")
self.combined_spectrum_ax.set_xlabel("频率 (MHz)")
self.combined_spectrum_ax.set_ylabel("幅度")
self.combined_spectrum_ax.grid(True, linestyle='--', alpha=0.6)
layout.addWidget(self.combined_spectrum_canvas)
return panel
def create_status_panel(self):
"""创建状态显示面板"""
panel = QFrame()
panel.setFrameShape(QFrame.StyledPanel)
layout = QHBoxLayout()
panel.setLayout(layout)
# 通信状态
comm_status = QGroupBox("通信状态")
comm_layout = QVBoxLayout()
comm_status.setLayout(comm_layout)
self.comm_status_label = QLabel("通信质量: 良好")
self.comm_status_label.setFont(QFont("Arial", 14))
self.comm_status_label.setStyleSheet("color: #00FF00;")
comm_layout.addWidget(self.comm_status_label)
self.snr_label = QLabel("信噪比(SNR): 20 dB")
self.snr_label.setFont(QFont("Arial", 12))
comm_layout.addWidget(self.snr_label)
self.ber_label = QLabel("误码率(BER): 0.001%")
self.ber_label.setFont(QFont("Arial", 12))
comm_layout.addWidget(self.ber_label)
layout.addWidget(comm_status)
# 干扰状态
jam_status = QGroupBox("干扰状态")
jam_layout = QVBoxLayout()
jam_status.setLayout(jam_layout)
self.jam_status_label = QLabel("干扰强度: 弱")
self.jam_status_label.setFont(QFont("Arial", 14))
self.jam_status_label.setStyleSheet("color: #FFA500;")
jam_layout.addWidget(self.jam_status_label)
self.jam_power_label = QLabel("干扰功率: 0.5")
self.jam_power_label.setFont(QFont("Arial", 12))
jam_layout.addWidget(self.jam_power_label)
self.jam_effect_label = QLabel("干扰效果: 轻微")
self.jam_effect_label.setFont(QFont("Arial", 12))
jam_layout.addWidget(self.jam_effect_label)
layout.addWidget(jam_status)
# 系统状态
sys_status = QGroupBox("系统状态")
sys_layout = QVBoxLayout()
sys_status.setLayout(sys_layout)
self.sys_status_label = QLabel("系统运行: 正常")
self.sys_status_label.setFont(QFont("Arial", 14))
self.sys_status_label.setStyleSheet("color: #00FF00;")
sys_layout.addWidget(self.sys_status_label)
self.sample_rate_status = QLabel("采样率: 1000 MS/s")
self.sample_rate_status.setFont(QFont("Arial", 12))
sys_layout.addWidget(self.sample_rate_status)
self.freq_range_status = QLabel("频率范围: 30-300 MHz")
self.freq_range_status.setFont(QFont("Arial", 12))
sys_layout.addWidget(self.freq_range_status)
layout.addWidget(sys_status)
return panel
def update_simulation(self):
"""更新仿真数据并刷新界面"""
# 生成信号数据
t, signal, noisy_signal, jamming_signal, combined_signal = self.comm_system.generate_combined_signal()
# 计算频谱
freq, spectrum = self.comm_system.calculate_spectrum(signal)
_, combined_spectrum = self.comm_system.calculate_spectrum(combined_signal)
# 计算信噪比
snr = self.comm_system.calculate_snr(signal, jamming_signal + (noisy_signal - signal))
# 更新波形图
self.update_waveform_plot(t, signal, jamming_signal, combined_signal)
# 更新频谱图
self.update_spectrum_plot(freq, spectrum, combined_spectrum)
# 更新状态显示
self.update_status(snr, combined_signal)
# 自动干扰模式
if self.auto_jam_active:
self.auto_jamming()
def update_waveform_plot(self, t, signal, jamming_signal, combined_signal):
"""更新波形图"""
# 原始信号
self.signal_ax.clear()
self.signal_ax.plot(t, signal, 'b-', linewidth=1.5)
self.signal_ax.set_title("原始通信信号")
self.signal_ax.set_xlabel("时间 (ms)")
self.signal_ax.set_ylabel("幅度")
self.signal_ax.grid(True, linestyle='--', alpha=0.6)
self.signal_ax.set_xlim(0, self.comm_system.duration)
self.signal_ax.set_ylim(-2.5, 2.5)
self.signal_canvas.draw()
# 干扰信号
self.jamming_ax.clear()
self.jamming_ax.plot(t, jamming_signal, 'r-', linewidth=1.5)
self.jamming_ax.set_title("干扰信号")
self.jamming_ax.set_xlabel("时间 (ms)")
self.jamming_ax.set_ylabel("幅度")
self.jamming_ax.grid(True, linestyle='--', alpha=0.6)
self.jamming_ax.set_xlim(0, self.comm_system.duration)
self.jamming_ax.set_ylim(-2.5, 2.5)
self.jamming_canvas.draw()
# 合成信号
self.combined_ax.clear()
self.combined_ax.plot(t, combined_signal, 'g-', linewidth=1.5)
self.combined_ax.set_title("合成信号 (通信 + 干扰)")
self.combined_ax.set_xlabel("时间 (ms)")
self.combined_ax.set_ylabel("幅度")
self.combined_ax.grid(True, linestyle='--', alpha=0.6)
self.combined_ax.set_xlim(0, self.comm_system.duration)
self.combined_ax.set_ylim(-2.5, 2.5)
self.combined_canvas.draw()
def update_spectrum_plot(self, freq, spectrum, combined_spectrum):
"""更新频谱图"""
# 原始信号频谱
self.spectrum_ax.clear()
self.spectrum_ax.plot(freq, spectrum, 'b-', linewidth=1.5)
self.spectrum_ax.set_title("信号频谱")
self.spectrum_ax.set_xlabel("频率 (MHz)")
self.spectrum_ax.set_ylabel("幅度")
self.spectrum_ax.grid(True, linestyle='--', alpha=0.6)
self.spectrum_ax.set_xlim(0, 300)
self.spectrum_canvas.draw()
# 合成信号频谱
self.combined_spectrum_ax.clear()
self.combined_spectrum_ax.plot(freq, combined_spectrum, 'g-', linewidth=1.5)
self.combined_spectrum_ax.set_title("合成信号频谱")
self.combined_spectrum_ax.set_xlabel("频率 (MHz)")
self.combined_spectrum_ax.set_ylabel("幅度")
self.combined_spectrum_ax.grid(True, linestyle='--', alpha=0.6)
self.combined_spectrum_ax.set_xlim(0, 300)
self.combined_spectrum_canvas.draw()
def update_status(self, snr, combined_signal):
"""更新状态显示"""
# 更新SNR
self.snr_label.setText(f"信噪比(SNR): {snr:.2f} dB")
# 估算误码率
ber = max(0.0001, 1 / (1 + np.exp(0.5 * (snr - 10))))
self.ber_label.setText(f"误码率(BER): {ber * 100:.4f}%")
# 通信质量评估
if snr > 15:
self.comm_status_label.setText("通信质量: 优秀")
self.comm_status_label.setStyleSheet("color: #00FF00;")
elif snr > 10:
self.comm_status_label.setText("通信质量: 良好")
self.comm_status_label.setStyleSheet("color: #7CFC00;")
elif snr > 5:
self.comm_status_label.setText("通信质量: 一般")
self.comm_status_label.setStyleSheet("color: #FFD700;")
else:
self.comm_status_label.setText("通信质量: 差")
self.comm_status_label.setStyleSheet("color: #FF4500;")
# 干扰状态
jam_power = np.sum(np.abs(self.comm_system.jamming_amplitude))
self.jam_power_label.setText(f"干扰功率: {jam_power:.2f}")
if jam_power < 0.3:
self.jam_status_label.setText("干扰强度: 弱")
self.jam_status_label.setStyleSheet("color: #7CFC00;")
elif jam_power < 0.7:
self.jam_status_label.setText("干扰强度: 中")
self.jam_status_label.setStyleSheet("color: #FFA500;")
else:
self.jam_status_label.setText("干扰强度: 强")
self.jam_status_label.setStyleSheet("color: #FF4500;")
# 干扰效果评估
if snr < 5:
self.jam_effect_label.setText("干扰效果: 严重")
elif snr < 10:
self.jam_effect_label.setText("干扰效果: 显著")
elif snr < 15:
self.jam_effect_label.setText("干扰效果: 轻微")
else:
self.jam_effect_label.setText("干扰效果: 无")
# 系统状态
self.sample_rate_status.setText(f"采样率: {self.comm_system.sample_rate} MS/s")
def auto_jamming(self):
"""自动干扰模式"""
# 随机改变干扰参数
if np.random.rand() < 0.1:
self.jam_type_combo.setCurrentIndex(np.random.randint(1, 5))
if np.random.rand() < 0.2:
new_freq = max(30, min(300, self.comm_system.jamming_freq + np.random.randint(-20, 20)))
self.jam_freq_spin.setValue(new_freq)
if np.random.rand() < 0.3:
new_amp = max(0.1, min(1.0, self.comm_system.jamming_amplitude + np.random.uniform(-0.1, 0.1)))
self.jam_amp_slider.setValue(int(new_amp * 100))
def toggle_auto_jam(self):
"""切换自动干扰模式"""
self.auto_jam_active = not self.auto_jam_active
if self.auto_jam_active:
self.auto_jam_btn.setText("停止干扰")
self.auto_jam_btn.setStyleSheet("background-color: #FF4500;")
else:
self.auto_jam_btn.setText("自动干扰")
self.auto_jam_btn.setStyleSheet("")
def optimize_communication(self):
"""优化通信参数"""
# 简单优化策略:避开干扰频率
if self.comm_system.jamming_type != "None" and self.comm_system.jamming_freq > 0:
# 尝试避开干扰频率
new_freq = self.comm_system.jamming_freq + 20
if new_freq > 300:
new_freq = self.comm_system.jamming_freq - 20
self.freq_spin.setValue(new_freq)
self.comm_status_label.setText("通信参数已优化")
def reset_params(self):
"""重置参数到默认值"""
self.comm_system = CommunicationSystem()
self.freq_spin.setValue(self.comm_system.signal_freq)
self.amp_slider.setValue(int(self.comm_system.signal_amplitude * 100))
self.mod_combo.setCurrentText(self.comm_system.modulation_type)
self.mod_idx_slider.setValue(int(self.comm_system.modulation_index * 100))
self.jam_type_combo.setCurrentText(self.comm_system.jamming_type)
self.jam_amp_slider.setValue(int(self.comm_system.jamming_amplitude * 100))
self.jam_freq_spin.setValue(self.comm_system.jamming_freq)
self.sweep_start_spin.setValue(self.comm_system.jamming_sweep_start)
self.sweep_end_spin.setValue(self.comm_system.jamming_sweep_end)
self.sample_rate_spin.setValue(self.comm_system.sample_rate)
self.noise_amp_slider.setValue(int(self.comm_system.noise_amplitude * 100))
self.auto_jam_active = False
self.auto_jam_btn.setText("自动干扰")
self.auto_jam_btn.setStyleSheet("")
# 参数更新函数
def update_freq(self, value):
self.comm_system.signal_freq = value
def update_amp(self, value):
self.comm_system.signal_amplitude = value / 100.0
def update_modulation(self, text):
self.comm_system.modulation_type = text
def update_mod_idx(self, value):
self.comm_system.modulation_index = value / 100.0
def update_jam_type(self, text):
self.comm_system.jamming_type = text
def update_jam_amp(self, value):
self.comm_system.jamming_amplitude = value / 100.0
def update_jam_freq(self, value):
self.comm_system.jamming_freq = value
def update_sweep_start(self, value):
self.comm_system.jamming_sweep_start = value
def update_sweep_end(self, value):
self.comm_system.jamming_sweep_end = value
def update_sample_rate(self, value):
self.comm_system.sample_rate = value
def update_noise_amp(self, value):
self.comm_system.noise_amplitude = value / 100.0
if __name__ == "__main__":
app = QApplication(sys.argv)
window = DigitalDashboard()
window.show()
sys.exit(app.exec_())
最新发布