def on_spectrum_analyzer_link_activated(self, link: str):
if link == "open_spectrum_analyzer":
r = SpectrumDialogController(ProjectManager(None), parent=self)
if r.has_empty_device_list:
Errors.no_device()
r.close()
return
r.device_parameters_changed.connect(self.set_recording_params_from_spectrum_analyzer_link)
r.show()
def on_show_spectrum_dialog_action_triggered(self):
pm = self.project_manager
r = SpectrumDialogController(pm, parent=self)
if r.has_empty_device_list:
Errors.no_device()
r.close()
return
r.device_parameters_changed.connect(pm.set_device_parameters)
r.show()
def create_protocol_sniff_dialog(self, testing_mode=False):
pm = self.project_manager
signal = next((proto.signal for proto in self.compare_frame_controller.protocol_list), None)
signals = [f.signal for f in self.signal_tab_controller.signal_frames if f.signal]
psd = ProtocolSniffDialog(project_manager=pm, signal=signal, signals=signals,
testing_mode=testing_mode, parent=self)
if psd.has_empty_device_list:
Errors.no_device()
psd.close()
return None
else:
psd.device_parameters_changed.connect(pm.set_device_parameters)
psd.protocol_accepted.connect(self.compare_frame_controller.add_sniffed_protocol_messages)
return psd
def on_show_record_dialog_action_triggered(self):
pm = self.project_manager
try:
r = ReceiveDialog(pm, parent=self)
except OSError as e:
logger.error(repr(e))
return
if r.has_empty_device_list:
Errors.no_device()
r.close()
return
r.device_parameters_changed.connect(pm.set_device_parameters)
r.files_recorded.connect(self.on_signals_recorded)
r.show()
def on_btn_replay_clicked(self):
project_manager = self.project_manager
try:
dialog = SendDialogController(project_manager, modulated_data=self.signal.data, parent=self)
except OSError as e:
logger.error(repr(e))
return
if dialog.has_empty_device_list:
Errors.no_device()
dialog.close()
return
dialog.recording_parameters.connect(project_manager.set_recording_parameters)
dialog.show()
dialog.graphics_view.show_full_scene(reinitialize=True)
def on_btn_send_clicked(self):
try:
total_samples = self.total_modulated_samples
buffer = self.prepare_modulation_buffer(total_samples)
if buffer is not None:
modulated_data = self.modulate_data(buffer)
else:
# Enter continuous mode
modulated_data = None
try:
if modulated_data is not None:
try:
dialog = SendDialog(self.project_manager, modulated_data=modulated_data,
modulation_msg_indices=self.modulation_msg_indices, parent=self)
except MemoryError:
# Not enough memory for device buffer so we need to create a continuous send dialog
del modulated_data
Errors.not_enough_ram_for_sending_precache(None)
dialog = ContinuousSendDialog(self.project_manager,
self.table_model.protocol.messages,
self.modulators, total_samples, parent=self)
else:
dialog = ContinuousSendDialog(self.project_manager, self.table_model.protocol.messages,
self.modulators, total_samples, parent=self)
except OSError as e:
logger.exception(e)
return
if dialog.has_empty_device_list:
Errors.no_device()
dialog.close()
return
dialog.device_parameters_changed.connect(self.project_manager.set_device_parameters)
dialog.show()
dialog.graphics_view.show_full_scene(reinitialize=True)
except Exception as e:
Errors.generic_error(self.tr("Failed to generate data"), str(e), traceback.format_exc())
self.unsetCursor()
def show_proto_sniff_dialog(self):
pm = self.project_manager
signal = next((proto.signal for proto in self.compare_frame_controller.protocol_list), None)
bit_len = signal.bit_len if signal else 100
mod_type = signal.modulation_type if signal else 1
tolerance = signal.tolerance if signal else 5
noise = signal.noise_threshold if signal else 0.001
center = signal.qad_center if signal else 0.02
psd = ProtocolSniffDialogController(pm, noise, center, bit_len, tolerance, mod_type,
self.compare_frame_controller.decodings,
encoding_index=self.compare_frame_controller.ui.cbDecoding.currentIndex(),
parent=self)
if psd.has_empty_device_list:
Errors.no_device()
psd.close()
else:
psd.recording_parameters.connect(pm.set_recording_parameters)
psd.protocol_accepted.connect(self.compare_frame_controller.add_sniffed_protocol_messages)
psd.show()
def on_btn_send_clicked(self):
try:
total_samples = self.total_modulated_samples
buffer = self.prepare_modulation_buffer(total_samples)
if buffer is not None:
modulated_data = self.modulate_data(buffer)
else:
# Enter continuous mode
modulated_data = None
try:
if modulated_data is not None:
try:
dialog = SendDialogController(self.project_manager, modulated_data=modulated_data, parent=self)
except MemoryError:
# Not enough memory for device buffer so we need to create a continuous send dialog
del modulated_data
Errors.not_enough_ram_for_sending_precache(None)
dialog = ContinuousSendDialogController(self.project_manager,
self.table_model.protocol.messages,
self.modulators, total_samples, parent=self)
else:
dialog = ContinuousSendDialogController(self.project_manager, self.table_model.protocol.messages,
self.modulators, total_samples, parent=self)
except OSError as e:
logger.error(repr(e))
return
if dialog.has_empty_device_list:
Errors.no_device()
dialog.close()
return
dialog.recording_parameters.connect(self.project_manager.set_recording_parameters)
dialog.show()
dialog.graphics_view.show_full_scene(reinitialize=True)
except Exception as e:
Errors.generic_error(self.tr("Failed to generate data"), str(e), traceback.format_exc())
self.unsetCursor()
def on_btn_send_clicked(self):
try:
modulated_data = self.modulate_data()
try:
dialog = SendDialogController(self.project_manager,
modulated_data=modulated_data,
parent=self)
except OSError as e:
logger.error(repr(e))
return
if dialog.has_empty_device_list:
Errors.no_device()
dialog.close()
return
dialog.recording_parameters.connect(
self.project_manager.set_recording_parameters)
dialog.show()
dialog.graphics_view.show_full_scene(reinitialize=True)
except Exception as e:
Errors.generic_error(self.tr("Failed to generate data"), str(e),
traceback.format_exc())
self.unsetCursor()
def on_btn_replay_clicked(self):
project_manager = self.project_manager
try:
dialog = SendDialogController(project_manager.frequency,
project_manager.sample_rate,
project_manager.bandwidth,
project_manager.gain,
project_manager.device,
modulated_data=self.signal.data,
parent=self)
except OSError as e:
logger.error(repr(e))
return
if dialog.has_empty_device_list:
Errors.no_device()
dialog.close()
return
dialog.recording_parameters.connect(
project_manager.set_recording_parameters)
dialog.show()
dialog.graphics_view.show_full_scene(reinitialize=True)
def __init__(self,
freq,
samp_rate,
bw,
gain,
device,
noise,
center,
bit_length,
tolerance,
modulation_type_index,
parent=None):
super().__init__(parent)
self.ui = Ui_SniffProtocol()
self.ui.setupUi(self)
self.setAttribute(Qt.WA_DeleteOnClose)
self.ui.spinBoxFreq.setValue(freq)
self.ui.spinBoxSampleRate.setValue(samp_rate)
self.ui.spinBoxBandwidth.setValue(bw)
self.ui.spinBoxGain.setValue(gain)
self.ui.spinboxNoise.setValue(noise)
self.ui.spinboxCenter.setValue(center)
self.ui.spinboxBitLen.setValue(bit_length)
self.ui.spinboxErrorTolerance.setValue(tolerance)
self.ui.comboxModulation.setCurrentIndex(modulation_type_index)
self.ui.btnStop.setEnabled(False)
self.ui.btnClear.setEnabled(False)
self.ui.cbDevice.clear()
items = []
bh = BackendHandler()
for device_name in bh.DEVICE_NAMES:
dev = bh.device_backends[device_name.lower()]
if dev.is_enabled and dev.supports_rx:
items.append(device_name)
pm = PluginManager()
if pm.is_plugin_enabled("NetworkSDRInterface"):
items.append(NetworkSDRInterfacePlugin.NETWORK_SDR_NAME)
self.ui.cbDevice.addItems(items)
del bh
if device in items:
self.ui.cbDevice.setCurrentIndex(items.index(device))
if self.ui.cbDevice.count() == 0:
Errors.no_device()
self.close()
return
device = self.ui.cbDevice.currentText()
self.sniffer = ProtocolSniffer(bit_length, center, noise, tolerance,
modulation_type_index, samp_rate, freq,
gain, bw, device)
self.set_object_visibility()
self.sniffer.usrp_ip = self.ui.lineEditIP.text()
self.bw_sr_are_locked = self.ui.btnLockBWSR.isChecked()
ipRange = "(?:[0-1]?[0-9]?[0-9]|2[0-4][0-9]|25[0-5])"
ipRegex = QRegExp("^" + ipRange + "\\." + ipRange + "\\." + ipRange +
"\\." + ipRange + "$")
self.ui.lineEditIP.setValidator(QRegExpValidator(ipRegex))
# Auto Complete like a Boss
completer = QCompleter()
completer.setModel(QDirModel(completer))
self.ui.lineEditOutputFile.setCompleter(completer)
self.create_connects()
