Beispiel #1
0
    def setUp(self):
        constants.SETTINGS.setValue("NetworkSDRInterface", True)

        self.form = MainController()
        self.form.add_signalfile(get_path_for_data_file("esaver.complex"))
        self.signal = self.form.signal_tab_controller.signal_frames[0].signal
        self.gframe = self.form.generator_tab_controller
        self.form.ui.tabWidget.setCurrentIndex(2)

        project_manager = self.form.project_manager
        self.receive_dialog = ReceiveDialogController(
            project_manager.frequency,
            project_manager.sample_rate,
            project_manager.bandwidth,
            project_manager.gain,
            project_manager.device,
            testing_mode=True)

        self.send_dialog = SendDialogController(
            project_manager.frequency,
            project_manager.sample_rate,
            project_manager.bandwidth,
            project_manager.gain,
            project_manager.device,
            modulated_data=self.signal.data,
            testing_mode=True)
        self.send_dialog.graphics_view.show_full_scene(reinitialize=True)

        self.spectrum_dialog = SpectrumDialogController(
            project_manager.frequency,
            project_manager.sample_rate,
            project_manager.bandwidth,
            project_manager.gain,
            project_manager.device,
            testing_mode=True)

        self.sniff_dialog = ProtocolSniffDialogController(
            project_manager.frequency,
            project_manager.sample_rate,
            project_manager.bandwidth,
            project_manager.gain,
            project_manager.device,
            self.signal.noise_threshold,
            self.signal.qad_center,
            self.signal.bit_len,
            self.signal.tolerance,
            self.signal.modulation_type,
            testing_mode=True)

        self.dialogs = [
            self.receive_dialog, self.send_dialog, self.spectrum_dialog,
            self.sniff_dialog
        ]
Beispiel #2
0
    def __get_send_dialog(self):
        send_dialog = SendDialogController(self.form.project_manager,
                                           modulated_data=self.signal.data,
                                           modulation_msg_indices=None,
                                           testing_mode=True,
                                           parent=self.form)
        if self.SHOW:
            send_dialog.show()

        QApplication.instance().processEvents()
        send_dialog.graphics_view.show_full_scene(reinitialize=True)
        return send_dialog
Beispiel #3
0
    def on_btn_replay_clicked(self):
        project_manager = self.project_manager
        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)
        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)
Beispiel #4
0
    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,
                            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 = 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()
Beispiel #5
0
    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:
            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()
Beispiel #7
0
    def setUp(self):
        constants.SETTINGS.setValue("NetworkSDRInterface", True)

        QTest.qWait(50)
        logger.debug("init form")
        self.form = MainController()
        logger.debug("initalized form")
        app.processEvents()
        QTest.qWait(75)
        logger.debug("Adding signalfile")
        self.form.add_signalfile(get_path_for_data_file("esaver.complex"))
        logger.debug("Added signalfile")
        app.processEvents()
        self.signal = self.form.signal_tab_controller.signal_frames[0].signal
        self.gframe = self.form.generator_tab_controller
        self.form.ui.tabWidget.setCurrentIndex(2)
        app.processEvents()
        QTest.qWait(100)

        project_manager = self.form.project_manager

        logger.debug("Creating Receive Dialog")
        self.receive_dialog = ReceiveDialogController(project_manager,
                                                      testing_mode=True,
                                                      parent=self.form)
        app.processEvents()
        QTest.qWait(50)

        logger.debug("Creating Send Dialog")
        self.send_dialog = SendDialogController(
            project_manager,
            modulated_data=self.signal.data,
            testing_mode=True,
            parent=self.form)
        self.send_dialog.graphics_view.show_full_scene(reinitialize=True)
        app.processEvents()
        QTest.qWait(50)

        logger.debug("Creating Spectrum Dialog")
        self.spectrum_dialog = SpectrumDialogController(project_manager,
                                                        testing_mode=True,
                                                        parent=self.form)
        app.processEvents()
        QTest.qWait(50)

        logger.debug("Creating Sniff Dialog")
        self.sniff_dialog = ProtocolSniffDialogController(
            project_manager,
            self.signal.noise_threshold,
            self.signal.qad_center,
            self.signal.bit_len,
            self.signal.tolerance,
            self.signal.modulation_type,
            testing_mode=True,
            parent=self.form)
        app.processEvents()
        QTest.qWait(50)

        logger.debug("Created Dialogs")

        self.dialogs = [
            self.receive_dialog, self.send_dialog, self.spectrum_dialog,
            self.sniff_dialog
        ]