def loads(self, stream, fileroot): self.wipe_slate() design = PropertyNode() if props_json.loads(stream, design, ""): print "json parse successful" else: error = QErrorMessage(self) error.showMessage( "json parse failed" ) return False # design.pretty_print() self.setWindowTitle( self.default_title + " - " + fileroot ) node = design.getChild('overview', True) self.overview.load(node) design.setLen('wing', 1) # force to be enumerated if not already num_wings = design.getLen('wing') for i in range(num_wings): wing_node = design.getChild('wing[%d]' % i) wing = WingUI(changefunc=self.onChange) wing.load(wing_node) self.wings.append(wing) self.tabs.addTab( wing.get_widget(), "Wing: " + wing.get_name() ) self.rebuildWingLists() self.setClean()
def handle_error(self, error): """Handle when an error occurs Show the error in an error message window. """ em = QErrorMessage(self.main_window) em.showMessage(error)
def validateForSubmit(self): errorMsgs = [] reference = self.ui.referenceField.text() if reference == "": errorMsgs.append("Du har glömt referensfältet") counter = 1 for j in self.jobList: if j.ui.description.text() == "": errorMsgs.append("Du har glömt beskrivning på job " + str(counter)) try: float(j.ui.price.text().replace(",", ".")) except Exception: errorMsgs.append("Det ser inte ut som en siffra på priset på job " + str(counter)) try: int(j.ui.number.text()) except Exception: errorMsgs.append("Det ser inte ut som en siffra på antalet på job " + str(counter)) counter += 1 # TODO: if new customer is added if self.newCustomerActivated: if self.newCustomerForm.ui.name.text() == "": errorMsgs.append("Det finns inget namn på den nya kunden") if self.newCustomerForm.ui.address.text() == "": errorMsgs.append("Det finns ingen address på den nya kunden") if self.newCustomerForm.ui.zip.text() == "": errorMsgs.append("Det finns inget postnummer på den nya kunden") if len(errorMsgs) != 0: errWidget = QErrorMessage(self) errWidget.showMessage("<br/>".join(errorMsgs)) return False return True
def display_error(err): app = QApplication.instance() window = app.activeWindow() dialog = QErrorMessage(window) dialog.setWindowModality(Qt.WindowModal) dialog.setWindowTitle("Error") dialog.showMessage(err)
def main(): # Arguments parsing parser = argparse.ArgumentParser( description="Daemon program for the Optimus Manager tool.\n" "https://github.com/Askannz/optimus-manager") parser.parse_args() print("Optimus Manager (systray) version %s" % envs.VERSION) # Setup app = QApplication(sys.argv) # Make sure it doesn't quit after cancelling a confirm prompt app.setQuitOnLastWindowClosed(False) # Warning message : this app is deprecated msg = QMessageBox() msg.setIcon(QMessageBox.Warning) msg.setText("optimus-manager-systray is deprecated") msg.setText( "The current tray app bundled in optimus-manager is deprecated" " and will be removed in a future release. Please install the program" " <b>optimus-manager-qt</b> instead.<br><br>" "Github : <a href=\"https://github.com/Shatur95/optimus-manager-qt\">" "https://github.com/Shatur95/optimus-manager-qt</a><br>" "AUR : <a href=\"https://aur.archlinux.org/packages/optimus-manager-qt/\">" "https://aur.archlinux.org/packages/optimus-manager-qt/</a><br>") msg.exec() # Check current mode try: mode = checks.read_gpu_mode() print('Current mode:', mode) except checks.CheckError as e: msg = "Error reading mode : %s" % str(e) print(msg) error_dialog = QErrorMessage() error_dialog.showMessage(msg) sys.exit(app.exec_()) # Setup systray widget = QWidget() tray_icon = SystemTrayIcon(mode, widget) tray_icon.show() # Make sure KeyboardInterrupt signals and exceptions are handled correctly setup_interrupt_handling() sys.excepthook = traceback.print_exception # Start sys.exit(app.exec_())
def save_comments(self): if self.current_mode is None: self.error_dialog = QErrorMessage() self.error_dialog.showMessage("No mode selected") return file = self.expListWidget.currentItem().data(QtCore.Qt.UserRole) fname = file[:-3] label = DataLabel(opt1=self.opt1.text(), opt2=self.opt2.text(), comments=self.commentLineEdit.text(), error=self.errorCheckBox.isChecked(), mode=self.current_mode) label.save(fname)
def connection_error(self, error): self.timer.stop() error_dialog = QErrorMessage() error_dialog.setWindowTitle('Unable to connect to discord') error_dialog.showMessage(error) error_dialog.exec_() sys.exit(1)
def readContours(self): """Reads contours saved in xml format (Echoplaque compatible)""" if self.image == False: warning = QErrorMessage() warning.setWindowModality(Qt.WindowModal) warning.showMessage( 'Reading of contours failed. Images must be loaded prior to loading contours' ) warning.exec_() else: options = QFileDialog.Options() options |= QFileDialog.DontUseNativeDialog fileName, _ = QFileDialog.getOpenFileName( self, "QFileDialog.getOpenFileName()", "", "XML file (*.xml)", options=options) self.lumen, self.plaque, self.stent, self.resolution, frames = read_xml.read( fileName) self.lumen = self.mapToList(self.lumen) self.plaque = self.mapToList(self.plaque) self.stent = self.mapToList(self.stent) self.contours = True self.resizeContours() self.wid.setData(self.lumen, self.plaque, self.images) self.hideBox.setChecked(False)
def go_to_epoch(self, checked=False, test_text_str=None): """Go to any window""" if test_text_str is not None: time_str = test_text_str ok = True else: time_str, ok = QInputDialog.getText(self, 'Go To Epoch', 'Enter start time of the ' 'epoch,\nin seconds ("1560") ' 'or\nas absolute time ' '("22:30")') if not ok: return try: rec_start_time = self.parent.info.dataset.header['start_time'] window_start = _convert_timestr_to_seconds(time_str, rec_start_time) except ValueError as err: error_dialog = QErrorMessage() error_dialog.setWindowTitle('Error moving to epoch') error_dialog.showMessage(str(err)) if test_text_str is None: error_dialog.exec() self.parent.statusBar().showMessage(str(err)) return self.parent.overview.update_position(window_start)
class MainWindow(QMainWindow, DatalogTestItemAnalysis_UI.Ui_MainWindow): def __init__(self): super(MainWindow, self).__init__() self.setupUi(self) self.cwd = getcwd() self.qe = QErrorMessage(self) self.Open_pushButton.clicked.connect(self.Open) self.Run_pushButton.clicked.connect(self.Run) def Open(self): fileNameChoose, fileType = QFileDialog.getOpenFileName( self, 'Select CSV File', self.cwd, 'CSV Files(*.csv);;All Files(*)') if not fileNameChoose: return self.Open_lineEdit.setText(fileNameChoose) def CallBackLog(self, msg): self.progressBar.setValue( int(msg)) # pass the thread's parameters to progressBar if msg == '100': self.Run_pushButton.setEnabled(True) def Run(self): if not self.Open_lineEdit.text(): self.qe.showMessage('Path cannot be empty!') return global totalCount, currentCount, last_test_item_column_num, sigma, dpi with open(self.Open_lineEdit.text()) as f: data = [] csvReader = reader(f) for row in csvReader: data.append(row) # get row and column of last test item search_last_test_item = search_string(data, 'MIPIError') if not search_last_test_item: exit() else: last_test_item_column_num = search_last_test_item[1] totalCount = last_test_item_column_num currentCount = 0 sigma = int(self.Sigma_lineEdit.text()) dpi = int(self.DPI_lineEdit.text()) # create thread self.Run_pushButton.setEnabled(False) self.thread = RunThread(self.Open_lineEdit.text()) # connect signal self.thread._signal.connect(self.CallBackLog) self.thread.daemon = True self.thread.start()
def load_cam(self): self.cam_page.setLayout(self.cam_page_lay) self.error_cam.hide() self.camera = QCameraInfo.defaultCamera() # Проверяем, что камера сущетсвует # Если нет, то переключаемся на вторую вкладку if self.camera.isNull(): dialog = QErrorMessage() dialog.setWindowTitle('Warning') dialog.showMessage( 'Not enough cameras, the app will only be available in drawing mode' ) dialog.exec() self.error_cam.show() self.cam_page.setEnabled(False) self.tabWidget.setCurrentIndex(1) # Если да, то на первую else: self.tabWidget.setCurrentIndex(0) self.camera = QCamera(self.camera) self.view_cam = QCameraViewfinder(self) self.view_cam.setMediaObject(self.camera) self.view_cam.setAutoFillBackground(True) self.camera.setViewfinder(self.view_cam) self.box_lay = QVBoxLayout(self) self.box_lay.addWidget(self.view_cam) self.scrolling.setLayout(self.box_lay) # Запускаем камеру self.camera.start() # Подвязываем кнопку к слоту со снимком self.bt_cam.clicked.connect(self.make_ph) # Можно зумить фотографию self.zoom.valueChanged.connect(self.zoom_pict)
def extract(self): text = self.input_file_to_text() user_vocab = None if (text is None): error = QErrorMessage(self) error.showMessage('Please specify valid source file') return if (self.ui.vocabCheckBox.isChecked()): user_vocab = self.vocab_file_to_set() if (user_vocab is None): error = QErrorMessage(self) error.showMessage('Please specify valid User Vocabulary file') return pair = self.before_extract() if pair is None: return filename = pair[0] write_chunks = pair[1] # with futures.ProcessPoolExecutor(1) as executor: # vocab_future = executor.submit(extract_worker, text, user_vocab, # filename, write_chunks) # vocab_future.add_done_callback(self.after_extract) vocab_future = self.ppool.submit(extract_worker, text, user_vocab, filename, write_chunks) vocab_future.add_done_callback(self.after_extract) logging.debug('returning from extract')
def add_plan(self): """Функция, которая добавляет новые планы""" if self.current_plan.text() == '': self.error_dialog = QErrorMessage() self.error_dialog.showMessage('Вам нужно обязательно ввести что-нибудь в поле.') self.error_dialog.show() return else: plan_text = self.current_plan.text() cursor.execute(f"INSERT INTO plans VALUES (?, ?)", (user_id, plan_text)) data_base.commit() self.list_of_plans.append(self.current_plan.text()) self.display_plans() self.current_plan.setText('')
def showresult(self, edit1, edit2, edit3, edit4, edit5, edit6): self.i1 = int(self.edit1.text()) self.i2 = int(self.edit2.text()) if self.i2 == 0: self.error_dialog = QErrorMessage() self.error_dialog.showMessage('О нет! Деление на ноль!') else: self.i3 = self.i1 + self.i2 self.i5 = self.i1 - self.i2 self.i4 = self.i1 * self.i2 self.i6 = self.i1 / self.i2 self.edit3.setText(str(self.i3)) self.edit4.setText(str(self.i4)) self.edit5.setText(str(self.i5)) self.edit6.setText(str(self.i6))
def segment(self): """Segmentation and phenotyping of IVUS images""" warning = QErrorMessage() warning.setWindowModality(Qt.WindowModal) warning.showMessage( 'Warning: IVUS Phenotyping is currently only supported for 20MHz images. Interpret other images with extreme caution' ) warning.exec_()
def au(self, acc, paw): u = UserManage() u.addUser(acc, paw) er = QErrorMessage(self) er.setWindowTitle("提示") er.showMessage("添加成功!") er.show() self.showAll()
def startMultiplayerTournament(self): self.playerNames = self.tournamentMenuMapper.mapOnlyNames( self.multiplayerTournamentScene) if self.playerNames is None: error_dialog = QErrorMessage() error_dialog.showMessage( "All IDs must differ from each other and cannot be empty.") else: self.view = QtWidgets.QGraphicsView(self.scene) self.view.setSceneRect(90, 90, 1250, 738) self.view.setViewportUpdateMode( QtWidgets.QGraphicsView.NoViewportUpdate) self.view.setInteractive(False) self.setCentralWidget(self.view) self.tm = TournamentManager.Tournament(self.playerNames)
def export_raw(self): if not self.ctx.get_status(): return fname, scheme = QFileDialog.getSaveFileName( self.win, 'Export People Data to CSV', None, "Comma-separated Values Files (*.csv)") if not fname: return if not fname.endswith('.csv'): fname += '.csv' try: with open(fname, 'w') as handle: self.ctx.app_data_manager.export_raw_to_csv(handle) handle.close() except Exception as e: error_dialog = QErrorMessage() error_dialog.showMessage(str(e))
def __init__(self): super(MainWindow, self).__init__() self.setupUi(self) self.cwd = getcwd() self.qe = QErrorMessage(self) self.pale = QPalette() # self.pale.setBrush(self.backgroundRole(), QBrush(QPixmap('./images/kobe3.jpg'))) self.setPalette(self.pale) self.Open_pushButton.clicked.connect(self.Open) self.Project_comboBox.insertItem(0, self.tr('F28')) self.Project_comboBox.insertItem(1, self.tr('JX825')) self.Project_comboBox.insertItem(2, self.tr('JX828')) self.Project_comboBox.insertItem(3, self.tr('JX829')) self.Project_comboBox.insertItem(4, self.tr('JX832')) self.Analysis_pushButton.clicked.connect(self.Analysis)
def readAllSerial(self, returnOutput=False, printOutput=True): if self.serial.is_open: returnString = str(self.serial.read( self.serial.inWaiting())).strip("'").strip("b'") if printOutput: print(returnString) # In case of an error from the arduino: if returnString[:5] == "ERROR:"[:5]: errorMessage = QErrorMessage() errorMessage.showMessage(returnString) if returnOutput: return returnString
def delete_page(self): # предупреждение о тонкостях удаления страниц if self.count != self.maxcount: dop = 'Удалится не текущая страница, а последняя. \n \t Продолжить?' else: dop = 'Удалить страницу?' reply = QMessageBox.question(self, 'Удаление страницы', dop, QMessageBox.Yes | QMessageBox.No, QMessageBox.No) # в случае положительного ответа if reply == QMessageBox.Yes: # проверка, что не удаляется единственная страница, а если удаляется, выводится ошибка if self.maxcount == 1: error = QErrorMessage(self) error.showMessage( 'Ошибка. Осталась всего одна страница. Ее нельзя удалять') return # в файле последней страницы удаляется все содержимое with open("{}.txt".format(self.maxcount), 'w') as f: f.write('') # если пользователь находился на последней странице, а ее удаляют, он переместится на # предыдущую, а если нет, то останется на прежней if self.count == self.maxcount: self.count -= 1 self.maxcount -= 1 with open("{}.txt".format(self.maxcount)) as f: self.note.setText(f.read()) self.count_page.display(self.count) self.count_page_max.display(self.count) else: self.maxcount -= 1 self.count_page.display(self.count) self.count_page_max.display(self.maxcount) with open("page.txt", 'w') as f: f.write(str(self.maxcount)) # установка активности кнопок if self.maxcount == 1: self.button_left_page.setEnabled(False) self.button_right_page.setEnabled(False) elif self.count == 1: self.button_left_page.setEnabled(False) self.button_right_page.setEnabled(True) elif self.count == self.maxcount: self.button_left_page.setEnabled(True) self.button_right_page.setEnabled(False) else: self.button_left_page.setEnabled(True) self.button_right_page.setEnabled(True)
def connect_to_laser(self): logging.info("Looking for COM ports") available_comports = list(serial.tools.list_ports.comports()) self.ui.comboBox.clear() for port in available_comports: self.ui.comboBox.addItem(port.device) self.display_repetition_quantity = True self.display_repetition_frequency = True self.last_transmitted_quantity = -1.0 self.last_transmitted_frequency = -1.0 self.ui.connection_label.setText("Connecting to laser...") self.app.processEvents() try: self.laser_communication_thread = laser_communication.LaserCommunicationThread( self, debug=False) logging.info("Connecting GUI signals") self.ui.stop_button.clicked.connect( self.laser_communication_thread.Stop) self.ui.burst_on_button.clicked.connect( self.laser_communication_thread.BurstOn) self.ui.laser_off_button.clicked.connect( self.laser_communication_thread.LaserOff) self.ui.standby_button.clicked.connect( self.laser_communication_thread.LaserOn) self.ui.toggle_shutter_button.clicked.connect( self.laser_communication_thread.ToggleShutter) self.ui.external_trigger_on_button.clicked.connect( self.laser_communication_thread.ExternalTriggerOn) self.ui.repetition_on_button.clicked.connect( self.laser_communication_thread.RepetitionOn) self.ui.repetition_rate_spinBox.editingFinished.connect( self.repetition_rate_changed) self.set_repetition_rate_signal.connect( self.laser_communication_thread.setRepetitionRate) self.ui.repetition_quantity_spinBox.editingFinished.connect( self.repetition_quantity_changed) self.set_repetition_quantity_signal.connect( self.laser_communication_thread.setRepetitionQuantity) logging.info("Starting laser communication thread.") self.laser_communication_thread.start() except Exception as e: self.error_window = QErrorMessage(self) self.error_window.message = str(e)
def searchF(self, state): @pyqtSlot(list) def Users(users): #print(users) self.model_list.items.clear() for u in users: self.model_list.items.append(u) self.model_list.layoutChanged.emit() f = dict() for k in self.model_table.item.keys(): if self.model_table.item.get(k) != user().get(k) or k in [ 'page', 'limit' ]: f[k] = self.model_table.item.get(k) searchUsers = SearchUser(self.auth, f) #print(f,"searchF "*10) searchUsers.signals.finished.connect( lambda: print("finished searchUser")) searchUsers.signals.hasError.connect(lambda x: QErrorMessage( self.parent).showMessage(str(x) + __name__)) searchUsers.signals.hasResponse.connect(lambda x: print(x, "response")) searchUsers.signals.hasUsers.connect(Users) QThreadPool.globalInstance().start(searchUsers)
def process(self): search_name = self.searchName.text() layer = self.layerCombo.currentLayer() expression = self.fieldExpressionWidget.currentField()[0] priority = self.priorityBox.value() srid = layer.crs().authid() evaluate_directly = self.evaluateCheckBox.isChecked() if self.projectSearch is None: self.projectSearch = self.project_search_model.addSearch(search_name, layer, expression, priority) else: self.projectSearch.edit(search_name, layer.id(), layer.name(), expression, priority, srid) if evaluate_directly: self.progressBar.setMinimum(0) self.progressBar.setMaximum(layer.featureCount()) self.progressBar.show() self.cancelButton.show() ok, message = self.project_finder.recordSearch(self.projectSearch) self.progressBar.hide() self.cancelButton.hide() self.okButton.show() if not ok: QErrorMessage().showMessage(message) return self.close()
def save(self,state): #print(self.model.item) self.saveUser=SaveUser(self.auth,self.model.item) self.saveUser.signals.finished.connect(lambda :print("user finished saving")) self.saveUser.signals.hasError.connect(lambda x:QErrorMessage(self.parent).showMessage(str(x)+__name__)) self.saveUser.signals.hasResponse.connect(lambda x:print(x)) QThreadPool.globalInstance().start(self.saveUser)
def __init__(self, parent=None): super(Dialog, self).__init__(parent) self.openFilesPath = '' self.errorMessageDialog = QErrorMessage(self) frameStyle = QFrame.Sunken | QFrame.Panel self.textLabel = QLabel() self.textLabel.setFrameStyle(frameStyle) self.textButton = QPushButton("Press") self.warningLabel = QLabel() self.warningLabel.setFrameStyle(frameStyle) self.warningButton = QPushButton("Autor") self.textButton.clicked.connect(self.setText) self.warningButton.clicked.connect(self.warningMessage) self.native = QCheckBox() self.native.setText("Use native file dialog.") self.native.setChecked(True) if sys.platform not in ("win32", "darwin"): self.native.hide() layout = QGridLayout() layout.setColumnStretch(1, 1) layout.setColumnMinimumWidth(1, 250) layout.addWidget(self.textButton, 3, 0) layout.addWidget(self.textLabel, 3, 1) self.setLayout(layout) self.setWindowTitle("3b")
def run(self): try: QApplication.setOverrideCursor(Qt.WaitCursor) transform_svds(self.ris_files, self.rois, self.QComboBox_scaling.currentText(), self.output_directory) QApplication.restoreOverrideCursor() self.QMessageBox_finnish = QMessageBox() self.QMessageBox_finnish.setWindowTitle("Finished") self.QMessageBox_finnish.setText("Done.") self.QMessageBox_finnish.exec_() except Exception as e: QApplication.restoreOverrideCursor() self.QErrorMessage = QErrorMessage() self.QErrorMessage.showMessage(str(e))
def generateTriangles(self): self.fill = {} for idx, vert in enumerate(self.vertecies): if self.checkIntersection(vert): box = QErrorMessage(self) box.showMessage("Intersection in one curve is not supported!") return False #cdt = CDT(vert[:-2]) # do not add last point again, poly2tri #cdt #= CDT(vert[:-2]) # do not add last point again, poly2tri #crashes if there is the same point #crashes if there is the same point # twice #cdt.triangulate() #self.fill[idx] = cdt.get_triangles() self.update() return True
def aboutconfig(self): self.aboutconfigVar=readAbout(Path("Client/MainWindow/about.json")) #not this one self.aboutconfigVar.signals.hasError.connect(lambda x:QErrorMessage(self.parent).showMessage(str(x)+__name__)) self.aboutconfigVar.signals.hasAbout.connect(self.icon) self.aboutconfigVar.signals.finished.connect(lambda : print("reading about config")) QThreadPool.globalInstance().start(self.aboutconfigVar)
def export_results_select(self): if not self.ctx.app_data.results: return fname, scheme = QFileDialog.getSaveFileName( self.win, 'Export Allocation to CSV', None, "Comma-separated Values Files (*.csv)") if not fname: return if not fname.endswith('.csv'): fname += '.csv' try: with open(fname, 'w') as handle: a = self.ctx.window.tabs.tab_results.tabs.currentIndex() self.ctx.app_data_manager.export_allocation_to_csv(handle, a) handle.close() except Exception as e: error_dialog = QErrorMessage() error_dialog.showMessage(str(e))
def __init__(self, reference_item): CustomStandardDialog.__init__(self) self.setupUi(self) # Save the input reference item to detect changes self.reference_item = reference_item # Initialize a error dialog that is fed by the workers self.error_dialog = QErrorMessage(self) # Setup threads and worker objects for retrieval of data # from NCBI. Use one thread for the pubmed lookup. self.pmid_thread = QtCore.QThread(self) self.pmid_worker = RetrievePubmedData() self.pmid_worker.moveToThread(self.pmid_thread) # Use a second thread for the querying of non pubmed ids # like DOIs or Pubmed central Ids. Those Ids are translated # to pubmed ids in order to not implement a second parser # for the pubmed central xml format self.id_thread = QtCore.QThread(self) self.id_worker = IdConverter() self.id_worker.moveToThread(self.id_thread) self.connect_workers() # Setup the author table data model self.authorTable = AuthorTable(self) self.authorTableView.setModel(self.authorTable) # Setup items, disable Ok button and restore state self.populate_inputs() self.buttonBox.button(QDialogButtonBox.Save).setEnabled(False) self.setup_connections() self.restore_dialog_geometry()
def use_filter(self, func): if self.flag_open: pil_image = Image.open(self.filename) try: try: args = map(lambda x: x[1], list(self.func_dict[func.__name__].items())) pil_image = func(pil_image, *args) except KeyError: pil_image = func(pil_image) except: QErrorMessage(self).showMessage("Bad filter!") return # ***************** переделать через буфер ***************** # PIL.Image.Image -> QImage pil_image.save("PIL_tmp.jpg") image = QImage("PIL_tmp.jpg") item = QGraphicsPixmapItem(QPixmap.fromImage(image)) self.graphicsView.scene().items().clear() self.graphicsView.scene().addItem(item) self.graphicsView.show() if not self.windowTitle().endswith(' *'): self.setWindowTitle(self.windowTitle() + ' *') self.flag_save = True
def save_dynamic(self): from db_manag import DBmanager from sqlite3 import OperationalError as sqlite3_OperationalError self.data_base = DBmanager(self.settings_way_db, 'valute') try: self.data_base.insert_into_table_dynamic_rate(self.dynamic_req) except sqlite3_OperationalError: self.data_base.create_table_dynamic_rate() self.data_base.insert_into_table_dynamic_rate(self.dynamic_req) self.message_save_data = QMessageBox.information(self, 'Save Data', 'Data saved', QMessageBox.Ok) except AttributeError: self.error_no_data = QErrorMessage(self) self.error_no_data.setWindowTitle('No data') self.error_no_data.showMessage('No data to save') else: self.message_save_data = QMessageBox.information(self, 'Save Data', 'Data saved', QMessageBox.Ok)
def setPropertyForAllObjects(self): selectedPropertyIndices = self.selectedColumns() if self.model().isRowObjects else self.selectedRows() if len(selectedPropertyIndices) != 1: errorDialog = QErrorMessage(self) rowOrColumn = "column" if self.model().isRowObjects else "row" errorDialog.showMessage("Must select a single property " + rowOrColumn + ".") errorDialog.exec_() return try: propertyIndex = selectedPropertyIndices[0] dtype = self.model().propertyType(propertyIndex) if dtype is None: return obj = self.model().objects[0] prop = self.model().properties[propertyIndex] if "Write" not in prop.get('mode', "Read/Write"): return model = ObjectListTableModelQt([obj], [prop], self.model().isRowObjects, False) view = ObjectListTableViewQt(model) dialog = QDialog(self) buttons = QDialogButtonBox(QDialogButtonBox.Ok) buttons.accepted.connect(dialog.accept) buttons.rejected.connect(dialog.reject) vbox = QVBoxLayout(dialog) vbox.addWidget(view) vbox.addWidget(buttons) dialog.setWindowModality(Qt.WindowModal) dialog.exec_() for objectIndex, obj in enumerate(self.model().objects): row = objectIndex if self.model().isRowObjects else propertyIndex col = propertyIndex if self.model().isRowObjects else objectIndex index = self.model().index(row, col) if objectIndex == 0: value = self.model().data(index) else: if prop.get('action', '') == "fileDialog": try: getAttrRecursive(obj, prop['attr'])(value) self.model().dataChanged.emit(index, index) # Tell model to update cell display. except: self.model().setData(index, value) self.model().dataChanged.emit(index, index) # Tell model to update cell display. else: self.model().setData(index, value) self.model().dataChanged.emit(index, index) # Tell model to update cell display. except: pass
def start(mode): # Install message handler for Qt messages qInstallMessageHandler(gui_msg_handler) # Start the Qt main object app = QApplication([]) # Start the bluesky network client client = GuiClient() # Enable HiDPI support (Qt5 only) if QT_VERSION >= 0x050000: app.setAttribute(Qt.AA_UseHighDpiPixmaps) splash = Splash() # Register our custom pan/zoom event for etype in range(1000, 1000 + NUMCUSTOMEVENTS): reg_etype = QEvent.registerEventType(etype) if reg_etype != etype: print(('Warning: Registered event type differs from requested type id (%d != %d)' % (reg_etype, etype))) splash.show() # Install error message handler handler = QErrorMessage.qtHandler() handler.setWindowFlags(Qt.WindowStaysOnTopHint) # Check and set OpenGL capabilities if not QGLFormat.hasOpenGL(): raise RuntimeError('No OpenGL support detected for this system!') else: f = QGLFormat() f.setVersion(3, 3) f.setProfile(QGLFormat.CoreProfile) f.setDoubleBuffer(True) QGLFormat.setDefaultFormat(f) print(('QGLWidget initialized for OpenGL version %d.%d' % (f.majorVersion(), f.minorVersion()))) splash.showMessage('Constructing main window') app.processEvents() win = MainWindow(mode) win.show() splash.showMessage('Done!') app.processEvents() splash.finish(win) # If this instance of the gui is started in client-only mode, show # server selection dialog if mode == 'client': dialog = DiscoveryDialog(win) dialog.show() bs.net.start_discovery() else: client.connect(event_port=bs.settings.event_port, stream_port=bs.settings.stream_port) # Start the Qt main loop app.exec_()
def scan_start(self, event=None): if pathlib.Path(self.filename()).is_dir(): err = QErrorMessage(self) err.setWindowTitle("eDocuments - Error") err.showMessage("The destination is a directory!") return destination1, extension, _, _ = self.backend.process.destination_filename( self.ui.scan_type.currentData().get("cmds"), self.filename() ) destination2, extension, _, _ = self.backend.process.destination_filename( self.ui.scan_type.currentData().get("postprocess", {}), destination1 ) if pathlib.Path(destination1).is_file() or pathlib.Path(destination2).is_file(): msg = QMessageBox(self) msg.setWindowTitle("Scanning...") msg.setText("The destination file already exists") msg.setInformativeText("Do you want to overwrite it?") msg.setStandardButtons( QMessageBox.Ok | QMessageBox.Cancel | QMessageBox.Open) ret = msg.exec() if ret == QMessageBox.Ok: if pathlib.Path(destination1).is_file(): os.unlink(destination1) if pathlib.Path(destination2).is_file(): os.unlink(destination2) self._scan() elif ret == QMessageBox.Open: if pathlib.Path(destination1).is_file(): cmd = edocuments.config.get('open_cmd').split(' ') cmd.append(destination1) call(cmd) if pathlib.Path(destination2).is_file(): cmd = edocuments.config.get('open_cmd').split(' ') cmd.append(destination2) call(cmd) else: self._scan()
def __init__(self, args): super().__init__(args) self.error_msg = QErrorMessage() self.error_msg.setWindowTitle("Starter Kit: Blinkenlights Demo " + config.DEMO_VERSION) signal.signal(signal.SIGINT, self.exit_demo) signal.signal(signal.SIGTERM, self.exit_demo) self.make_gui() self.connect()
def __init__(self, args): super().__init__(args) self.error_msg = QErrorMessage() self.ipcon = IPConnection() signal.signal(signal.SIGINT, self.exit_demo) signal.signal(signal.SIGTERM, self.exit_demo) timer = QTimer(self) timer.setSingleShot(True) timer.timeout.connect(self.connect) timer.start(1)
def __init__(self, videoWidget, subtitleData, parent=None): super().__init__(parent) self._models = defaultdict(self._modelFactory) # path : QStandardItemModel self._current = None self._videoWidget = videoWidget self._subtitleData = subtitleData # avoid unnecessary copies in each addPoint() call self._err = QErrorMessage() self._table = None self._subtitleData.fileChanged.connect(self._fileChanged) self._subtitleData.subtitlesChanged.connect(self._subtitlesChanged) self._subtitleData.subtitlesAdded.connect(self._subtitlesAdded) self._subtitleData.subtitlesRemoved.connect(self._subtitlesRemoved)
def __init__(self): super(Gui, self).__init__([]) self.acdata = ACDataEvent() self.routedata = RouteDataEvent() self.navdb = None self.radarwidget = [] self.command_history = [] self.cmd = '' self.args = [] self.history_pos = 0 self.command_mem = '' self.command_line = '' self.prev_cmdline = '' self.mousedragged = False self.mousepos = (0, 0) self.prevmousepos = (0, 0) self.panzoomchanged = False self.simt = 0.0 # Register our custom pan/zoom event for etype in range(1000, 1000 + NUMEVENTS): reg_etype = QEvent.registerEventType(etype) if reg_etype != etype: print('Warning: Registered event type differs from requested type id (%d != %d)' % (reg_etype, etype)) self.splash = Splash() self.splash.show() # Install error message handler handler = QErrorMessage.qtHandler() handler.setWindowFlags(Qt.WindowStaysOnTopHint) # Check and set OpenGL capabilities if not QGLFormat.hasOpenGL(): raise RuntimeError('No OpenGL support detected for this system!') else: f = QGLFormat() f.setVersion(3, 3) f.setProfile(QGLFormat.CoreProfile) f.setDoubleBuffer(True) QGLFormat.setDefaultFormat(f) print('QGLWidget initialized for OpenGL version %d.%d' % (f.majorVersion(), f.minorVersion())) # Enable HiDPI support (Qt5 only) if QT_VERSION == 5: self.setAttribute(Qt.AA_UseHighDpiPixmaps)
def __init__(self, parent, app): super().__init__() self.app = app self.setupUi(self) self.error_msg = QErrorMessage() self.error_msg.setWindowTitle("Starter Kit: Blinkenlights Demo " + config.DEMO_VERSION) self.slider_frame_rate.valueChanged.connect(self.slider_frame_rate_changed) self.spinbox_frame_rate.valueChanged.connect(self.spinbox_frame_rate_changed) self.button_choose.pressed.connect(self.choose_pressed) self.button_show.pressed.connect(self.show_pressed) self.button_default.pressed.connect(self.default_pressed) self.update_frame_rate_timer = QTimer(self) self.update_frame_rate_timer.timeout.connect(self.update_frame_rate) self.default_pressed()
def __init__(self) : #заглушка qem = QErrorMessage() qem.showMessage('Не удаётся подключиться к Raspberry Pi: Будет подключена локальная камера') qem.exec() self._capturedDevice = cv2.VideoCapture(0)
class ImagesWidget(QWidget, Ui_Images): images = None def __init__(self, parent, app): super().__init__() self.app = app self.setupUi(self) self.error_msg = QErrorMessage() self.error_msg.setWindowTitle("Starter Kit: Blinkenlights Demo " + config.DEMO_VERSION) self.slider_frame_rate.valueChanged.connect(self.slider_frame_rate_changed) self.spinbox_frame_rate.valueChanged.connect(self.spinbox_frame_rate_changed) self.button_choose.pressed.connect(self.choose_pressed) self.button_show.pressed.connect(self.show_pressed) self.button_default.pressed.connect(self.default_pressed) self.update_frame_rate_timer = QTimer(self) self.update_frame_rate_timer.timeout.connect(self.update_frame_rate) self.default_pressed() def start(self): self.images = Images(self.app.ipcon) self.update_frame_rate() self.images.frame_rendered(0) def stop(self): if self.images: self.images.stop_rendering() self.images = None def spinbox_frame_rate_changed(self, frame_rate): self.slider_frame_rate.setValue(frame_rate) self.update_frame_rate_timer.start(100) def slider_frame_rate_changed(self, frame_rate): self.spinbox_frame_rate.setValue(frame_rate) def show_pressed(self): if self.images: files = self.text_edit_files.toPlainText().strip() if len(files) > 0: new_images = files.split('\n') try: self.images.set_new_images(new_images) except Exception as e: self.error_msg.showMessage(str(e)) self.images.frame_prepare_next() self.images.frame_rendered(0) def choose_pressed(self): names, selected_filter = QFileDialog.getOpenFileNames(self, 'Choose Images', QDir.homePath()) for filename in names: self.text_edit_files.append(filename) def default_pressed(self): self.spinbox_frame_rate.setValue(1) def update_frame_rate(self): self.update_frame_rate_timer.stop() config.IMAGES_FRAME_RATE = self.spinbox_frame_rate.value() if self.images: self.images.update_frame_rate()
class Blinkenlights(QApplication): HOST = "localhost" PORT = 4223 ipcon = None projects = [] active_project = None error_msg = None def __init__(self, args): super().__init__(args) self.error_msg = QErrorMessage() self.error_msg.setWindowTitle("Starter Kit: Blinkenlights Demo " + config.DEMO_VERSION) signal.signal(signal.SIGINT, self.exit_demo) signal.signal(signal.SIGTERM, self.exit_demo) self.make_gui() self.connect() def exit_demo(self, signl=None, frme=None): try: self.ipcon.disconnect() self.timer.stop() self.tabs.destroy() except: pass sys.exit() def make_gui(self): self.main = MainWindow(self) self.main.setWindowIcon(QIcon(load_pixmap('starter_kit_blinkenlights_demo-icon.png'))) self.tabs = QTabWidget() widget = QWidget() layout = QVBoxLayout() layout.addWidget(self.tabs) widget.setLayout(layout) self.main.setCentralWidget(widget) self.setup = SetupWidget(self.tabs, self) self.tetris = TetrisWidget(self.tabs, self) self.pong = PongWidget(self.tabs, self) self.fire = FireWidget(self.tabs, self) self.text = TextWidget(self.tabs, self) self.images = ImagesWidget(self.tabs, self) self.rainbow = RainbowWidget(self.tabs, self) self.projects.append(self.setup) self.projects.append(self.tetris) self.projects.append(self.pong) self.projects.append(self.fire) self.projects.append(self.text) self.projects.append(self.images) self.projects.append(self.rainbow) self.tabs.addTab(self.setup, "Setup") self.tabs.addTab(self.tetris, "Tetris") self.tabs.addTab(self.pong, "Pong") self.tabs.addTab(self.fire, "Fire") self.tabs.addTab(self.text, "Text") self.tabs.addTab(self.images, "Images") self.tabs.addTab(self.rainbow, "Rainbow") self.active_project = self.projects[0] self.tabs.currentChanged.connect(self.tab_changed_slot) self.main.setWindowTitle("Starter Kit: Blinkenlights Demo " + config.DEMO_VERSION) self.main.show() def connect(self): config.UID_LED_STRIP_BRICKLET = None self.setup.label_led_strip_found.setText('No') self.setup.label_led_strip_uid.setText('None') config.UID_MULTI_TOUCH_BRICKLET = None self.setup.label_multi_touch_found.setText('No') self.setup.label_multi_touch_uid.setText('None') config.UID_DUAL_BUTTON_BRICKLET = (None, None) self.setup.label_dual_button1_found.setText('No') self.setup.label_dual_button1_uid.setText('None') self.setup.label_dual_button2_found.setText('No') self.setup.label_dual_button2_uid.setText('None') config.UID_PIEZO_SPEAKER_BRICKLET = None self.setup.label_piezo_speaker_found.setText('No') self.setup.label_piezo_speaker_uid.setText('None') config.UID_SEGMENT_DISPLAY_4X7_BRICKLET = None self.setup.label_segment_display_found.setText('No') self.setup.label_segment_display_uid.setText('None') if self.ipcon != None: try: self.ipcon.disconnect() except: pass self.ipcon = IPConnection() host = self.setup.edit_host.text() port = self.setup.spinbox_port.value() try: self.ipcon.connect(host, port) except Error as e: self.error_msg.showMessage('Connection Error: ' + str(e.description) + "<br><br>Brickd installed and running?") return except socket.error as e: self.error_msg.showMessage('Socket error: ' + str(e) + "<br><br>Brickd installed and running?") return self.ipcon.register_callback(IPConnection.CALLBACK_ENUMERATE, self.cb_enumerate) self.ipcon.register_callback(IPConnection.CALLBACK_CONNECTED, self.cb_connected) # Wait for a second to give user visual feedback timer = QTimer(self) timer.setSingleShot(True) timer.timeout.connect(self.ipcon.enumerate) timer.start(250) def tab_changed_slot(self, tabIndex): self.active_project.stop() self.active_project = self.projects[tabIndex] self.active_project.start() def cb_enumerate(self, uid, connected_uid, position, hardware_version, firmware_version, device_identifier, enumeration_type): if enumeration_type == IPConnection.ENUMERATION_TYPE_CONNECTED or \ enumeration_type == IPConnection.ENUMERATION_TYPE_AVAILABLE: if device_identifier == LEDStrip.DEVICE_IDENTIFIER or device_identifier == LEDStripV2.DEVICE_IDENTIFIER: if device_identifier == LEDStripV2.DEVICE_IDENTIFIER: self.setup.label_7.setText('LED Strip V2') config.IS_LED_STRIP_V2 = True else: self.setup.label_7.setText('LED Strip') config.IS_LED_STRIP_V2 = False config.UID_LED_STRIP_BRICKLET = uid self.setup.label_led_strip_found.setText('Yes') self.setup.label_led_strip_uid.setText(uid) elif device_identifier == MultiTouch.DEVICE_IDENTIFIER: config.UID_MULTI_TOUCH_BRICKLET = uid self.setup.label_multi_touch_found.setText('Yes') self.setup.label_multi_touch_uid.setText(uid) elif device_identifier == DualButton.DEVICE_IDENTIFIER: if config.UID_DUAL_BUTTON_BRICKLET[0] == None: config.UID_DUAL_BUTTON_BRICKLET = (uid, None) self.setup.label_dual_button1_found.setText('Yes') self.setup.label_dual_button1_uid.setText(uid) else: config.UID_DUAL_BUTTON_BRICKLET = (config.UID_DUAL_BUTTON_BRICKLET[0], uid) self.setup.label_dual_button2_found.setText('Yes') self.setup.label_dual_button2_uid.setText(uid) elif device_identifier == PiezoSpeaker.DEVICE_IDENTIFIER: config.UID_PIEZO_SPEAKER_BRICKLET = uid self.setup.label_piezo_speaker_found.setText('Yes') self.setup.label_piezo_speaker_uid.setText(uid) elif device_identifier == SegmentDisplay4x7.DEVICE_IDENTIFIER: config.UID_SEGMENT_DISPLAY_4X7_BRICKLET = uid self.setup.label_segment_display_found.setText('Yes') self.setup.label_segment_display_uid.setText(uid) def cb_connected(self, connected_reason): if connected_reason == IPConnection.CONNECT_REASON_AUTO_RECONNECT: while True: try: self.ipcon.enumerate() break except Error as e: self.error_msg.showMessage('Enumerate Error: ' + str(e.description)) time.sleep(1)
class Stepper(PluginBase, Ui_Stepper): qtcb_position_reached = pyqtSignal(int) qtcb_under_voltage = pyqtSignal(int) def __init__(self, *args): PluginBase.__init__(self, BrickStepper, *args) self.setupUi(self) self.stepper = self.device # the firmware version of a Brick can (under common circumstances) not # change during the lifetime of a Brick plugin. therefore, it's okay to # make final decisions based on it here self.has_status_led = self.firmware_version >= (2, 3, 1) self.endis_all(False) self.update_timer = QTimer(self) self.update_timer.timeout.connect(self.update_data) self.new_value = 0 self.update_counter = 0 self.full_brake_time = 0 self.qem = QErrorMessage(self) self.qem.setWindowTitle("Under Voltage") self.decay_widget.hide() self.setting_sync_rect_checkbox = False self.velocity_syncer = SliderSpinSyncer(self.velocity_slider, self.velocity_spin, self.velocity_changed) self.acceleration_syncer = SliderSpinSyncer(self.acceleration_slider, self.acceleration_spin, self.acceleration_changed) self.deceleration_syncer = SliderSpinSyncer(self.deceleration_slider, self.deceleration_spin, self.deceleration_changed) self.decay_syncer = SliderSpinSyncer(self.decay_slider, self.decay_spin, self.decay_changed) self.enable_checkbox.toggled.connect(self.enable_toggled) self.forward_button.clicked.connect(self.forward_clicked) self.stop_button.clicked.connect(self.stop_clicked) self.full_brake_button.clicked.connect(self.full_brake_clicked) self.backward_button.clicked.connect(self.backward_clicked) self.to_button.clicked.connect(self.to_button_clicked) self.steps_button.clicked.connect(self.steps_button_clicked) self.motor_current_button.clicked.connect(self.motor_current_button_clicked) self.minimum_motor_voltage_button.clicked.connect(self.minimum_motor_voltage_button_clicked) self.sync_rect_checkbox.toggled.connect(self.sync_rect_toggled) self.mode_dropbox.currentIndexChanged.connect(self.mode_changed) self.qtcb_position_reached.connect(self.cb_position_reached) self.stepper.register_callback(self.stepper.CALLBACK_POSITION_REACHED, self.qtcb_position_reached.emit) self.qtcb_under_voltage.connect(self.cb_under_voltage) self.stepper.register_callback(self.stepper.CALLBACK_UNDER_VOLTAGE, self.qtcb_under_voltage.emit) self.ste = 0 self.pos = 0 self.current_velocity = 0 self.cur = 0 self.sv = 0 self.ev = 0 self.mv = 0 self.mod = 0 if self.has_status_led: self.status_led_action = QAction('Status LED', self) self.status_led_action.setCheckable(True) self.status_led_action.toggled.connect(lambda checked: self.stepper.enable_status_led() if checked else self.stepper.disable_status_led()) self.set_configs([(0, None, [self.status_led_action])]) else: self.status_led_action = None reset = QAction('Reset', self) reset.triggered.connect(lambda: self.stepper.reset()) self.set_actions([(0, None, [reset])]) def start(self): if self.has_status_led: async_call(self.stepper.is_status_led_enabled, None, self.status_led_action.setChecked, self.increase_error_count) self.update_timer.start(100) self.update_start() def stop(self): self.update_timer.stop() def destroy(self): pass @staticmethod def has_device_identifier(device_identifier): return device_identifier == BrickStepper.DEVICE_IDENTIFIER def cb_position_reached(self, position): self.position_update(position) self.endis_all(True) def disable_list(self, button_list): for button in button_list: button.setEnabled(False) def endis_all(self, value): self.forward_button.setEnabled(value) self.stop_button.setEnabled(value) self.backward_button.setEnabled(value) self.to_button.setEnabled(value) self.steps_button.setEnabled(value) self.full_brake_button.setEnabled(value) def mode_changed(self, index): try: self.stepper.set_step_mode(1 << index) self.mod = 1 << index except ip_connection.Error: return def forward_clicked(self): try: self.stepper.drive_forward() except ip_connection.Error: return self.disable_list([self.to_button, self.steps_button]) def backward_clicked(self): try: self.stepper.drive_backward() except ip_connection.Error: return self.disable_list([self.to_button, self.steps_button]) def stop_clicked(self): try: self.stepper.stop() except ip_connection.Error: return self.endis_all(True) def full_brake_clicked(self): try: self.stepper.full_brake() except ip_connection.Error: return self.endis_all(True) def to_button_clicked(self): drive_to = self.to_spin.value() try: self.stepper.set_target_position(drive_to) except ip_connection.Error: return self.disable_list([self.to_button, self.steps_button, self.forward_button, self.backward_button]) def steps_button_clicked(self): drive_steps = self.steps_spin.value() try: self.stepper.set_steps(drive_steps) except ip_connection.Error: return self.disable_list([self.to_button, self.steps_button, self.forward_button, self.backward_button]) def motor_current_button_clicked(self): qid = QInputDialog(self) qid.setInputMode(QInputDialog.IntInput) qid.setIntMinimum(0) qid.setIntMaximum(2500) qid.setIntStep(100) async_call(self.stepper.get_motor_current, None, qid.setIntValue, self.increase_error_count) qid.intValueSelected.connect(self.motor_current_selected) qid.setLabelText("Choose motor current in mA.") qid.open() def minimum_motor_voltage_button_clicked(self): qid = QInputDialog(self) qid.setInputMode(QInputDialog.IntInput) qid.setIntMinimum(0) qid.setIntMaximum(40000) qid.setIntStep(100) async_call(self.stepper.get_minimum_voltage, None, qid.setIntValue, self.increase_error_count) qid.intValueSelected.connect(self.minimum_motor_voltage_selected) qid.setLabelText("Choose minimum motor voltage in mV.") qid.open() def motor_current_selected(self, value): try: self.stepper.set_motor_current(value) except ip_connection.Error: return def minimum_motor_voltage_selected(self, value): try: self.stepper.set_minimum_voltage(value) except ip_connection.Error: return def cb_under_voltage(self, ov): mv_str = self.minimum_voltage_label.text() ov_str = "%gV" % round(ov/1000.0, 1) if not self.qem.isVisible(): self.qem.showMessage("Under Voltage: Output Voltage of " + ov_str + " is below minimum voltage of " + mv_str, "Stepper_UnderVoltage") def enable_toggled(self, checked): try: if checked: if not self.stepper.is_enabled(): self.endis_all(True) self.stepper.enable() else: if self.stepper.is_enabled(): self.endis_all(False) self.stepper.disable() except ip_connection.Error: return def sync_rect_toggled(self, checked): if not self.setting_sync_rect_checkbox and checked: rc = QMessageBox.warning(get_main_window(), 'Synchronous Rectification', 'If you want to use high speeds (> 10000 steps/s) for a large stepper motor with a ' + 'large inductivity we strongly suggest that you do not enable synchronous rectification. ' + 'Otherwise the Brick may not be able to cope with the load and overheat.', QMessageBox.Ok | QMessageBox.Cancel) if rc != QMessageBox.Ok: self.sync_rect_checkbox.setChecked(False) return try: self.stepper.set_sync_rect(checked) except ip_connection.Error: return self.decay_widget.setVisible(checked) def stack_input_voltage_update(self, sv): sv_str = "%gV" % round(sv/1000.0, 1) self.stack_voltage_label.setText(sv_str) def external_input_voltage_update(self, ev): ev_str = "%gV" % round(ev/1000.0, 1) self.external_voltage_label.setText(ev_str) def minimum_voltage_update(self, mv): mv_str = "%gV" % round(mv/1000.0, 1) self.minimum_voltage_label.setText(mv_str) def maximum_current_update(self, cur): cur_str = "%gA" % round(cur/1000.0, 1) self.maximum_current_label.setText(cur_str) def position_update(self, pos): pos_str = "%d" % pos self.position_label.setText(pos_str) def remaining_steps_update(self, ste): ste_str = "%d" % ste self.remaining_steps_label.setText(ste_str) def current_velocity_update(self, velocity): velocity_str = "%d" % velocity self.current_velocity_label.setText(velocity_str) self.speedometer.set_velocity(velocity) def mode_update(self, mod): if mod == 8: index = 3 elif mod == 4: index = 2 elif mod == 2: index = 1 else: index = 0 self.mode_dropbox.setCurrentIndex(index) def get_max_velocity_async(self, velocity): if not self.velocity_slider.isSliderDown(): if velocity != self.velocity_slider.sliderPosition(): self.velocity_slider.setSliderPosition(velocity) self.velocity_spin.setValue(velocity) def get_speed_ramping_async(self, ramp): acc, dec = ramp if not self.acceleration_slider.isSliderDown() and \ not self.deceleration_slider.isSliderDown(): if acc != self.acceleration_slider.sliderPosition(): self.acceleration_slider.setSliderPosition(acc) self.acceleration_spin.setValue(acc) if dec != self.deceleration_slider.sliderPosition(): self.deceleration_slider.setSliderPosition(dec) self.deceleration_spin.setValue(dec) def get_decay_async(self, decay): if not self.decay_slider.isSliderDown(): if decay != self.decay_slider.sliderPosition(): self.decay_slider.setSliderPosition(decay) self.decay_spin.setValue(decay) def is_enabled_async(self, enabled): if enabled: if not self.enable_checkbox.isChecked(): self.endis_all(True) self.enable_checkbox.setChecked(True) else: if self.enable_checkbox.isChecked(): self.endis_all(False) self.enable_checkbox.setChecked(False) def is_sync_rect_async(self, sync_rect): self.setting_sync_rect_checkbox = True self.sync_rect_checkbox.setChecked(sync_rect) self.setting_sync_rect_checkbox = False def update_start(self): async_call(self.stepper.get_max_velocity, None, self.get_max_velocity_async, self.increase_error_count) async_call(self.stepper.get_speed_ramping, None, self.get_speed_ramping_async, self.increase_error_count) async_call(self.stepper.get_decay, None, self.get_decay_async, self.increase_error_count) async_call(self.stepper.is_enabled, None, self.is_enabled_async, self.increase_error_count) async_call(self.stepper.is_sync_rect, None, self.is_sync_rect_async, self.increase_error_count) def update_data(self): async_call(self.stepper.get_remaining_steps, None, self.remaining_steps_update, self.increase_error_count) async_call(self.stepper.get_current_position, None, self.position_update, self.increase_error_count) async_call(self.stepper.get_current_velocity, None, self.current_velocity_update, self.increase_error_count) self.update_counter += 1 if self.update_counter % 10 == 0: async_call(self.stepper.get_motor_current, None, self.maximum_current_update, self.increase_error_count) async_call(self.stepper.get_stack_input_voltage, None, self.stack_input_voltage_update, self.increase_error_count) async_call(self.stepper.get_external_input_voltage, None, self.external_input_voltage_update, self.increase_error_count) async_call(self.stepper.get_minimum_voltage, None, self.minimum_voltage_update, self.increase_error_count) async_call(self.stepper.get_step_mode, None, self.mode_update, self.increase_error_count) def velocity_changed(self, value): try: self.stepper.set_max_velocity(value) except ip_connection.Error: return def acceleration_changed(self, value): dec = self.deceleration_spin.value() try: self.stepper.set_speed_ramping(value, dec) except ip_connection.Error: return def deceleration_changed(self, value): acc = self.acceleration_slider.value() try: self.stepper.set_speed_ramping(acc, value) except ip_connection.Error: return def decay_changed(self, value): try: self.stepper.set_decay(value) except ip_connection.Error: return
class SilentStepper(PluginBase, Ui_SilentStepper): qtcb_position_reached = pyqtSignal(int) qtcb_under_voltage = pyqtSignal(int) def __init__(self, *args): PluginBase.__init__(self, BrickSilentStepper, *args) self.setupUi(self) self.silent_stepper = self.device self.endis_all(False) self.update_timer = QTimer(self) self.update_timer.timeout.connect(self.update_data) self.speedometer = SpeedoMeter() self.vertical_layout_right.insertWidget(5, self.speedometer) self.new_value = 0 self.update_counter = 0 self.full_brake_time = 0 self.qem = QErrorMessage(self) self.qem.setWindowTitle("Under Voltage") self.velocity_syncer = SliderSpinSyncer(self.velocity_slider, self.velocity_spin, self.velocity_changed) self.acceleration_syncer = SliderSpinSyncer(self.acceleration_slider, self.acceleration_spin, self.acceleration_changed) self.deceleration_syncer = SliderSpinSyncer(self.deceleration_slider, self.deceleration_spin, self.deceleration_changed) self.enable_checkbox.stateChanged.connect(self.enable_state_changed) self.forward_button.clicked.connect(self.forward_clicked) self.stop_button.clicked.connect(self.stop_clicked) self.full_brake_button.clicked.connect(self.full_brake_clicked) self.backward_button.clicked.connect(self.backward_clicked) self.to_button.clicked.connect(self.to_button_clicked) self.steps_button.clicked.connect(self.steps_button_clicked) self.motor_current_button.clicked.connect(self.motor_current_button_clicked) self.minimum_motor_voltage_button.clicked.connect(self.minimum_motor_voltage_button_clicked) self.qtcb_position_reached.connect(self.cb_position_reached) self.silent_stepper.register_callback(self.silent_stepper.CALLBACK_POSITION_REACHED, self.qtcb_position_reached.emit) self.qtcb_under_voltage.connect(self.cb_under_voltage) self.silent_stepper.register_callback(self.silent_stepper.CALLBACK_UNDER_VOLTAGE, self.qtcb_under_voltage.emit) # Step Configuration self.step_resolution_dropbox.currentIndexChanged.connect(self.step_configuration_changed) self.interpolate_checkbox.stateChanged.connect(self.step_configuration_changed) # Basic Configuration self.standstill_current_spin.valueChanged.connect(self.basic_configuration_changed) self.motor_run_current_spin.valueChanged.connect(self.basic_configuration_changed) self.standstill_delay_time_spin.valueChanged.connect(self.basic_configuration_changed) self.power_down_time_spin.valueChanged.connect(self.basic_configuration_changed) self.stealth_threshold_spin.valueChanged.connect(self.basic_configuration_changed) self.coolstep_threashold_spin.valueChanged.connect(self.basic_configuration_changed) self.classic_threshold_spin.valueChanged.connect(self.basic_configuration_changed) self.high_velocity_chopper_mode_checkbox.stateChanged.connect(self.basic_configuration_changed) # Spreadcycle Configuration self.slow_decay_duration_spin.valueChanged.connect(self.spreadcycle_configuration_changed) self.enable_random_slow_decay_checkbox.stateChanged.connect(self.spreadcycle_configuration_changed) self.fast_decay_duration_spin.valueChanged.connect(self.spreadcycle_configuration_changed) self.hysteresis_start_value_spin.valueChanged.connect(self.spreadcycle_configuration_changed) self.hysteresis_end_value_spin.valueChanged.connect(self.spreadcycle_configuration_changed) self.sine_wave_offset_spin.valueChanged.connect(self.spreadcycle_configuration_changed) self.chopper_mode_combo.currentIndexChanged.connect(self.spreadcycle_configuration_changed) self.comparator_blank_time_combo.currentIndexChanged.connect(self.spreadcycle_configuration_changed) self.fast_decay_without_comparator_checkbox.stateChanged.connect(self.spreadcycle_configuration_changed) # Stealth Configuration self.enable_stealth_checkbox.stateChanged.connect(self.stealth_configuration_changed) self.amplitude_spin.valueChanged.connect(self.stealth_configuration_changed) self.gradient_spin.valueChanged.connect(self.stealth_configuration_changed) self.enable_autoscale_checkbox.stateChanged.connect(self.stealth_configuration_changed) self.force_symmetric_checkbox.stateChanged.connect(self.stealth_configuration_changed) self.freewheel_mode_combo.currentIndexChanged.connect(self.stealth_configuration_changed) # Coolstep Configuration self.minimum_stallguard_value_spin.valueChanged.connect(self.coolstep_configuration_changed) self.maximum_stallguard_value_spin.valueChanged.connect(self.coolstep_configuration_changed) self.current_up_step_width_combo.currentIndexChanged.connect(self.coolstep_configuration_changed) self.current_down_step_width_combo.currentIndexChanged.connect(self.coolstep_configuration_changed) self.minimum_current_combo.currentIndexChanged.connect(self.coolstep_configuration_changed) self.stallguard_threshold_value_spin.valueChanged.connect(self.coolstep_configuration_changed) self.stallguard_mode_combo.currentIndexChanged.connect(self.coolstep_configuration_changed) # Misc Configuration self.disable_short_to_ground_protection_checkbox.stateChanged.connect(self.misc_configuration_changed) self.synchronize_phase_frequency_spin.valueChanged.connect(self.misc_configuration_changed) self.ste = 0 self.pos = 0 self.current_velocity = 0 self.cur = 0 self.sv = 0 self.ev = 0 self.mv = 0 self.mod = 0 self.status_led_action = QAction('Status LED', self) self.status_led_action.setCheckable(True) self.status_led_action.toggled.connect(lambda checked: self.silent_stepper.enable_status_led() if checked else self.silent_stepper.disable_status_led()) self.set_configs([(0, None, [self.status_led_action])]) reset = QAction('Reset', self) reset.triggered.connect(lambda: self.silent_stepper.reset()) self.set_actions([(0, None, [reset])]) def start(self): async_call(self.silent_stepper.is_status_led_enabled, None, self.status_led_action.setChecked, self.increase_error_count) self.update_timer.start(100) self.update_start() def stop(self): self.update_timer.stop() def destroy(self): pass @staticmethod def has_device_identifier(device_identifier): return device_identifier == BrickSilentStepper.DEVICE_IDENTIFIER def cb_position_reached(self, position): self.position_update(position) self.endis_all(True) def disable_list(self, button_list): for button in button_list: button.setEnabled(False) def endis_all(self, value): self.forward_button.setEnabled(value) self.stop_button.setEnabled(value) self.backward_button.setEnabled(value) self.to_button.setEnabled(value) self.steps_button.setEnabled(value) self.full_brake_button.setEnabled(value) def step_configuration_changed(self, _): step_resolution = self.step_resolution_dropbox.currentIndex() interpolation = self.interpolate_checkbox.isChecked() try: self.silent_stepper.set_step_configuration(step_resolution, interpolation) except ip_connection.Error: return def basic_configuration_changed(self, _): standstill_current = self.standstill_current_spin.value() motor_run_current = self.motor_run_current_spin.value() standstill_delay_time = self.standstill_delay_time_spin.value() power_down_time = self.power_down_time_spin.value() stealth_threshold = self.stealth_threshold_spin.value() coolstep_threshold = self.coolstep_threashold_spin.value() classic_threshold = self.classic_threshold_spin.value() high_velocity_chopper_mode = self.high_velocity_chopper_mode_checkbox.isChecked() try: self.silent_stepper.set_basic_configuration(standstill_current, motor_run_current, standstill_delay_time, power_down_time, stealth_threshold, coolstep_threshold, classic_threshold, high_velocity_chopper_mode) except ip_connection.Error: return def spreadcycle_configuration_changed(self, _): slow_decay_duration = self.slow_decay_duration_spin.value() enable_random_slow_decay = self.enable_random_slow_decay_checkbox.isChecked() fast_decay_duration = self.fast_decay_duration_spin.value() hysteresis_start_value = self.hysteresis_start_value_spin.value() hysteresis_end_value = self.hysteresis_end_value_spin.value() sine_wave_offset = self.sine_wave_offset_spin.value() chopper_mode = self.chopper_mode_combo.currentIndex() comparator_blank_time = self.comparator_blank_time_combo.currentIndex() fast_decay_without_comparator = self.fast_decay_without_comparator_checkbox.isChecked() try: self.silent_stepper.set_spreadcycle_configuration(slow_decay_duration, enable_random_slow_decay, fast_decay_duration, hysteresis_start_value, hysteresis_end_value, sine_wave_offset, chopper_mode, comparator_blank_time, fast_decay_without_comparator) except ip_connection.Error: return def stealth_configuration_changed(self, _): enable_stealth = self.enable_stealth_checkbox.isChecked() amplitude = self.amplitude_spin.value() gradient = self.gradient_spin.value() enable_autoscale = self.enable_autoscale_checkbox.isChecked() force_symmetric = self.force_symmetric_checkbox.isChecked() freewheel_mode = self.freewheel_mode_combo.currentIndex() try: self.silent_stepper.set_stealth_configuration(enable_stealth, amplitude, gradient, enable_autoscale, force_symmetric, freewheel_mode) except ip_connection.Error: return def coolstep_configuration_changed(self, _): minimum_stallguard_value = self.minimum_stallguard_value_spin.value() maximum_stallguard_value = self.maximum_stallguard_value_spin.value() current_up_step_width = self.current_up_step_width_combo.currentIndex() current_down_step_width = self.current_down_step_width_combo.currentIndex() minimum_current = self.minimum_current_combo.currentIndex() stallguard_threshold_value = self.stallguard_threshold_value_spin.value() stallguard_mode = self.stallguard_mode_combo.currentIndex() try: self.silent_stepper.set_coolstep_configuration(minimum_stallguard_value, maximum_stallguard_value, current_up_step_width, current_down_step_width, minimum_current, stallguard_threshold_value, stallguard_mode) except ip_connection.Error: return def misc_configuration_changed(self, _): disable_short_to_ground_protection = self.disable_short_to_ground_protection_checkbox.isChecked() synchronize_phase_frequency = self.synchronize_phase_frequency_spin.value() try: self.silent_stepper.set_misc_configuration(disable_short_to_ground_protection, synchronize_phase_frequency) except ip_connection.Error: return def forward_clicked(self): try: self.silent_stepper.drive_forward() except ip_connection.Error: return self.disable_list([self.to_button, self.steps_button]) def backward_clicked(self): try: self.silent_stepper.drive_backward() except ip_connection.Error: return self.disable_list([self.to_button, self.steps_button]) def stop_clicked(self): try: self.silent_stepper.stop() except ip_connection.Error: return self.endis_all(True) def full_brake_clicked(self): try: self.silent_stepper.full_brake() except ip_connection.Error: return self.endis_all(True) def to_button_clicked(self): drive_to = self.to_spin.value() try: self.silent_stepper.set_target_position(drive_to) except ip_connection.Error: return self.disable_list([self.to_button, self.steps_button, self.forward_button, self.backward_button]) def steps_button_clicked(self): drive_steps = self.steps_spin.value() try: self.silent_stepper.set_steps(drive_steps) except ip_connection.Error: return self.disable_list([self.to_button, self.steps_button, self.forward_button, self.backward_button]) def motor_current_button_clicked(self): qid = QInputDialog(self) qid.setInputMode(QInputDialog.IntInput) qid.setIntMinimum(360) qid.setIntMaximum(1640) qid.setIntStep(100) async_call(self.silent_stepper.get_motor_current, None, qid.setIntValue, self.increase_error_count) qid.intValueSelected.connect(self.motor_current_selected) qid.setLabelText("Choose motor current in mA.") qid.open() def minimum_motor_voltage_button_clicked(self): qid = QInputDialog(self) qid.setInputMode(QInputDialog.IntInput) qid.setIntMinimum(0) qid.setIntMaximum(40000) qid.setIntStep(100) async_call(self.silent_stepper.get_minimum_voltage, None, qid.setIntValue, self.increase_error_count) qid.intValueSelected.connect(self.minimum_motor_voltage_selected) qid.setLabelText("Choose minimum motor voltage in mV.") qid.open() def motor_current_selected(self, value): try: self.silent_stepper.set_motor_current(value) except ip_connection.Error: return def minimum_motor_voltage_selected(self, value): try: self.silent_stepper.set_minimum_voltage(value) except ip_connection.Error: return def cb_under_voltage(self, ov): mv_str = self.minimum_voltage_label.text() ov_str = "%gV" % round(ov/1000.0, 1) if not self.qem.isVisible(): self.qem.showMessage("Under Voltage: Output Voltage of " + ov_str + " is below minimum voltage of " + mv_str, "SilentStepper_UnderVoltage") def enable_state_changed(self, state): try: if state == Qt.Checked: self.endis_all(True) self.silent_stepper.enable() elif state == Qt.Unchecked: self.endis_all(False) self.silent_stepper.disable() except ip_connection.Error: return def stack_input_voltage_update(self, sv): sv_str = "%gV" % round(sv/1000.0, 1) self.stack_voltage_label.setText(sv_str) def external_input_voltage_update(self, ev): ev_str = "%gV" % round(ev/1000.0, 1) self.external_voltage_label.setText(ev_str) def minimum_voltage_update(self, mv): mv_str = "%gV" % round(mv/1000.0, 1) self.minimum_voltage_label.setText(mv_str) def maximum_current_update(self, cur): cur_str = "%gA" % round(cur/1000.0, 1) self.maximum_current_label.setText(cur_str) def position_update(self, pos): pos_str = "%d" % pos self.position_label.setText(pos_str) def remaining_steps_update(self, ste): ste_str = "%d" % ste self.remaining_steps_label.setText(ste_str) def driver_status_update(self, update): if update.open_load == 0: self.status_open_load.setText('No') elif update.open_load == 1: self.status_open_load.setText('Phase A') elif update.open_load == 2: self.status_open_load.setText('Phase B') elif update.open_load == 3: self.status_open_load.setText('Phase A and B') else: self.status_open_load.setText('Unknown') if update.short_to_ground == 0: self.status_short_to_ground.setText('No') elif update.short_to_ground == 1: self.status_short_to_ground.setText('Phase A') elif update.short_to_ground == 2: self.status_short_to_ground.setText('Phase B') elif update.short_to_ground == 3: self.status_short_to_ground.setText('Phase A and B') else: self.status_short_to_ground.setText('Unknown') if update.over_temperature == 0: self.status_over_temperature.setText('No') elif update.over_temperature == 1: self.status_over_temperature.setText('<font color=yellow>Warning</font>') elif update.over_temperature == 2: self.status_over_temperature.setText('<font color=red>Limit</font>') if update.motor_stalled: self.status_motor_stalled.setText('Yes') else: self.status_motor_stalled.setText('No') self.status_actual_motor_current.setText(str(update.actual_motor_current)) if update.full_step_active: self.status_full_step_active.setText('Yes') else: self.status_full_step_active.setText('No') self.status_stallguard_result.setText(str(update.stallguard_result)) self.status_stealth_voltage_amplitude.setText(str(update.stealth_voltage_amplitude)) def get_max_velocity_async(self, velocity): if not self.velocity_slider.isSliderDown(): if velocity != self.velocity_slider.sliderPosition(): self.velocity_slider.setSliderPosition(velocity) self.velocity_spin.setValue(velocity) def get_speed_ramping_async(self, ramp): acc, dec = ramp if not self.acceleration_slider.isSliderDown() and \ not self.deceleration_slider.isSliderDown(): if acc != self.acceleration_slider.sliderPosition(): self.acceleration_slider.setSliderPosition(acc) self.acceleration_spin.setValue(acc) if dec != self.deceleration_slider.sliderPosition(): self.deceleration_slider.setSliderPosition(dec) self.deceleration_spin.setValue(dec) def is_enabled_async(self, enabled): if enabled: if not self.enable_checkbox.isChecked(): self.endis_all(True) self.enable_checkbox.blockSignals(True) self.enable_checkbox.setChecked(True) self.enable_checkbox.blockSignals(False) else: if self.enable_checkbox.isChecked(): self.endis_all(False) self.enable_checkbox.blockSignals(True) self.enable_checkbox.setChecked(False) self.enable_checkbox.blockSignals(False) def get_step_configuration_async(self, conf): self.step_resolution_dropbox.blockSignals(True) self.step_resolution_dropbox.setCurrentIndex(conf.step_resolution) self.step_resolution_dropbox.blockSignals(False) self.interpolate_checkbox.blockSignals(True) self.interpolate_checkbox.setChecked(conf.interpolation) self.interpolate_checkbox.blockSignals(False) def get_basic_configuration_async(self, conf): self.standstill_current_spin.blockSignals(True) self.standstill_current_spin.setValue(conf.standstill_current) self.standstill_current_spin.blockSignals(False) self.motor_run_current_spin.blockSignals(True) self.motor_run_current_spin.setValue(conf.motor_run_current) self.motor_run_current_spin.blockSignals(False) self.standstill_delay_time_spin.blockSignals(True) self.standstill_delay_time_spin.setValue(conf.standstill_delay_time) self.standstill_delay_time_spin.blockSignals(False) self.power_down_time_spin.blockSignals(True) self.power_down_time_spin.setValue(conf.power_down_time) self.power_down_time_spin.blockSignals(False) self.stealth_threshold_spin.blockSignals(True) self.stealth_threshold_spin.setValue(conf.stealth_threshold) self.stealth_threshold_spin.blockSignals(False) self.coolstep_threashold_spin.blockSignals(True) self.coolstep_threashold_spin.setValue(conf.coolstep_threshold) self.coolstep_threashold_spin.blockSignals(False) self.classic_threshold_spin.blockSignals(True) self.classic_threshold_spin.setValue(conf.classic_threshold) self.classic_threshold_spin.blockSignals(False) self.high_velocity_chopper_mode_checkbox.blockSignals(True) self.high_velocity_chopper_mode_checkbox.setChecked(conf.high_velocity_chopper_mode) self.high_velocity_chopper_mode_checkbox.blockSignals(False) def get_spreadcycle_configuration_async(self, conf): self.slow_decay_duration_spin.blockSignals(True) self.slow_decay_duration_spin.setValue(conf.slow_decay_duration) self.slow_decay_duration_spin.blockSignals(False) self.enable_random_slow_decay_checkbox.blockSignals(True) self.enable_random_slow_decay_checkbox.setChecked(conf.enable_random_slow_decay) self.enable_random_slow_decay_checkbox.blockSignals(False) self.fast_decay_duration_spin.blockSignals(True) self.fast_decay_duration_spin.setValue(conf.fast_decay_duration) self.fast_decay_duration_spin.blockSignals(False) self.hysteresis_start_value_spin.blockSignals(True) self.hysteresis_start_value_spin.setValue(conf.hysteresis_start_value) self.hysteresis_start_value_spin.blockSignals(False) self.hysteresis_end_value_spin.blockSignals(True) self.hysteresis_end_value_spin.setValue(conf.hysteresis_end_value) self.hysteresis_end_value_spin.blockSignals(False) self.sine_wave_offset_spin.blockSignals(True) self.sine_wave_offset_spin.setValue(conf.sine_wave_offset) self.sine_wave_offset_spin.blockSignals(False) self.chopper_mode_combo.blockSignals(True) self.chopper_mode_combo.setCurrentIndex(conf.chopper_mode) self.chopper_mode_combo.blockSignals(False) self.standstill_current_spin.blockSignals(True) self.comparator_blank_time_combo.setCurrentIndex(conf.comparator_blank_time) self.standstill_current_spin.blockSignals(False) self.fast_decay_without_comparator_checkbox.blockSignals(True) self.fast_decay_without_comparator_checkbox.setChecked(conf.fast_decay_without_comparator) self.fast_decay_without_comparator_checkbox.blockSignals(False) def get_stealth_configuration_async(self, conf): self.enable_stealth_checkbox.blockSignals(True) self.enable_stealth_checkbox.setChecked(conf.enable_stealth) self.enable_stealth_checkbox.blockSignals(False) self.amplitude_spin.blockSignals(True) self.amplitude_spin.setValue(conf.amplitude) self.amplitude_spin.blockSignals(False) self.gradient_spin.blockSignals(True) self.gradient_spin.setValue(conf.gradient) self.gradient_spin.blockSignals(False) self.enable_autoscale_checkbox.blockSignals(True) self.enable_autoscale_checkbox.setChecked(conf.enable_autoscale) self.enable_autoscale_checkbox.blockSignals(False) self.force_symmetric_checkbox.blockSignals(True) self.force_symmetric_checkbox.setChecked(conf.force_symmetric) self.force_symmetric_checkbox.blockSignals(False) self.freewheel_mode_combo.blockSignals(True) self.freewheel_mode_combo.setCurrentIndex(conf.freewheel_mode) self.freewheel_mode_combo.blockSignals(False) def get_coolstep_configuration_async(self, conf): self.minimum_stallguard_value_spin.blockSignals(True) self.minimum_stallguard_value_spin.setValue(conf.minimum_stallguard_value) self.minimum_stallguard_value_spin.blockSignals(False) self.maximum_stallguard_value_spin.blockSignals(True) self.maximum_stallguard_value_spin.setValue(conf.maximum_stallguard_value) self.maximum_stallguard_value_spin.blockSignals(False) self.current_up_step_width_combo.blockSignals(True) self.current_up_step_width_combo.setCurrentIndex(conf.current_up_step_width) self.current_up_step_width_combo.blockSignals(False) self.current_down_step_width_combo.blockSignals(True) self.current_down_step_width_combo.setCurrentIndex(conf.current_down_step_width) self.current_down_step_width_combo.blockSignals(False) self.minimum_current_combo.blockSignals(True) self.minimum_current_combo.setCurrentIndex(conf.minimum_current) self.minimum_current_combo.blockSignals(False) self.stallguard_threshold_value_spin.blockSignals(True) self.stallguard_threshold_value_spin.setValue(conf.stallguard_threshold_value) self.stallguard_threshold_value_spin.blockSignals(False) self.stallguard_mode_combo.blockSignals(True) self.stallguard_mode_combo.setCurrentIndex(conf.stallguard_mode) self.stallguard_mode_combo.blockSignals(False) def get_misc_configuration_async(self, conf): self.disable_short_to_ground_protection_checkbox.blockSignals(True) self.disable_short_to_ground_protection_checkbox.setChecked(conf.disable_short_to_ground_protection) self.disable_short_to_ground_protection_checkbox.blockSignals(False) self.synchronize_phase_frequency_spin.blockSignals(True) self.synchronize_phase_frequency_spin.setValue(conf.synchronize_phase_frequency) self.synchronize_phase_frequency_spin.blockSignals(False) def update_start(self): async_call(self.silent_stepper.get_max_velocity, None, self.get_max_velocity_async, self.increase_error_count) async_call(self.silent_stepper.get_speed_ramping, None, self.get_speed_ramping_async, self.increase_error_count) async_call(self.silent_stepper.is_enabled, None, self.is_enabled_async, self.increase_error_count) async_call(self.silent_stepper.get_step_configuration, None, self.get_step_configuration_async, self.increase_error_count) async_call(self.silent_stepper.get_basic_configuration, None, self.get_basic_configuration_async, self.increase_error_count) async_call(self.silent_stepper.get_spreadcycle_configuration, None, self.get_spreadcycle_configuration_async, self.increase_error_count) async_call(self.silent_stepper.get_stealth_configuration, None, self.get_stealth_configuration_async, self.increase_error_count) async_call(self.silent_stepper.get_coolstep_configuration, None, self.get_coolstep_configuration_async, self.increase_error_count) async_call(self.silent_stepper.get_misc_configuration, None, self.get_misc_configuration_async, self.increase_error_count) def update_data(self): async_call(self.silent_stepper.get_remaining_steps, None, self.remaining_steps_update, self.increase_error_count) async_call(self.silent_stepper.get_current_position, None, self.position_update, self.increase_error_count) async_call(self.silent_stepper.get_current_velocity, None, self.speedometer.set_velocity, self.increase_error_count) self.update_counter += 1 if self.update_counter % 10 == 0: async_call(self.silent_stepper.get_motor_current, None, self.maximum_current_update, self.increase_error_count) async_call(self.silent_stepper.get_stack_input_voltage, None, self.stack_input_voltage_update, self.increase_error_count) async_call(self.silent_stepper.get_external_input_voltage, None, self.external_input_voltage_update, self.increase_error_count) async_call(self.silent_stepper.get_minimum_voltage, None, self.minimum_voltage_update, self.increase_error_count) async_call(self.silent_stepper.get_driver_status, None, self.driver_status_update, self.increase_error_count) def velocity_changed(self, value): try: self.silent_stepper.set_max_velocity(value) except ip_connection.Error: return def acceleration_changed(self, value): dec = self.deceleration_spin.value() try: self.silent_stepper.set_speed_ramping(value, dec) except ip_connection.Error: return def deceleration_changed(self, value): acc = self.acceleration_slider.value() try: self.silent_stepper.set_speed_ramping(acc, value) except ip_connection.Error: return
def __init__(self, *args): PluginBase.__init__(self, BrickStepper, *args) self.setupUi(self) self.stepper = self.device # the firmware version of a Brick can (under common circumstances) not # change during the lifetime of a Brick plugin. therefore, it's okay to # make final decisions based on it here self.has_status_led = self.firmware_version >= (2, 3, 1) self.endis_all(False) self.update_timer = QTimer(self) self.update_timer.timeout.connect(self.update_data) self.new_value = 0 self.update_counter = 0 self.full_brake_time = 0 self.qem = QErrorMessage(self) self.qem.setWindowTitle("Under Voltage") self.decay_widget.hide() self.setting_sync_rect_checkbox = False self.velocity_syncer = SliderSpinSyncer(self.velocity_slider, self.velocity_spin, self.velocity_changed) self.acceleration_syncer = SliderSpinSyncer(self.acceleration_slider, self.acceleration_spin, self.acceleration_changed) self.deceleration_syncer = SliderSpinSyncer(self.deceleration_slider, self.deceleration_spin, self.deceleration_changed) self.decay_syncer = SliderSpinSyncer(self.decay_slider, self.decay_spin, self.decay_changed) self.enable_checkbox.toggled.connect(self.enable_toggled) self.forward_button.clicked.connect(self.forward_clicked) self.stop_button.clicked.connect(self.stop_clicked) self.full_brake_button.clicked.connect(self.full_brake_clicked) self.backward_button.clicked.connect(self.backward_clicked) self.to_button.clicked.connect(self.to_button_clicked) self.steps_button.clicked.connect(self.steps_button_clicked) self.motor_current_button.clicked.connect(self.motor_current_button_clicked) self.minimum_motor_voltage_button.clicked.connect(self.minimum_motor_voltage_button_clicked) self.sync_rect_checkbox.toggled.connect(self.sync_rect_toggled) self.mode_dropbox.currentIndexChanged.connect(self.mode_changed) self.qtcb_position_reached.connect(self.cb_position_reached) self.stepper.register_callback(self.stepper.CALLBACK_POSITION_REACHED, self.qtcb_position_reached.emit) self.qtcb_under_voltage.connect(self.cb_under_voltage) self.stepper.register_callback(self.stepper.CALLBACK_UNDER_VOLTAGE, self.qtcb_under_voltage.emit) self.ste = 0 self.pos = 0 self.current_velocity = 0 self.cur = 0 self.sv = 0 self.ev = 0 self.mv = 0 self.mod = 0 if self.has_status_led: self.status_led_action = QAction('Status LED', self) self.status_led_action.setCheckable(True) self.status_led_action.toggled.connect(lambda checked: self.stepper.enable_status_led() if checked else self.stepper.disable_status_led()) self.set_configs([(0, None, [self.status_led_action])]) else: self.status_led_action = None reset = QAction('Reset', self) reset.triggered.connect(lambda: self.stepper.reset()) self.set_actions([(0, None, [reset])])
def connectLocalCamera(self) : self.close() qem = QErrorMessage() qem.showMessage('Не удаётся подключиться к Raspberry Pi: Будет подключена локальная камера') qem.exec() self._capturedDevice = cv2.VideoCapture(0)
def __init__(self, navdb): super(Gui, self).__init__([]) self.acdata = ACDataEvent() self.navdb = navdb self.radarwidget = [] self.command_history = [] self.cmdargs = [] self.history_pos = 0 self.command_mem = '' self.command_line = '' self.prev_cmdline = '' self.simevent_target = 0 self.mousedragged = False self.mousepos = (0, 0) self.prevmousepos = (0, 0) self.panzoomchanged = False self.simt = 0.0 # Register our custom pan/zoom event for etype in [PanZoomEventType, ACDataEventType, SimInfoEventType, StackTextEventType, ShowDialogEventType, DisplayFlagEventType, RouteDataEventType, DisplayShapeEventType, SimQuitEventType, AMANEventType]: reg_etype = QEvent.registerEventType(etype) if reg_etype != etype: print('Warning: Registered event type differs from requested type id (%d != %d)' % (reg_etype, etype)) self.splash = Splash() self.splash.show() self.splash.showMessage('Constructing main window') self.processEvents() # Install error message handler handler = QErrorMessage.qtHandler() handler.setWindowFlags(Qt.WindowStaysOnTopHint) # Check and set OpenGL capabilities if not QGLFormat.hasOpenGL(): raise RuntimeError('No OpenGL support detected for this system!') else: f = QGLFormat() f.setVersion(3, 3) f.setProfile(QGLFormat.CoreProfile) f.setDoubleBuffer(True) QGLFormat.setDefaultFormat(f) print('QGLWidget initialized for OpenGL version %d.%d' % (f.majorVersion(), f.minorVersion())) # Create the main window and related widgets self.radarwidget = RadarWidget(navdb) self.win = MainWindow(self, self.radarwidget) self.nd = ND(shareWidget=self.radarwidget) #self.aman = AMANDisplay(shareWidget=self.radarwidget) # Enable HiDPI support (Qt5 only) if QT_VERSION == 5: self.setAttribute(Qt.AA_UseHighDpiPixmaps) timer = QTimer(self) timer.timeout.connect(self.radarwidget.updateGL) timer.timeout.connect(self.nd.updateGL) #timer.timeout.connect(self.aman.updateGL) timer.start(50)
class Synchronizer(Tool): def __init__(self, videoWidget, subtitleData, parent=None): super().__init__(parent) self._models = defaultdict(self._modelFactory) # path : QStandardItemModel self._current = None self._videoWidget = videoWidget self._subtitleData = subtitleData # avoid unnecessary copies in each addPoint() call self._err = QErrorMessage() self._table = None self._subtitleData.fileChanged.connect(self._fileChanged) self._subtitleData.subtitlesChanged.connect(self._subtitlesChanged) self._subtitleData.subtitlesAdded.connect(self._subtitlesAdded) self._subtitleData.subtitlesRemoved.connect(self._subtitlesRemoved) @property def name(self): return _("Synchronize") def setContent(self, widget): path = widget.filePath model = self._models[path] data = self._subtitleData.data(widget.filePath) self._current = _CurrentData(data, model, widget) if self._table is None: # e.g. when switched from file list self.clear() self._table = self._makeTable(model) self.layout().addWidget(self._table, stretch=1) self.layout().addWidget(_Controls(self), stretch=0) else: self._table.setModel(model) self._updateRmButtons() def clear(self): super().clear() self._table = None def remove(self, path): if path in self._models: del self._models[path] def setTopLevelWindow(self): self.raise_() self.activateWindow() def apply(self): syncpoints = _syncPoints(self._current.model) if len(syncpoints) == 0: return ts = TimeSync(self._current.data.subtitles) # in-place sync ts.sync(syncpoints) command = ChangeData(self._current.editor.filePath, self._current.data, _("Subtitles synchronization")) self._subtitleData.execute(command) @pyqtSlot() def addPoint(self): rows = self._current.editor.selectedRows() newStart = self._videoWidget.position if len(rows) == 0 or newStart is None: self._err.showMessage(_("Select a subtitle and position in current video first.")) return # row and sub reflect the same subtitle, but we need both for different things row = rows[0] sub = self._current.data.subtitles[row] # Don't add the same subtitle or the same sync time twice if any(row == point.subNo or newStart == point.start for point in _syncPoints(self._current.model)): self._err.showMessage(_("Can't repeat synchronization points")) return if sub.fps != newStart.fps: self._err.showMessage(_("Subtitle and video have different framerates (%(sub)s vs" "%(vid)s") % dict(sub=sub.fps, vid=newStart.fps)) return delta = sub.end - sub.start newEnd = newStart + delta startItem, endItem, textItem = createRow(sub, newStart, newEnd) subNoItem = QStandardItem(str(row)) subNoItem.setEditable(False) textItem.setEditable(False) rmItem = QStandardItem("") self._current.model.appendRow([subNoItem, startItem, endItem, textItem, rmItem]) self._rmButton(self._table, rmItem) def removeSelected(self): indices = self._table.selectedIndexes() if len(indices) > 0: rows = list(set([index.row() for index in indices])) rows.sort(reverse=True) for row in rows: self.removeRow(row) if self._current.model.rowCount() > rows[-1]: self._table.selectRow(rows[-1]) else: self._table.selectRow(self._current.model.rowCount() - 1) @pyqtSlot(int) def removeRow(self, no): self._current.model.removeRow(no) def keyPressEvent(self, keyEvent): if keyEvent.key() == Qt.Key_Delete: self.removeSelected() else: super().keyPressEvent(keyEvent) def _makeTable(self, model): table = QTableView(self) table.setModel(model) table.hideColumn(0) table.setShowGrid(False) subListDelegate = SubListItemDelegate() table.setItemDelegateForColumn(1, subListDelegate) table.setItemDelegateForColumn(2, subListDelegate) table.horizontalHeader().setSectionResizeMode(3, QHeaderView.Stretch) table.horizontalHeader().setSectionResizeMode(4, QHeaderView.ResizeToContents) return table def _modelFactory(self): model = QStandardItemModel(0, 5, self) model.setHorizontalHeaderLabels([_("No."), _("New begin"), _("New end"), _("Subtitle"), ""]) return model def _rmButton(self, table, item): rmButton = QPushButton(QIcon.fromTheme("list-remove"), "") rmButton.setFlat(True) table.setIndexWidget(item.index(), rmButton) rmButton.clicked.connect(lambda _, i=item: self.removeRow(i.row())) def _updateRmButtons(self): if self._table is None: # safety check return for row in range(self._current.model.rowCount()): item = self._current.model.item(row, 4) self._rmButton(self._table, item) def _fileChanged(self, path): model = self._models.get(path) if model is None: return subtitles = self._subtitleData.subtitles(path) for row in range(model.rowCount()): subNo = _subNo(model, row) sub = subtitles[subNo] # clear model when things don't match pretty badly if subNo >= len(subtitles): model.removeRows(0, model.rowCount()) return _setText(sub.text, model, row) def _subtitlesChanged(self, path, subNos): model = self._models.get(path) if model is None: return subtitles = self._subtitleData.subtitles(path) for no in subNos: sub = subtitles[no] row = _findRow(no, model) if row is not None: _setText(sub.text, model, row) def _subtitlesAdded(self, path, subNos): """When subtitle is added, all syncPoints greater or equal than a new subtitle are incremented.""" def action(current, count, model, row): _setSubNo(current + count, model, row) def count(current, nos): ret = 0 for no in nos: if current >= no: ret += 1 # consider: current = 0, nos = [0, 1, 2, 3] # in that case, current should be prepended by all nos current += 1 return ret self._changeSubNos(path, subNos, count, action) def _subtitlesRemoved(self, path, subNos): """When subtitle is removed, all syncPoints greater than removed subtitle are decremented. SyncPoint equal to removed subtitle is also removed.""" def action(current, count, model, row): if count.equal > 0: model.removeRow(row) else: _setSubNo(current - count.greater_equal, model, row) def count(current, nos): return _GtEqCount(current, nos) self._changeSubNos(path, subNos, count, action) def _changeSubNos(self, path, subNos, count, action, reverse=False): """Implementation of subs add/removal handling. Args: path: file path associated with model on which work is done subNos: list of added/removed subtitle numbers count: function which accepts current sync point's subtitle number and subNos and returns anything based on these values action: action performed for each of sync point's subtitle number. Accepts current SyncPoint.subNo, count result, model and row: def action(current, count, model, row) """ model = self._models.get(path) if model is None: return syncPoints = _syncPoints(model) syncSubNos = [p.subNo for p in syncPoints] syncSubNos.sort() if len(syncSubNos) == 0: return for current in syncSubNos: row = _findRow(current, model) action(current, count(current, subNos), model, row)
def __init__(self, *args): PluginBase.__init__(self, BrickSilentStepper, *args) self.setupUi(self) self.silent_stepper = self.device self.endis_all(False) self.update_timer = QTimer(self) self.update_timer.timeout.connect(self.update_data) self.speedometer = SpeedoMeter() self.vertical_layout_right.insertWidget(5, self.speedometer) self.new_value = 0 self.update_counter = 0 self.full_brake_time = 0 self.qem = QErrorMessage(self) self.qem.setWindowTitle("Under Voltage") self.velocity_syncer = SliderSpinSyncer(self.velocity_slider, self.velocity_spin, self.velocity_changed) self.acceleration_syncer = SliderSpinSyncer(self.acceleration_slider, self.acceleration_spin, self.acceleration_changed) self.deceleration_syncer = SliderSpinSyncer(self.deceleration_slider, self.deceleration_spin, self.deceleration_changed) self.enable_checkbox.stateChanged.connect(self.enable_state_changed) self.forward_button.clicked.connect(self.forward_clicked) self.stop_button.clicked.connect(self.stop_clicked) self.full_brake_button.clicked.connect(self.full_brake_clicked) self.backward_button.clicked.connect(self.backward_clicked) self.to_button.clicked.connect(self.to_button_clicked) self.steps_button.clicked.connect(self.steps_button_clicked) self.motor_current_button.clicked.connect(self.motor_current_button_clicked) self.minimum_motor_voltage_button.clicked.connect(self.minimum_motor_voltage_button_clicked) self.qtcb_position_reached.connect(self.cb_position_reached) self.silent_stepper.register_callback(self.silent_stepper.CALLBACK_POSITION_REACHED, self.qtcb_position_reached.emit) self.qtcb_under_voltage.connect(self.cb_under_voltage) self.silent_stepper.register_callback(self.silent_stepper.CALLBACK_UNDER_VOLTAGE, self.qtcb_under_voltage.emit) # Step Configuration self.step_resolution_dropbox.currentIndexChanged.connect(self.step_configuration_changed) self.interpolate_checkbox.stateChanged.connect(self.step_configuration_changed) # Basic Configuration self.standstill_current_spin.valueChanged.connect(self.basic_configuration_changed) self.motor_run_current_spin.valueChanged.connect(self.basic_configuration_changed) self.standstill_delay_time_spin.valueChanged.connect(self.basic_configuration_changed) self.power_down_time_spin.valueChanged.connect(self.basic_configuration_changed) self.stealth_threshold_spin.valueChanged.connect(self.basic_configuration_changed) self.coolstep_threashold_spin.valueChanged.connect(self.basic_configuration_changed) self.classic_threshold_spin.valueChanged.connect(self.basic_configuration_changed) self.high_velocity_chopper_mode_checkbox.stateChanged.connect(self.basic_configuration_changed) # Spreadcycle Configuration self.slow_decay_duration_spin.valueChanged.connect(self.spreadcycle_configuration_changed) self.enable_random_slow_decay_checkbox.stateChanged.connect(self.spreadcycle_configuration_changed) self.fast_decay_duration_spin.valueChanged.connect(self.spreadcycle_configuration_changed) self.hysteresis_start_value_spin.valueChanged.connect(self.spreadcycle_configuration_changed) self.hysteresis_end_value_spin.valueChanged.connect(self.spreadcycle_configuration_changed) self.sine_wave_offset_spin.valueChanged.connect(self.spreadcycle_configuration_changed) self.chopper_mode_combo.currentIndexChanged.connect(self.spreadcycle_configuration_changed) self.comparator_blank_time_combo.currentIndexChanged.connect(self.spreadcycle_configuration_changed) self.fast_decay_without_comparator_checkbox.stateChanged.connect(self.spreadcycle_configuration_changed) # Stealth Configuration self.enable_stealth_checkbox.stateChanged.connect(self.stealth_configuration_changed) self.amplitude_spin.valueChanged.connect(self.stealth_configuration_changed) self.gradient_spin.valueChanged.connect(self.stealth_configuration_changed) self.enable_autoscale_checkbox.stateChanged.connect(self.stealth_configuration_changed) self.force_symmetric_checkbox.stateChanged.connect(self.stealth_configuration_changed) self.freewheel_mode_combo.currentIndexChanged.connect(self.stealth_configuration_changed) # Coolstep Configuration self.minimum_stallguard_value_spin.valueChanged.connect(self.coolstep_configuration_changed) self.maximum_stallguard_value_spin.valueChanged.connect(self.coolstep_configuration_changed) self.current_up_step_width_combo.currentIndexChanged.connect(self.coolstep_configuration_changed) self.current_down_step_width_combo.currentIndexChanged.connect(self.coolstep_configuration_changed) self.minimum_current_combo.currentIndexChanged.connect(self.coolstep_configuration_changed) self.stallguard_threshold_value_spin.valueChanged.connect(self.coolstep_configuration_changed) self.stallguard_mode_combo.currentIndexChanged.connect(self.coolstep_configuration_changed) # Misc Configuration self.disable_short_to_ground_protection_checkbox.stateChanged.connect(self.misc_configuration_changed) self.synchronize_phase_frequency_spin.valueChanged.connect(self.misc_configuration_changed) self.ste = 0 self.pos = 0 self.current_velocity = 0 self.cur = 0 self.sv = 0 self.ev = 0 self.mv = 0 self.mod = 0 self.status_led_action = QAction('Status LED', self) self.status_led_action.setCheckable(True) self.status_led_action.toggled.connect(lambda checked: self.silent_stepper.enable_status_led() if checked else self.silent_stepper.disable_status_led()) self.set_configs([(0, None, [self.status_led_action])]) reset = QAction('Reset', self) reset.triggered.connect(lambda: self.silent_stepper.reset()) self.set_actions([(0, None, [reset])])
def view3d(self): viewer = "osgviewer" # look for viewer in the standard path result = distutils.spawn.find_executable(viewer) if result == None: app_path = os.path.split(os.path.abspath(sys.argv[0]))[0] viewer = os.path.abspath(app_path + "/OpenSceneGraph/bin/osgviewer") viewerexe = os.path.abspath(app_path + "/OpenSceneGraph/bin/osgviewer.exe") print "testing for " + viewer + " or " + viewerexe result = os.path.isfile(viewer) or os.path.isfile(viewerexe) if not result: error = QErrorMessage(self) error.showMessage( "Cannot find " + viewer + " in path. Perhaps it needs to be installed?" ) return madfile = self.fileroot + ".mad" if not os.path.exists(madfile): error = QErrorMessage(self) error.showMessage( "No '.mad' file ... please save your design with a file name." ) return if not self.isClean(): error = QErrorMessage(self) error.showMessage( "The design has been modified. You must <b>Build</b> it before viewing the 3d structure." ) return acfile = self.fileroot + ".ac" if not os.path.exists(acfile): error = QErrorMessage(self) error.showMessage( "Design needs to be 'built'; click ok to continue." ) #self.build_fast() return madtime = os.path.getmtime(madfile) actime = os.path.getmtime(acfile) if madtime > actime: error = QErrorMessage(self) error.showMessage( "Design needs to be 'built'; click ok to continue." ) #self.build_fast() return command = [] command.append(viewer) command.append("--window") command.append("50") command.append("50") command.append("800") command.append("600") command.append(self.fileroot + ".ac") pid = subprocess.Popen(command).pid print "spawned osgviewer with pid = " + str(pid)
def __init__(self, parent=None): super(Dialog, self).__init__(parent) self.openFilesPath = '' self.errorMessageDialog = QErrorMessage(self) frameStyle = QFrame.Sunken | QFrame.Panel self.integerLabel = QLabel() self.integerLabel.setFrameStyle(frameStyle) self.integerButton = QPushButton("QInputDialog.get&Int()") self.doubleLabel = QLabel() self.doubleLabel.setFrameStyle(frameStyle) self.doubleButton = QPushButton("QInputDialog.get&Double()") self.itemLabel = QLabel() self.itemLabel.setFrameStyle(frameStyle) self.itemButton = QPushButton("QInputDialog.getIte&m()") self.textLabel = QLabel() self.textLabel.setFrameStyle(frameStyle) self.textButton = QPushButton("QInputDialog.get&Text()") self.colorLabel = QLabel() self.colorLabel.setFrameStyle(frameStyle) self.colorButton = QPushButton("QColorDialog.get&Color()") self.fontLabel = QLabel() self.fontLabel.setFrameStyle(frameStyle) self.fontButton = QPushButton("QFontDialog.get&Font()") self.directoryLabel = QLabel() self.directoryLabel.setFrameStyle(frameStyle) self.directoryButton = QPushButton("QFileDialog.getE&xistingDirectory()") self.openFileNameLabel = QLabel() self.openFileNameLabel.setFrameStyle(frameStyle) self.openFileNameButton = QPushButton("QFileDialog.get&OpenFileName()") self.openFileNamesLabel = QLabel() self.openFileNamesLabel.setFrameStyle(frameStyle) self.openFileNamesButton = QPushButton("QFileDialog.&getOpenFileNames()") self.saveFileNameLabel = QLabel() self.saveFileNameLabel.setFrameStyle(frameStyle) self.saveFileNameButton = QPushButton("QFileDialog.get&SaveFileName()") self.criticalLabel = QLabel() self.criticalLabel.setFrameStyle(frameStyle) self.criticalButton = QPushButton("QMessageBox.critica&l()") self.informationLabel = QLabel() self.informationLabel.setFrameStyle(frameStyle) self.informationButton = QPushButton("QMessageBox.i&nformation()") self.questionLabel = QLabel() self.questionLabel.setFrameStyle(frameStyle) self.questionButton = QPushButton("QMessageBox.&question()") self.warningLabel = QLabel() self.warningLabel.setFrameStyle(frameStyle) self.warningButton = QPushButton("QMessageBox.&warning()") self.errorLabel = QLabel() self.errorLabel.setFrameStyle(frameStyle) self.errorButton = QPushButton("QErrorMessage.show&M&essage()") self.integerButton.clicked.connect(self.setInteger) self.doubleButton.clicked.connect(self.setDouble) self.itemButton.clicked.connect(self.setItem) self.textButton.clicked.connect(self.setText) self.colorButton.clicked.connect(self.setColor) self.fontButton.clicked.connect(self.setFont) self.directoryButton.clicked.connect(self.setExistingDirectory) self.openFileNameButton.clicked.connect(self.setOpenFileName) self.openFileNamesButton.clicked.connect(self.setOpenFileNames) self.saveFileNameButton.clicked.connect(self.setSaveFileName) self.criticalButton.clicked.connect(self.criticalMessage) self.informationButton.clicked.connect(self.informationMessage) self.questionButton.clicked.connect(self.questionMessage) self.warningButton.clicked.connect(self.warningMessage) self.errorButton.clicked.connect(self.errorMessage) self.native = QCheckBox() self.native.setText("Use native file dialog.") self.native.setChecked(True) if sys.platform not in ("win32", "darwin"): self.native.hide() layout = QGridLayout() layout.setColumnStretch(1, 1) layout.setColumnMinimumWidth(1, 250) layout.addWidget(self.integerButton, 0, 0) layout.addWidget(self.integerLabel, 0, 1) layout.addWidget(self.doubleButton, 1, 0) layout.addWidget(self.doubleLabel, 1, 1) layout.addWidget(self.itemButton, 2, 0) layout.addWidget(self.itemLabel, 2, 1) layout.addWidget(self.textButton, 3, 0) layout.addWidget(self.textLabel, 3, 1) layout.addWidget(self.colorButton, 4, 0) layout.addWidget(self.colorLabel, 4, 1) layout.addWidget(self.fontButton, 5, 0) layout.addWidget(self.fontLabel, 5, 1) layout.addWidget(self.directoryButton, 6, 0) layout.addWidget(self.directoryLabel, 6, 1) layout.addWidget(self.openFileNameButton, 7, 0) layout.addWidget(self.openFileNameLabel, 7, 1) layout.addWidget(self.openFileNamesButton, 8, 0) layout.addWidget(self.openFileNamesLabel, 8, 1) layout.addWidget(self.saveFileNameButton, 9, 0) layout.addWidget(self.saveFileNameLabel, 9, 1) layout.addWidget(self.criticalButton, 10, 0) layout.addWidget(self.criticalLabel, 10, 1) layout.addWidget(self.informationButton, 11, 0) layout.addWidget(self.informationLabel, 11, 1) layout.addWidget(self.questionButton, 12, 0) layout.addWidget(self.questionLabel, 12, 1) layout.addWidget(self.warningButton, 13, 0) layout.addWidget(self.warningLabel, 13, 1) layout.addWidget(self.errorButton, 14, 0) layout.addWidget(self.errorLabel, 14, 1) layout.addWidget(self.native, 15, 0) self.setLayout(layout) self.setWindowTitle("Standard Dialogs")
class WeatherStation(QApplication): HOST = "localhost" PORT = 4223 ipcon = None lcd = None al = None al_v2 = None al_v3 = None hum = None hum_v2 = None baro = None baro_v2 = None projects = [] active_project = None error_msg = None def __init__(self, args): super().__init__(args) self.error_msg = QErrorMessage() self.ipcon = IPConnection() signal.signal(signal.SIGINT, self.exit_demo) signal.signal(signal.SIGTERM, self.exit_demo) timer = QTimer(self) timer.setSingleShot(True) timer.timeout.connect(self.connect) timer.start(1) def exit_demo(self, signl=None, frme=None): try: self.ipcon.disconnect() self.timer.stop() self.tabs.destroy() except: pass sys.exit() def open_gui(self): self.main = MainWindow(self) self.main.setFixedSize(730, 430) self.main.setWindowIcon(QIcon(load_pixmap('starter_kit_weather_station_demo-icon.png'))) self.tabs = QTabWidget() widget = QWidget() layout = QVBoxLayout() layout.addWidget(self.tabs) widget.setLayout(layout) self.main.setCentralWidget(widget) self.projects.append(ProjectEnvDisplay(self.tabs, self)) self.projects.append(ProjectStatistics(self.tabs, self)) self.tabs.addTab(self.projects[0], "Display Environment Measurements") self.tabs.addTab(self.projects[1], "Show Statistics with Button Control") self.active_project = self.projects[0] self.tabs.currentChanged.connect(self.tabChangedSlot) self.main.setWindowTitle("Starter Kit: Weather Station Demo " + DEMO_VERSION) self.main.show() def connect(self): try: self.ipcon.connect(WeatherStation.HOST, WeatherStation.PORT) except Error as e: self.error_msg.showMessage('Connection Error: ' + str(e.description) + "\nBrickd installed and running?") return except socket.error as e: self.error_msg.showMessage('Socket error: ' + str(e) + "\nBrickd installed and running?") return self.ipcon.register_callback(IPConnection.CALLBACK_ENUMERATE, self.cb_enumerate) self.ipcon.register_callback(IPConnection.CALLBACK_CONNECTED, self.cb_connected) try: self.ipcon.enumerate() except Error as e: self.error_msg.showMessage('Enumerate Error: ' + str(e.description)) return self.open_gui() def tabChangedSlot(self, tabIndex): if self.lcd is not None: self.lcd.clear_display() self.active_project = self.projects[tabIndex] def cb_illuminance(self, illuminance): for p in self.projects: p.update_illuminance(illuminance/10.0) def cb_illuminance_v2(self, illuminance): for p in self.projects: p.update_illuminance(illuminance/100.0) def cb_illuminance_v3(self, illuminance): for p in self.projects: p.update_illuminance(illuminance/100.0) def cb_humidity(self, humidity): for p in self.projects: p.update_humidity(humidity/10.0) def cb_humidity_v2(self, humidity): for p in self.projects: p.update_humidity(humidity/100.0) def cb_air_pressure(self, air_pressure): for p in self.projects: p.update_air_pressure(air_pressure/1000.0) try: temperature = self.baro.get_chip_temperature() except Error as e: print('Could not get temperature: ' + str(e.description)) return for p in self.projects: p.update_temperature(temperature/100.0) def cb_air_pressure_v2(self, air_pressure): for p in self.projects: p.update_air_pressure(air_pressure/1000.0) try: temperature = self.baro_v2.get_temperature() except Error as e: print('Could not get temperature: ' + str(e.description)) return for p in self.projects: p.update_temperature(temperature/100.0) def configure_custom_chars(self): c = [[0x00 for x in range(8)] for y in range(8)] c[0] = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff] c[1] = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff] c[2] = [0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff] c[3] = [0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff] c[4] = [0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff] c[5] = [0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff] c[6] = [0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff] c[7] = [0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff] for i in range(len(c)): self.lcd.set_custom_character(i, c[i]); def cb_button_pressed(self, button): for p in self.projects: p.button_pressed(button) def cb_enumerate(self, uid, connected_uid, position, hardware_version, firmware_version, device_identifier, enumeration_type): if enumeration_type == IPConnection.ENUMERATION_TYPE_CONNECTED or \ enumeration_type == IPConnection.ENUMERATION_TYPE_AVAILABLE: if device_identifier == BrickletLCD20x4.DEVICE_IDENTIFIER: try: self.lcd = BrickletLCD20x4(uid, self.ipcon) self.lcd.clear_display() self.lcd.backlight_on() self.lcd.register_callback(self.lcd.CALLBACK_BUTTON_PRESSED, self.cb_button_pressed) self.configure_custom_chars() except Error as e: self.error_msg.showMessage('LCD 20x4 init failed: ' + str(e.description)) self.lcd = None elif device_identifier == BrickletAmbientLight.DEVICE_IDENTIFIER: try: self.al = BrickletAmbientLight(uid, self.ipcon) self.al.set_illuminance_callback_period(1000) self.al.register_callback(self.al.CALLBACK_ILLUMINANCE, self.cb_illuminance) except Error as e: self.error_msg.showMessage('Ambient Light init failed: ' + str(e.description)) self.al = None elif device_identifier == BrickletAmbientLightV2.DEVICE_IDENTIFIER: try: self.al_v2 = BrickletAmbientLightV2(uid, self.ipcon) self.al_v2.set_configuration(self.al_v2.ILLUMINANCE_RANGE_64000LUX, self.al_v2.INTEGRATION_TIME_200MS) self.al_v2.set_illuminance_callback_period(1000) self.al_v2.register_callback(self.al_v2.CALLBACK_ILLUMINANCE, self.cb_illuminance_v2) except Error as e: self.error_msg.showMessage('Ambient Light 2.0 init failed: ' + str(e.description)) self.al_v2 = None elif device_identifier == BrickletAmbientLightV3.DEVICE_IDENTIFIER: try: self.al_v3 = BrickletAmbientLightV3(uid, self.ipcon) self.al_v3.set_illuminance_callback_configuration(1000, False, 'x', 0, 0) self.al_v3.register_callback(self.al_v3.CALLBACK_ILLUMINANCE, self.cb_illuminance_v3) except Error as e: self.error_msg.showMessage('Ambient Light 3.0 init failed: ' + str(e.description)) self.al_v3 = None elif device_identifier == BrickletHumidity.DEVICE_IDENTIFIER: try: self.hum = BrickletHumidity(uid, self.ipcon) self.hum.set_humidity_callback_period(1000) self.hum.register_callback(self.hum.CALLBACK_HUMIDITY, self.cb_humidity) except Error as e: self.error_msg.showMessage('Humidity init failed: ' + str(e.description)) self.hum = None elif device_identifier == BrickletHumidityV2.DEVICE_IDENTIFIER: try: self.hum_v2 = BrickletHumidityV2(uid, self.ipcon) self.hum_v2.set_humidity_callback_configuration(1000, True, 'x', 0, 0) self.hum_v2.register_callback(self.hum_v2.CALLBACK_HUMIDITY, self.cb_humidity_v2) except Error as e: self.error_msg.showMessage('Humidity 2.0 init failed: ' + str(e.description)) self.hum_v2 = None elif device_identifier == BrickletBarometer.DEVICE_IDENTIFIER: try: self.baro = BrickletBarometer(uid, self.ipcon) self.baro.set_air_pressure_callback_period(1000) self.baro.register_callback(self.baro.CALLBACK_AIR_PRESSURE, self.cb_air_pressure) except Error as e: self.error_msg.showMessage('Barometer init failed: ' + str(e.description)) self.baro = None elif device_identifier == BrickletBarometerV2.DEVICE_IDENTIFIER: try: self.baro_v2 = BrickletBarometerV2(uid, self.ipcon) self.baro_v2.set_air_pressure_callback_configuration(1000, False, 'x', 0, 0) self.baro_v2.register_callback(self.baro_v2.CALLBACK_AIR_PRESSURE, self.cb_air_pressure_v2) except Error as e: self.error_msg.showMessage('Barometer 2.0 init failed: ' + str(e.description)) self.baro_v2 = None def cb_connected(self, connected_reason): if connected_reason == IPConnection.CONNECT_REASON_AUTO_RECONNECT: while True: try: self.ipcon.enumerate() break except Error as e: self.error_msg.showMessage('Enumerate Error: ' + str(e.description)) time.sleep(1)
def on_scan_error(self, error): print('Error: %s' % error) err = QErrorMessage(self) err.setWindowTitle("eDocuments - scan error") err.showMessage(error)
class Dialog(QDialog): MESSAGE = "<p>Message boxes have a caption, a text, and up to three " \ "buttons, each with standard or custom texts.</p>" \ "<p>Click a button to close the message box. Pressing the Esc " \ "button will activate the detected escape button (if any).</p>" def __init__(self, parent=None): super(Dialog, self).__init__(parent) self.openFilesPath = '' self.errorMessageDialog = QErrorMessage(self) frameStyle = QFrame.Sunken | QFrame.Panel self.integerLabel = QLabel() self.integerLabel.setFrameStyle(frameStyle) self.integerButton = QPushButton("QInputDialog.get&Int()") self.doubleLabel = QLabel() self.doubleLabel.setFrameStyle(frameStyle) self.doubleButton = QPushButton("QInputDialog.get&Double()") self.itemLabel = QLabel() self.itemLabel.setFrameStyle(frameStyle) self.itemButton = QPushButton("QInputDialog.getIte&m()") self.textLabel = QLabel() self.textLabel.setFrameStyle(frameStyle) self.textButton = QPushButton("QInputDialog.get&Text()") self.colorLabel = QLabel() self.colorLabel.setFrameStyle(frameStyle) self.colorButton = QPushButton("QColorDialog.get&Color()") self.fontLabel = QLabel() self.fontLabel.setFrameStyle(frameStyle) self.fontButton = QPushButton("QFontDialog.get&Font()") self.directoryLabel = QLabel() self.directoryLabel.setFrameStyle(frameStyle) self.directoryButton = QPushButton("QFileDialog.getE&xistingDirectory()") self.openFileNameLabel = QLabel() self.openFileNameLabel.setFrameStyle(frameStyle) self.openFileNameButton = QPushButton("QFileDialog.get&OpenFileName()") self.openFileNamesLabel = QLabel() self.openFileNamesLabel.setFrameStyle(frameStyle) self.openFileNamesButton = QPushButton("QFileDialog.&getOpenFileNames()") self.saveFileNameLabel = QLabel() self.saveFileNameLabel.setFrameStyle(frameStyle) self.saveFileNameButton = QPushButton("QFileDialog.get&SaveFileName()") self.criticalLabel = QLabel() self.criticalLabel.setFrameStyle(frameStyle) self.criticalButton = QPushButton("QMessageBox.critica&l()") self.informationLabel = QLabel() self.informationLabel.setFrameStyle(frameStyle) self.informationButton = QPushButton("QMessageBox.i&nformation()") self.questionLabel = QLabel() self.questionLabel.setFrameStyle(frameStyle) self.questionButton = QPushButton("QMessageBox.&question()") self.warningLabel = QLabel() self.warningLabel.setFrameStyle(frameStyle) self.warningButton = QPushButton("QMessageBox.&warning()") self.errorLabel = QLabel() self.errorLabel.setFrameStyle(frameStyle) self.errorButton = QPushButton("QErrorMessage.show&M&essage()") self.integerButton.clicked.connect(self.setInteger) self.doubleButton.clicked.connect(self.setDouble) self.itemButton.clicked.connect(self.setItem) self.textButton.clicked.connect(self.setText) self.colorButton.clicked.connect(self.setColor) self.fontButton.clicked.connect(self.setFont) self.directoryButton.clicked.connect(self.setExistingDirectory) self.openFileNameButton.clicked.connect(self.setOpenFileName) self.openFileNamesButton.clicked.connect(self.setOpenFileNames) self.saveFileNameButton.clicked.connect(self.setSaveFileName) self.criticalButton.clicked.connect(self.criticalMessage) self.informationButton.clicked.connect(self.informationMessage) self.questionButton.clicked.connect(self.questionMessage) self.warningButton.clicked.connect(self.warningMessage) self.errorButton.clicked.connect(self.errorMessage) self.native = QCheckBox() self.native.setText("Use native file dialog.") self.native.setChecked(True) if sys.platform not in ("win32", "darwin"): self.native.hide() layout = QGridLayout() layout.setColumnStretch(1, 1) layout.setColumnMinimumWidth(1, 250) layout.addWidget(self.integerButton, 0, 0) layout.addWidget(self.integerLabel, 0, 1) layout.addWidget(self.doubleButton, 1, 0) layout.addWidget(self.doubleLabel, 1, 1) layout.addWidget(self.itemButton, 2, 0) layout.addWidget(self.itemLabel, 2, 1) layout.addWidget(self.textButton, 3, 0) layout.addWidget(self.textLabel, 3, 1) layout.addWidget(self.colorButton, 4, 0) layout.addWidget(self.colorLabel, 4, 1) layout.addWidget(self.fontButton, 5, 0) layout.addWidget(self.fontLabel, 5, 1) layout.addWidget(self.directoryButton, 6, 0) layout.addWidget(self.directoryLabel, 6, 1) layout.addWidget(self.openFileNameButton, 7, 0) layout.addWidget(self.openFileNameLabel, 7, 1) layout.addWidget(self.openFileNamesButton, 8, 0) layout.addWidget(self.openFileNamesLabel, 8, 1) layout.addWidget(self.saveFileNameButton, 9, 0) layout.addWidget(self.saveFileNameLabel, 9, 1) layout.addWidget(self.criticalButton, 10, 0) layout.addWidget(self.criticalLabel, 10, 1) layout.addWidget(self.informationButton, 11, 0) layout.addWidget(self.informationLabel, 11, 1) layout.addWidget(self.questionButton, 12, 0) layout.addWidget(self.questionLabel, 12, 1) layout.addWidget(self.warningButton, 13, 0) layout.addWidget(self.warningLabel, 13, 1) layout.addWidget(self.errorButton, 14, 0) layout.addWidget(self.errorLabel, 14, 1) layout.addWidget(self.native, 15, 0) self.setLayout(layout) self.setWindowTitle("Standard Dialogs") def setInteger(self): i, ok = QInputDialog.getInt(self, "QInputDialog.getInt()", "Percentage:", 25, 0, 100, 1) if ok: self.integerLabel.setText("%d%%" % i) def setDouble(self): d, ok = QInputDialog.getDouble(self, "QInputDialog.getDouble()", "Amount:", 37.56, -10000, 10000, 2) if ok: self.doubleLabel.setText("$%g" % d) def setItem(self): items = ("Spring", "Summer", "Fall", "Winter") item, ok = QInputDialog.getItem(self, "QInputDialog.getItem()", "Season:", items, 0, False) if ok and item: self.itemLabel.setText(item) def setText(self): text, ok = QInputDialog.getText(self, "QInputDialog.getText()", "User name:", QLineEdit.Normal, QDir.home().dirName()) if ok and text != '': self.textLabel.setText(text) def setColor(self): color = QColorDialog.getColor(Qt.green, self) if color.isValid(): self.colorLabel.setText(color.name()) self.colorLabel.setPalette(QPalette(color)) self.colorLabel.setAutoFillBackground(True) def setFont(self): font, ok = QFontDialog.getFont(QFont(self.fontLabel.text()), self) if ok: self.fontLabel.setText(font.key()) self.fontLabel.setFont(font) def setExistingDirectory(self): options = QFileDialog.DontResolveSymlinks | QFileDialog.ShowDirsOnly directory = QFileDialog.getExistingDirectory(self, "QFileDialog.getExistingDirectory()", self.directoryLabel.text(), options=options) if directory: self.directoryLabel.setText(directory) def setOpenFileName(self): options = QFileDialog.Options() if not self.native.isChecked(): options |= QFileDialog.DontUseNativeDialog fileName, _ = QFileDialog.getOpenFileName(self, "QFileDialog.getOpenFileName()", self.openFileNameLabel.text(), "All Files (*);;Text Files (*.txt)", options=options) if fileName: self.openFileNameLabel.setText(fileName) def setOpenFileNames(self): options = QFileDialog.Options() if not self.native.isChecked(): options |= QFileDialog.DontUseNativeDialog files, _ = QFileDialog.getOpenFileNames(self, "QFileDialog.getOpenFileNames()", self.openFilesPath, "All Files (*);;Text Files (*.txt)", options=options) if files: self.openFilesPath = files[0] self.openFileNamesLabel.setText("[%s]" % ', '.join(files)) def setSaveFileName(self): options = QFileDialog.Options() if not self.native.isChecked(): options |= QFileDialog.DontUseNativeDialog fileName, _ = QFileDialog.getSaveFileName(self, "QFileDialog.getSaveFileName()", self.saveFileNameLabel.text(), "All Files (*);;Text Files (*.txt)", options=options) if fileName: self.saveFileNameLabel.setText(fileName) def criticalMessage(self): reply = QMessageBox.critical(self, "QMessageBox.critical()", Dialog.MESSAGE, QMessageBox.Abort | QMessageBox.Retry | QMessageBox.Ignore) if reply == QMessageBox.Abort: self.criticalLabel.setText("Abort") elif reply == QMessageBox.Retry: self.criticalLabel.setText("Retry") else: self.criticalLabel.setText("Ignore") def informationMessage(self): reply = QMessageBox.information(self, "QMessageBox.information()", Dialog.MESSAGE) if reply == QMessageBox.Ok: self.informationLabel.setText("OK") else: self.informationLabel.setText("Escape") def questionMessage(self): reply = QMessageBox.question(self, "QMessageBox.question()", Dialog.MESSAGE, QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel) if reply == QMessageBox.Yes: self.questionLabel.setText("Yes") elif reply == QMessageBox.No: self.questionLabel.setText("No") else: self.questionLabel.setText("Cancel") def warningMessage(self): msgBox = QMessageBox(QMessageBox.Warning, "QMessageBox.warning()", Dialog.MESSAGE, QMessageBox.NoButton, self) msgBox.addButton("Save &Again", QMessageBox.AcceptRole) msgBox.addButton("&Continue", QMessageBox.RejectRole) if msgBox.exec_() == QMessageBox.AcceptRole: self.warningLabel.setText("Save Again") else: self.warningLabel.setText("Continue") def errorMessage(self): self.errorMessageDialog.showMessage("This dialog shows and remembers " "error messages. If the checkbox is checked (as it is by " "default), the shown message will be shown again, but if the " "user unchecks the box the message will not appear again if " "QErrorMessage.showMessage() is called with the same message.") self.errorLabel.setText("If the box is unchecked, the message won't " "appear again.")