Esempio n. 1
0
 def _init_font(self):
     # There isn't a standard way of getting the system default monospace
     # font in Qt4 (it was introduced in Qt5.2). If QFontDatabase.FixedFont
     # exists, then we can assume that this functionality exists and ask for
     # the correct font directly. Otherwise we ask for a font that doesn't
     # exist and specify our requirements. Qt then finds an existing font
     # that best matches our parameters.
     if hasattr(QFontDatabase, "systemFont") and hasattr(
             QFontDatabase, "FixedFont"):
         font = QFontDatabase.systemFont(QFontDatabase.FixedFont)
     else:
         font = QFont("")
         font.setFixedPitch(True)
         font.setStyleHint(QFont.Monospace)
     self.setFont(font)
Esempio n. 2
0
    def __init__(self,
                 file_name,
                 job_name,
                 job_number,
                 realization,
                 iteration,
                 parent=None):
        super().__init__(parent)

        self.setWindowTitle(
            f"{job_name} # {job_number} "
            f"Realization: {realization} Iteration: {iteration}")

        try:
            self._file = open(file_name, "r")
        except OSError as error:
            self._mb = QMessageBox(
                QMessageBox.Critical,
                "Error opening file",
                error.strerror,
                QMessageBox.Ok,
                self,
            )
            self._mb.finished.connect(self.accept)
            self._mb.show()
            return

        self._view = QPlainTextEdit()
        self._view.setReadOnly(True)
        self._view.setWordWrapMode(QTextOption.NoWrap)
        # for moving the actual slider
        self._view.verticalScrollBar().sliderMoved.connect(self._update_cursor)
        # for mouse wheel and keyboard arrows
        self._view.verticalScrollBar().valueChanged.connect(
            self._update_cursor)

        self._view.setFont(QFontDatabase.systemFont(QFontDatabase.FixedFont))

        self._follow_mode = False

        self._init_layout()
        self._init_thread()

        self.show()
Esempio n. 3
0
    def __init__(self,
                 port: str = None,
                 baudrate: int = None,
                 address: int = None):
        super().__init__()

        #
        # Main window UI
        #

        logging.debug("Initializing MainWindow from mainwindow.ui")
        self.ui = loadUi(dirname(__file__) + "/mainwindow.ui", self)

        logging.debug("Configuring fixed font for labels")
        font = QFontDatabase.systemFont(QFontDatabase.FixedFont)
        font.setBold(True)
        font.setPointSize(36)
        self.ui.voltageInput.setFont(font)
        self.ui.voltageOutput.setFont(font)
        self.ui.currentOutput.setFont(font)
        self.ui.powerOutput.setFont(font)

        logging.debug("Resizing widgets and window to minimum size")
        self.adjustSize()
        self.resize(self.minimumSize())

        #
        # Default value definitions
        #

        # Precition output formats
        # Display formats on real devices
        # Model     V      I       P-on<99W P-on>99W
        # RD6006P   00.000 0.0000  00.000   000.00
        # RD6006    00.00  0.000   00.00    000.0
        # RD6012    00.00  00.00   00.00    000.0
        # RD6018    00.00  00.00   00.00    000.0

        logging.debug("Defining default value definitions")
        self.default_voltage_input_format = "%05.2f"
        self.default_voltage_output_format = "%05.2f"
        self.default_current_output_format = "%05.2f"
        self.default_power_output_format = "%6.2f"
        self.default_voltage_max = 61.0
        self.default_current_max = 0.0

        #
        # QSettings & Setting variables
        #

        logging.debug("Initializing QSettings")
        self.settings = QSettings("ShayBox", "RidenGUI")

        if self.settings.value("first-run", 1) == 1:
            logging.debug("First run detected, showing settings wizard")
            SettingsWizard(self.settings, self).exec()
            exit(0)

        logging.debug("Loading custom format strings from settings")
        self.voltage_input_format = self.settings.value(
            "format/voltage-input", self.default_voltage_input_format)
        self.voltage_output_format = self.settings.value(
            "format/voltage-output", self.default_voltage_output_format)
        self.current_output_format = self.settings.value(
            "format/current-output", self.default_current_output_format)
        self.power_output_format = self.settings.value(
            "format/power-output", self.default_power_output_format)

        logging.debug("Loading custom stylesheets from settings")
        self.output_on = self.settings.value(
            "style/output-on-bg") + self.settings.value("style/output-on-text")
        self.output_off = self.settings.value(
            "style/output-off-bg") + self.settings.value(
                "style/output-off-text")
        self.output_fault = self.settings.value(
            "style/output-fault-bg") + self.settings.value(
                "style/output-fault-text")

        #
        # Riden
        #

        logging.debug("Initializing Riden library")
        self.r = Riden(
            port=port or self.settings.value("serial/port", "/dev/ttyUSB0"),
            baudrate=baudrate
            or int(self.settings.value("serial/baudrate", 115200)),
            address=address or int(self.settings.value("serial/address", 1)),
        )

        logging.debug("Defining temporary variables for live feedback")
        self.prev_v_set = self.r.v_set
        self.prev_i_set = self.r.i_set

        #
        # Dynamic value definitions
        #

        logging.debug("Defining dynamic value definitions")
        if self.r.type == "RD6012":
            self.default_voltage_output_format = "%05.3f"
            self.default_current_output_format = "%05.4f"
            self.default_power_output_format = "%6.3f"
            self.default_current_max = 6.1
        elif self.r.type == "RD6006":
            self.default_current_output_format = "%04.3f"
            self.default_current_max = 6.1
        elif self.r.type == "RD6012":
            self.default_current_max = 12.1
        elif self.r.type == "RD6018":
            self.default_current_max = 18.1
        elif self.r.type == "RD6024":
            self.default_current_max = 24.1

        #
        # Qt Slots, Signals, and Messages
        #

        logging.debug("Connecting signals and slots")
        self.connect_signals()

        logging.debug("Setting permenant statusbar message")
        self.ui.statusbar.showMessage(
            "Connected to %s using %s at %s baud | FW: %s | SN: %s" % (
                self.r.type,
                self.r.serial.port,
                self.r.serial.baudrate,
                self.r.fw,
                self.r.sn,
            ))

        #
        # Background worker
        #

        logging.debug("Starting worker thread")
        self.worker = Worker(self.r, self.settings, self)
        self.worker.update.connect(self.worker_signal)
        self.worker.start()