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 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 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 open_visulization_window(self):
if len(self.raman_datasets) > 0:
self.raman_visualization_window = raman_visualization_window(
self.active_dataset())
self.raman_visualization_window.show()
else:
error_message = QErrorMessage()
error_message.showMessage('No active dataset available to '
'visualize!')
error_message.exec_()
def showSaveDialog(self):
try:
fileName = QFileDialog.getSaveFileName(self, "Сохранить файл",
"untitled.jpg",
"*.jpg;;*.bmp;;*.png")
self.MainWidget.image.save(fileName[0])
except Exception:
error = QErrorMessage(parent=self)
error.showMessage("Ошибка")
def db_integrity_check(self):
bad_tables = self.get_malformed_tables()
if bad_tables:
error_msg_dialog = QErrorMessage()
error_msg_dialog.showMessage(
f'Integrity check failed. Malformed tables: {", ".join(bad_tables)}'
)
error_msg_dialog.exec()
else:
self.statusBar().showMessage('Integrity check passed.', 5000)
def showDiagram(self, fig):
if count_code != 0:
DialogSecondIns = EpurDialogWindow(self, fig)
DialogSecondIns.show()
DialogSecondIns.exec()
else:
error_dialog = QErrorMessage()
error_dialog.showMessage('Сначала рассчитайте конструкцию!')
error_dialog.exec_()
def showOpenDialog(self):
try:
file = QFileDialog.getOpenFileName(self, 'Открыть файл', '/home',
"*.jpg;;*.bmp;;*.png")[0]
self.MainWidget.image = Image.open(file)
self.MainWidget.lbl.setPixmap(showPicture(self.MainWidget.image))
except Exception:
error = QErrorMessage(parent=self)
error.showMessage("Ошибка")
def open_uva_window(self):
if len(self.raman_datasets) > 0:
self.raman_univariate_analysis_window = raman_univariate_analysis_window(
self.active_dataset())
self.raman_univariate_analysis_window.show()
else:
error_message = QErrorMessage()
error_message.showMessage('No active dataset available to '
'analyze!')
error_message.exec_()
def open_preprocessing_window(self):
if len(self.raman_datasets) > 0:
self.raman_preprocessing_window = raman_preprocessing_window(
self.active_dataset())
self.raman_preprocessing_window.show()
else:
error_message = QErrorMessage()
error_message.showMessage('No active dataset available to '
'preprocess!')
error_message.exec_()
def category_table_widget_item_changed(self, item):
try:
# remove extra spaces before text and after text
category_name = item.text().strip()
# if the newly entered category name and the old category name are not the same
# start updating category process
if category_name != self.before_cell_is_edited:
# get the id of category from category table widget
item_id = self.CategoryTableWidget.item(item.row(), 0).text()
# capitalize the first letter in every word
category_name = category_name.title()
# get the row of the edited category in the category table widget
category_name_row = item.row()
# get the column of the edited category in the category table widget
category_name_column = item.column()
# if the category doesn't already exist continue updating process
if not self.edit_and_add_categories_controller.check_if_category_exists_with_name(category_name):
# put new category into table widget item
category_name_widget_item = QTableWidgetItem(category_name)
# center the table widget item's contents
category_name_widget_item.setTextAlignment(Qt.AlignCenter)
# if the category is not updated sucessfully throw an error message
if not self.edit_and_add_categories_controller.update_category(item_id, category_name):
error_message = QErrorMessage(self)
error_message.showMessage("The category with the specified name already exists")
else:
''' if the category update was successfull itemChanged must be disconnected because the user
is done editing the cell. We only want this on while the user is editing a cell '''
self.CategoryTableWidget.itemChanged.disconnect()
# put the new category in the category table widget
self.CategoryTableWidget.setItem(category_name_row, category_name_column, category_name_widget_item)
else:
'''itemChanged must be disconnected because the user
is done editing the cell. We only want this on while the user is editing a cell'''
self.CategoryTableWidget.itemChanged.disconnect()
# the new category already exists. Since the new category was not added,
# change the cell of the category table widget back to what it previously was and
# add nothing to the database
category_name_widget_item_previous = QTableWidgetItem(self.before_cell_is_edited)
category_name_widget_item_previous.setTextAlignment(Qt.AlignCenter)
self.CategoryTableWidget.setItem(category_name_row, category_name_column, category_name_widget_item_previous)
# throw an error message telling the user the category already exists
error_message = QErrorMessage(self)
error_message.showMessage("The category already exists.")
else:
self.CategoryTableWidget.itemChanged.disconnect()
except Exception as e:
print(str(e))
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 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 on_save_button_clicked(self):
file_name, _ = QFileDialog.getSaveFileName(self, "Save Image",
self.current_name + ".png",
"Images (*.png)")
if file_name != "":
try:
self.current_image.save(file_name)
except:
error = QErrorMessage(self)
error.showMessage("Could not save file")
error.setWindowModality(Qt.WindowModal)
def __save_contacts_to_settings(self):
contacts = self._contacts_picker.contacts
name, okay = QInputDialog.getText(self, 'New Group',
'Enter Group Name')
if name != '' and okay:
result = self._sample_config.add_config(name, contacts)
if result == False:
error = QErrorMessage()
error.showMessage('Name is already in use')
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 _on_new_group(self):
contacts = self._contacts_picker.contacts
name, okay = QInputDialog.getText(self, "New Group",
"Enter Group Name")
if name != "" and okay:
result = self._sample_config.add_config(name, contacts)
if result == False:
error = QErrorMessage()
error.showMessage("Name is already in use")
def Submit_btn(self):
URI = self.uri.text()
USERNAME = self.username.text()
PASSWORD = self.password.text()
try:
self.neo = neoHandler(URI, USERNAME, PASSWORD)
self.LOGGEDIN = True
self.close()
except Exception as e:
err = QErrorMessage()
err.showMessage(str(e.__context__))
def execute(operation: str, params=(), multi=False): # Смотри что оборачиваешь, и его параметры
"""Функция не реализующая коннект по требованию и создание уникального курсора для каждого запроса"""
try:
cur = DbWrapper.__conn.cursor()
cur.execute(operation, params, multi)
return cur
except Exception as err:
error_widget = QErrorMessage()
error_widget.showMessage(str(err))
error_widget.exec()
return None
def crash(self, error_text, save_world=False):
"""
This constant function opens an QErrorMessage with the given error_text and forces python to
exit the program. Only call this if a fatal error has happened.
"""
if save_world:
self.save_world()
error_message = QErrorMessage()
error_message.setModal(True)
error_message.showMessage(error_text)
exit(error_message.exec_())
def DrawGr(self):
if count_code != 0:
self.get_i_rod()
print("Fig rod")
fig_Gr = self.newCount.makeGraf(self.i_rod)
print("Grafishere")
self.showGraf(fig_Gr)
else:
error_dialog = QErrorMessage()
error_dialog.showMessage('Сначала рассчитайте конструкцию!')
error_dialog.exec_()
def button1_clicked(self):
# TODO: insert here parsed text
self.plain_text_area.clear()
http_url = self.url_line.text()
try:
text = get_text_wiki(http_url)
self.plain_text_area.insertPlainText(format(text))
except:
error_dialog = QErrorMessage()
error_dialog.showMessage('Wrong URL')
self.exec_()
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 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"))
class DataList(object):
def __init__(self, FilePattern):
super(DataList, self).__init__()
try:
print(FilePattern)
self.FilePattern = FilePattern
except Exception as ImportFilePattern:
print(ImportFilePattern)
self.BulkFileGrab()
def BulkFileGrab(self):
print("inside BulkFileGrab")
#Open directory window and grab path of directory we want to pull data from
self.path = QFileDialog.getExistingDirectory()
self.Error = QErrorMessage() #creates an object using pyqt ErrorMessage class
try:
if self.path == "": #if we detect an empty string (no path given) we give user an error
self.Error.showMessage("invalid filepath given")
self.NoneReturn = True #confirmation that an error occured
elif self.path != "": # proper filepath was given (non-empty string)
#print statements made for debugging purposes.
#print(self.path)
#Grab all csv files following proper name convention
if self.FilePattern == "Enter File Pattern...":
print("No LineEdit input given. Default state confirmed. Grabbing Files with fileformat TestSample*.csv")
print(("{}/TestSample*.csv").format(self.path))
self.filepaths = glob(("{}/TestSample*.csv").format(self.path)) #glob responsible collecting all files that fit format
self.NoneReturn = False #file path is not None, proper input given
print(self.filepaths)
else:
print("LineEdit was given input. Changing from default filepattern name convention.")
print(("{}/{}*.csv").format(self.path, self.FilePattern))
# glob grabs files with new filepattern string at specified directory
self.filepaths = glob(("{}/{}*.csv").format(self.path,self.FilePattern))
self.NoneReturn = False #file path is not None, proper input given
print(self.filepaths)
else: #Otherwise throw an error
print("directory not given")
self.Error.showMessage("Directory not given")
self.NoneReturn = True
except Exception as FilePatternErr:
print("error occured when trying to choose file pattern.......ERROR: {}".format(FilePatternErr))
def login_wrapper(self):
try:
with open(f'Users/{self.login_name_line.text()}.json', 'r') as file:
if json.load(file)['password'] != self.login_password_line.text():
msg = QErrorMessage(self)
msg.showMessage('Error: Username or password incorrect')
else:
self.open_main(self.login_name_line.text())
except FileNotFoundError:
msg = QErrorMessage(self)
msg.showMessage('Error: Username or password incorrect.')
def exit_exception(app, txt, exc=None):
if exc is None:
exc = ValueError(txt)
msg = txt
else:
msg = txt + '; ' + str(exc)
if app:
e = QErrorMessage()
e.showMessage(msg)
sys.exit(e.exec_())
else:
raise exc
def open_ref_spec_fit_viewer(self):
if (len(self.raman_datasets) > 0) and hasattr(self.active_dataset(),
'fitted_spectra'):
self.ref_spec_fit_viewer = reference_spectra_fit_viewer(
self.active_dataset())
self.ref_spec_fit_viewer.show()
else:
error_message = QErrorMessage()
error_message.showMessage('No reference spectra fit dataset '
'available to visualize! Perform '
'reference spectra fit first.')
error_message.exec_()
def open_3d_data_viewer(self):
if (len(self.raman_datasets) > 0) and type(
self.active_dataset()) is raman_image:
self.intensity_viewer = raman_3d_intensity_viewer(
self.active_dataset())
self.intensity_viewer.show()
else:
error_message = QErrorMessage()
error_message.showMessage('No dataset available to visualize '
'or no active dataset is not a raman'
'map. Perform data analysis first!')
error_message.exec_()
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 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 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 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 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) :
#заглушка
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()
def on_scan_error(self, error):
print('Error: %s' % error)
err = QErrorMessage(self)
err.setWindowTitle("eDocuments - scan error")
err.showMessage(error)
def connectLocalCamera(self) :
self.close()
qem = QErrorMessage()
qem.showMessage('Не удаётся подключиться к Raspberry Pi: Будет подключена локальная камера')
qem.exec()
self._capturedDevice = cv2.VideoCapture(0)
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 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)
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 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.")
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
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)
