def _rotateTriggered(self): """rotate an element""" self.operationIndex = 0 if self.selected == False: errorHint = QErrorMessage(self) errorHint.setWindowTitle("Rotation Hint") errorHint.showMessage( "Nothing selected! Please specify a graph element to rotate.") return if self.centerSet == False: self.statusBar().showMessage( "Please specify the center of rotation") self.mainCanvas.setCenter = True elif self.degreeSet == False: self.statusBar().showMessage( "Pleases move your mouse to specify the degree of rotation") self.mainCanvas.setDegree = True else: # print "Rotation center:", self.center # print "Rotation degree:", self.degree w, h = self.backPanel.canvas.shape[:2] # print "Transformed rotation center:", self.center[0], w-1-self.center[1] state = self.backPanel.rotate(self.selectedID, self.center[0], w - 1 - self.center[1], self.degree) if state == True: self.mainCanvas.setPixmap(self._getPic()) self.statusBar().showMessage("Rotation finished.") else: self.statusBar().showMessage("Rotation failed.") self.centerSet = self.degreeSet = False # end operation
def Op12(self, n): try: p = "" p = QFileDialog.getExistingDirectory( self, 'Открыть папку', self.path_dir_dirs if n == 1 else self.path_dir_images) if p == "": raise Exception("string index out of range") if n == 1: self.file_path, self.file_name = self.Files( p, n, namef=self.ImageName.text()) self.path_dir_dirs = p else: self.file_path, self.file_name = self.Files(p, n) self.path_dir_images = p #print(self.file_path) self.Zap() self.arr = [None for j in self.file_name] self.stst = [None for j in self.file_name] ## self.arr_lv = [self.lv_c for j in self.file_name] self.arr_t = [self.t_c for j in self.file_name] self.Run_Tread() """ def ClosePotok(self): self.potokRasch.stop() self.potokRasch.mysignal.disconnect() del self.potokRasch """ except Exception as ex: if str(ex) != "string index out of range": ems = QErrorMessage(self) ems.setWindowTitle('Возникла ошибка') ems.showMessage('При открытии возникла ошибка (' + str(ex) + ').')
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 Op3(self): try: p = QFileDialog.getOpenFileNames(self, 'Открыть файлы', self.path_excel, "*.xlsx *.xls") if p == ([], ''): raise Exception("string index out of range") self.file_path = [] self.file_name = [] self.arr_lv = [] self.arr_t = [] self.arr = [] for i in p[0]: N, nam, lv, t = xlsx.OpenFile(i) self.arr += N self.stst += [imagescan.define_state(a) for a in N] self.file_name += nam self.file_path += [None for j in nam] self.arr_lv += [j if j != None else self.lv_c for j in lv] self.arr_t += [j if j != None else self.t_c for j in t] self.path_excel = os.path.dirname(p[0][0]) self.Zap() for i in range(len(self.arr)): color = imagescan.common_state(self.stst[i]) self.sp_m[i].setBackground( QBrush(QColor(*self.back_colors[color]))) except Exception as ex: if str(ex) != "string index out of range": ems = QErrorMessage(self) ems.setWindowTitle('Возникла ошибка') ems.showMessage('При открытии возникла ошибка (' + str(ex) + ').')
def add_items(self): try: pedido, n_simafic, qtd_items = self.pedido.text( ), self.n_simafic.text(), self.qtd_items.text() print("Add Pedido: {} {} {}".format(pedido, n_simafic, qtd_items)) if services.validateCadastro(pedido, n_simafic, qtd_items): print("Add Pedido: {} {} {}".format(pedido, n_simafic, qtd_items)) mb = QMessageBox() mb.setIconPixmap(QPixmap('assets/check_icon_blue2')) mb.setWindowTitle("Sucesso") mb.setText( 'O pedido: {} foi criado com sucesso!'.format(pedido)) services.add_pedido(pedido, n_simafic, qtd_items) mb.exec_() self.update_model_tableview() self.limpar_pedidos() except (ValidationError, DBPedidosException) as error: error_dialog = QErrorMessage() error_dialog.setWindowTitle(error.errors) error_dialog.setWindowIcon(QIcon(main_icon)) error_dialog.showMessage(error.message) error_dialog.exec_() pass
def Op0(self): try: p = QFileDialog.getOpenFileNames(self, 'Открыть файлы', self.path_image, "*.png *.jpg *.bmp") if p == ([], ''): raise Exception("string index out of range") self.file_path = [] self.file_name = [] for i in p[0]: fname, pr = os.path.splitext(os.path.split(i)[1]) self.file_path.append(i) self.file_name.append(fname) self.Zap() self.arr = [None for j in self.file_name] self.stst = [None for j in self.file_name] self.arr_lv = [self.lv_c for j in self.file_name] self.arr_t = [self.t_c for j in self.file_name] self.path_image = os.path.dirname(p[0][0]) self.Run_Tread() except Exception as ex: if str(ex) != "string index out of range": ems = QErrorMessage(self) ems.setWindowTitle('Возникла ошибка') ems.showMessage('При открытии возникла ошибка (' + str(ex) + ').')
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 validaScanInput(self): print('validaScanInput {}'.format(self.input_scanner.text())) try: if services.valida_simafic(s_input=self.input_scanner.text(), pedido=self.pedido): self.pedido.qty_scanneada += 1 self.qtd_parcial_le.setText(str(self.pedido.qty_scanneada)) self.pedido.nome_responsavel = self.count_resp_le.text() self.pedido.id_caixa = self.id_caixa_le.text() services.update_pedido(self.pedido) self.input_scanner.clear() if (self.pedido.qty_scanneada == self.pedido.qty_total): print("Aqui é pra tocar o som") QSound.play('assets/error.wav') self.input_scanner.setDisabled(True) QMessageBox.warning( self, "Item finalizado.", "O Item já atingiu a quantidade cadastrada.") except (ValidationError, DBPedidosException) as error: error_dialog = QErrorMessage() errorSound = QSound('assets/error.wav') errorSound.play() error_dialog.setWindowTitle(error.errors) error_dialog.setWindowIcon(QIcon(main_icon)) error_dialog.showMessage(error.message) self.input_scanner.clear() error_dialog.exec_()
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)
def _scaleTriggered(self): """scale an element""" self.operationIndex = 2 if self.selected == False: errorHint = QErrorMessage(self) errorHint.setWindowTitle("Scaling Hint") errorHint.showMessage( "Nothing selected! Please specify a graph element to scale.") return if self.centerSet == False: self.statusBar().showMessage( "Please specify the center of scaling") self.mainCanvas.setCenter = True elif self.scaleSet == False: self.statusBar().showMessage( "Please move your mouse to specify the degree of scaling") self.mainCanvas.setScale = True else: # print "Scaling center:", self.center # print "Scaling ratio:", self.scaleRatio w, h = self.backPanel.canvas.shape[:2] state = self.backPanel.scale(self.selectedID, self.center[0], w - 1 - self.center[1], self.scaleRatio) if state == True: self.mainCanvas.setPixmap(self._getPic()) self.statusBar().showMessage("Scaling finished.") else: self.statusBar().showMessage("Scaling failed.") self.centerSet = self.scaleSet = False # end operation
def display_error(err): app = QApplication.instance() window = app.activeWindow() dialog = QErrorMessage(window) dialog.setWindowModality(Qt.WindowModal) dialog.setWindowTitle("Error") dialog.showMessage(err)
def displayFileError(self, file): errordialog = QErrorMessage(self.pdfmerger) file = os.path.basename(file) errordialog.showMessage( f"{file}\n has not a valid format.\n" f"For {self.pdfmerger.current_mode} Mode supported formats are {self.valid_types} Files ", file) errordialog.setWindowTitle("File Error")
def mapdialog(self): # Yrittää ladata kentän img = QFileDialog.getOpenFileName(self, 'Open 24-bit BMP image from \maps - directory', os.getcwd(), 'Image files (*.bmp)') if img[0]: success, msg = self.game.load_map(img[0]) if success == 0: error = QErrorMessage(self.menu) error.setWindowTitle("Error") error.showMessage(msg)
def au(self, acc, paw): u = UserManage() u.addUser(acc, paw) er = QErrorMessage(self) er.setWindowTitle("提示") er.showMessage("添加成功!") er.show() self.showAll()
def show_error_box(title: str, text: str, parent: QWidget = None): error_box = QErrorMessage() # error_box.setParent(parent) error_box.setWindowTitle(title) error_box.setModal(True) error_box.setMaximumSize(600, 200) error_box.setMinimumSize(600, 200) x = error_box.showMessage(text) x = error_box.exec_()
def pay(self, data): c = ZhuanzhangNote() c.addNote(data) d = CreditAbout() d.setPayed(self.cid) self.showAll() mes = QErrorMessage(self) mes.setWindowTitle("提示") mes.showMessage("支付成功!") mes.show()
def get_detail(self): res = self.PC.get_producingplan(autoid=self.autoid) if res: # 把生产指令的内容填入表格中 self.set_data(res[0]) self.ori_detail = model_to_dict(res[0]) self.detail = self.ori_detail else: errordialig = QErrorMessage(self) errordialig.setWindowTitle("错误")
def finish(self): try: self.finish_crop() self.app.exit() except Exception as e: error = QErrorMessage(self.window) error.setWindowTitle("Cropping Error") error.showMessage("Select more points") raise Exception(e)
def segmentation_clicked(self): error_message = QErrorMessage(self) if not self.inputLoaded : error_message.setWindowTitle("Input error") error_message.showMessage('First load input ') else: I = cv2.imread(self.nameOfInput) draw_seg(I) cv2.imwrite("r.jpg",I) self.labelResult.setPixmap(QPixmap("r.jpg"))
def harris_clicked(self): error_message = QErrorMessage(self) if not self.inputLoaded : error_message.setWindowTitle("Input error") error_message.showMessage('First load input ') else: I = cv2.imread(self.nameOfInput) R = harris_cop(I) cv2.imwrite("res.jpg",R) self.labelResult.setPixmap(QPixmap("res.jpg"))
def open_FileClicked(self): # fn = self.setOpenFileName()[0] self.file_Path = self.set_OpenFileName() self.file_name = self.file_Path[0] if dosmt.is_excel(self.file_name) == True: df = pd.read_excel(self.file_name) self.load_df(df) else: mess = QErrorMessage(self) mess.setWindowTitle("Notice!!") mess.showMessage("Open Excel file only")
def excluirPedido(self, pedido): try: services.excluirPedidoItem(pedido) self.update_model_tableview() except (ValidationError, DBPedidosException) as error: error_dialog = QErrorMessage() error_dialog.setWindowTitle(error.errors) error_dialog.setWindowIcon(QIcon(main_icon)) error_dialog.showMessage(error.message) error_dialog.exec_()
def excepthook_errormsg(exc_type, exc_value, exc_tb): error_box = QErrorMessage() error_box.setWindowTitle("Błąd") tb = "\n".join(traceback.format_exception(exc_type, exc_value, exc_tb)) error_box.setMaximumSize(600, 200) error_box.setMinimumSize(600, 200) error_box.setModal(True) print(tb, file=sys.stderr, flush=True) x = error_box.showMessage(tb) x = error_box.exec_() QtWidgets.QApplication.quit()
def finish(self): name = self.lineEdit.text() num = self.spinBox.value() price = re.findall("[\d.]+", self.lineEdit_3.text())[0] if name and num and price: self.finish_signal.emit([name, int(num), float(price)]) self.close() else: mes = QErrorMessage(self) mes.setWindowTitle("提示") mes.showMessage("请输入完整内容!") mes.show()
def _translateTriggered(self): """translate an element""" self.operationIndex = 1 if self.selected == False: errorHint = QErrorMessage(self) errorHint.setWindowTitle("Translation Hint") errorHint.showMessage( "Nothing selected! Please specify a graph element to translate." ) return self.statusBar().showMessage("Translating ...") self.mainCanvas.startTranslation()
def excepthook(exc_type, exc_value, exc_tb): traceback_ = ''.join( traceback.format_exception(exc_type, exc_value, exc_tb)) err_msg = f'An unhandled exception has occurred:\n {traceback_}' manager_logger.error(err_msg) err_msg = err_msg.replace('\n', '<br>') error_dialog = QErrorMessage() error_dialog.setWindowTitle('HLM PV Import - Error') error_dialog.resize(600, 300) error_dialog.setFont(QFont('Lucida Console', 9)) error_dialog.showMessage(err_msg) error_dialog.exec()
def line_up_with_epoch(self): """Go to the start of the present epoch.""" if self.parent.notes.annot is None: # TODO: remove if buttons are disabled error_dialog = QErrorMessage() error_dialog.setWindowTitle('Error moving to epoch') error_dialog.showMessage('No score file loaded') error_dialog.exec() return new_window_start = self.parent.notes.annot.get_epoch_start( self.parent.value('window_start')) self.parent.overview.update_position(new_window_start)
def connect_button_pressed(self): errors = self.login_window.validate() if len(errors) != 0: error_message = QErrorMessage() error_message.setWindowTitle('Ошибка') error_message.setFixedSize(550, 300) error_message.showMessage('<br>'.join(errors)) error_message.exec_() else: self.connect() self.login_window.hide() self.conversation_window.show() self.setGeometry(300, 300, 650, 400)
def apply_button_operation_del_element(self): try: name = self.remove_element_widget.layout().itemAt( 1).layout().itemAt(0).widget().toPlainText() if name: query = human_and_time_database.HumanModel.select().where( human_and_time_database.HumanModel.name == name).limit(1) if len(list(query)) == 1: human = query[0] new_rows = [] for row in human_and_time_database.RelationTable.select(): if human.id in [row.spouse, row.parent1, row.parent2]: current_human = row.human current_spouse = None if row.spouse == human.id else row.spouse current_parent1 = None if row.parent1 == human.id else row.parent1 current_parent2 = None if row.parent2 == human.id else row.parent2 new_rows.append((current_human, current_spouse, current_parent1, current_parent2)) human_and_time_database.RelationTable.delete().where( (human_and_time_database.RelationTable.human == human.id) | (human_and_time_database.RelationTable.spouse == human.id) | (human_and_time_database.RelationTable.parent1 == human.id) | (human_and_time_database.RelationTable.parent2 == human.id)).execute() for h, s, p1, p2 in new_rows: human_and_time_database.RelationTable.create( human=h, spouse=s, parent1=p1, parent2=p2) human_and_time_database.HumanModel.delete().where( human_and_time_database.HumanModel.name == name).execute() self.remove_element_widget.close() else: message = QErrorMessage(self) message.setWindowTitle('Input data error') message.showMessage('No such node in the tree') else: message = QErrorMessage(self) message.setWindowTitle('Input data error') message.showMessage('All fields must be filled') except Exception as e: print('apply_button_operation_del_element: ', e)
def delClient(self): try: index = self.tableView.currentIndex().row() self.data.pop(index) self.showTable() mes = QErrorMessage(self) mes.setWindowTitle("提示") mes.showMessage("删除成功!") mes.show() except Exception as ret: print(ret) mes = QErrorMessage(self) mes.setWindowTitle("提示") mes.showMessage("删除失败!") mes.show()
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 on_scan_error(self, error): print('Error: %s' % error) err = QErrorMessage(self) err.setWindowTitle("eDocuments - scan error") err.showMessage(error)
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 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 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 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