def create_macros_set(self) -> Optional[data_types.MacroSet]:
"""
create new macros from data from fields and add it to all macroses
:return: new macros
"""
name = self.LineNameSet.text()
if not name:
common_functions.error_message("Macros Set Name is empty")
return None
if name not in [macro.name for macro in self.all_macros]:
new_macros_set = data_types.MacroSet(name=name, macros=list())
for key in self.macros_dict.keys():
new_macros_set.macros.append(
data_types.Macro(
name=self.macros_names_list[key].text(),
command=self.macros_command_list[key].text(),
icon_path=self.current_icon_paths[key]))
self.all_macros.append(new_macros_set)
self.CBMacros.addItem(name)
self.CBMacros.setCurrentText(name)
return new_macros_set
else:
macros_used = data_types.get_macros_by_name(name, self.all_macros)
for i in range(data_types.max_macros):
macros_used.macros[i].name = self.macros_names_list[i].text()
macros_used.macros[i].command = self.macros_command_list[
i].text()
macros_used.macros[i].command = self.current_icon_paths[i]
return macros_used
def connect(self):
"""
connects to selected port with selected settings, sets connected UI state if success
:return:
"""
name: str = self.CBPorts.currentText().split(':')[0]
self.serial_port.setPortName(name)
# noinspection PyArgumentList
self.serial_port.setBaudRate(self.port_settings.baudrate)
self.serial_port.setDataBits(
data_types.databits_dict[self.port_settings.databits])
self.serial_port.setParity(
data_types.parity_dict[self.port_settings.parity])
self.serial_port.setStopBits(
data_types.stopbits_dict[self.port_settings.stopbits])
if not self.serial_port.open(QtCore.QIODevice.ReadWrite):
common_functions.error_message("Unable to open port %s" % name)
else:
self.start_time = datetime.datetime.now()
self.LblStatus.setPixmap(
QtGui.QPixmap(":/status-conn/icon/status con2.gif"))
self.BtnDisconnect.setEnabled(True)
self.BtnConnect.setEnabled(False)
self.port_settings.name = name
self.port_settings.last_name = name
self.BtnSend.setEnabled(True)
self.BtnSend2.setEnabled(True)
self.statusbar.clearMessage()
self.TxtBuffer.clear()
self.clear_counter()
def write_data(self, text: Union[str, bytes], encode=True, hexes=True) -> int:
"""
writes data to comport
:param hexes: convert hexes or not
:param encode: True if we need to encode
:param text: text to send
:return: -1 if failed 0 if ok
"""
commands = common_functions.split_with_bytes(text) if hexes and encode else [text]
res_command = bytes()
for command in commands:
if common_functions.is_byte(command):
add_command = bytes.fromhex(command[1:]) if encode else command
else:
add_command = bytes(command, encoding='utf-8') if encode else command
res_command += add_command
res = self.serial_port.write(res_command)
self.serial_port.flush()
if res != len(res_command):
common_functions.error_message('Data was not sent correctly')
return -1
if self.text_settings.show_sent and encode:
self.TxtBuffer.setStyleSheet("background-color:rgb%s" % str(self.colors['background-color']))
self.TxtBuffer.setTextBackgroundColor(QtGui.QColor(*self.colors['background-color']))
for command in commands:
if common_functions.is_byte(command):
self.TxtBuffer.setTextColor(QtGui.QColor(*self.colors['bytes-color']))
else:
self.TxtBuffer.setTextColor(QtGui.QColor(*self.colors['font-transmit']))
command_to_show: str = common_functions.hexify(command) if self.CBHex.isChecked() else command
self.TxtBuffer.insertPlainText(command_to_show)
if self.text_settings.scroll:
scroll = self.TxtBuffer.verticalScrollBar().maximum()
self.TxtBuffer.verticalScrollBar().setValue(scroll)
return 0
def set_question_ui(self):
"""
sets ui of question (text and other question data)
:return:
"""
actual_category: questiondata.Category = self.state.category
self.LblDscr.setText(
"%s:\nВопрос № %i из %i. Стоимость %i " %
(actual_category.name, self.state.question + 1,
len(actual_category.questions),
actual_category.questions[self.state.question].points))
self.TxtQstn.setHtml(
common_functions.get_question_text(
actual_category.questions[self.state.question].description))
self.LblAnswer.setText(
actual_category.questions[self.state.question].answer)
self.category_form.question = question_opened.QuestionDialog(
actual_category, self.state.question, self.model, self.usbhost,
self.state.commands_answered, self.Timer)
self.category_form.question.question_signal[int].connect(
self.cmd_button_pressed)
self.state.answer_signal[bool].connect(
self.category_form.question.answer_processed)
if self.category_form.question.image:
common_functions.resize_to_third(self.category_form.question)
self.category_form.question.image.show()
if self.category_form.question.media:
if self.category_form.question.mediapath:
self.BtnMusic.setEnabled(True)
os.system(r"start %s" % self.category_form.question.mediapath)
else:
common_functions.error_message(
"Файла с медиаконтентом не существует или формат неверный")
self.category_form.question.show()
def create_macros_set(self) -> Optional[data_types.MacroSet]:
"""
create new macros from data from fields and add it to all macroses
:return: new macros
"""
name = self.LineNameSet.text()
if not name:
common_functions.error_message("Macros Set Name is empty")
return None
new_macros_set = data_types.MacroSet(name=name, macros=list())
for key in self.macros_dict.keys():
new_macros_set.macros.append(
data_types.Macro(name=self.macros_dict[key][0].text(),
command=self.macros_dict[key][1].text()))
if name in [macro.name for macro in self.all_macros]:
macros_used = data_types.get_macros_by_name(name, self.all_macros)
if macros_used != new_macros_set:
# reply = QtWidgets.QMessageBox.question(self, 'Message',
# 'Macros set "%s" already exists. Overwrite?' % name,
# QtWidgets.QMessageBox.Yes, QtWidgets.QMessageBox.No)
# if reply == QtWidgets.QMessageBox.Yes:
ind = self.all_macros.index(macros_used)
self.all_macros.pop(ind)
self.all_macros.insert(ind, new_macros_set)
return macros_used
if name not in [macro.name for macro in self.all_macros]:
self.all_macros.append(new_macros_set)
self.CBMacros.addItem(name)
self.CBMacros.setCurrentText(name)
return new_macros_set
def new_category(self):
"""
:return:
"""
if len(self.bets.bets) > 0:
common_functions.error_message("Все незачтенные ставки сгорели!")
self.bets.clear_bet()
self.category_form.setVisible(True)
def load_settings(self):
"""
loads settings from file if any and overwrites default
:return:
"""
if os.path.exists("settings.json"):
with open("settings.json") as f:
try:
settings_json = json.load(f)
if 'COM settings' in settings_json.keys():
if 'baudrate' in settings_json['COM settings'].keys():
self.port_settings.baudrate = settings_json['COM settings']['baudrate']
if self.port_settings.baudrate not in data_types.baudrates:
self.CBBaudrate.addItem(str(self.port_settings.baudrate))
self.CBBaudrate.setCurrentText(str(self.port_settings.baudrate))
if 'stopbits' in settings_json['COM settings'].keys():
self.port_settings.stopbits = settings_json['COM settings']['stopbits']
if 'parity' in settings_json['COM settings'].keys():
self.port_settings.parity = data_types.Parity(settings_json['COM settings']['parity'])
if 'databits' in settings_json['COM settings'].keys():
self.port_settings.databits = settings_json['COM settings']['databits']
if 'Text settings' in settings_json.keys():
if 'CRLF' in settings_json['Text settings'].keys():
self.text_settings.CRLF = settings_json['Text settings']['CRLF']
if 'bytecodes' in settings_json['Text settings'].keys():
self.text_settings.bytecodes = settings_json['Text settings']['bytecodes']
if 'scroll' in settings_json['Text settings'].keys():
self.text_settings.scroll = settings_json['Text settings']['scroll']
if 'show sent' in settings_json['Text settings'].keys():
self.text_settings.show_sent = settings_json['Text settings']['show sent']
if 'timestamps' in settings_json['Text settings'].keys():
self.text_settings.timestamps = settings_json['Text settings']['timestamps']
if 'Colors' in settings_json.keys():
if 'background-color' in settings_json['Colors'].keys():
self.colors['background-color'] = tuple(settings_json['Colors']['background-color'])
self.back_color_changed()
if 'font-transmit' in settings_json['Colors'].keys():
self.colors['font-transmit'] = tuple(settings_json['Colors']['font-transmit'])
if 'font-receive' in settings_json['Colors'].keys():
self.colors['font-receive'] = tuple(settings_json['Colors']['font-receive'])
if 'bytes-color' in settings_json['Colors'].keys():
self.colors['bytes-color'] = tuple(settings_json['Colors']['bytes-color'])
if 'Font' in settings_json.keys():
font_family = settings_json['Font']['family'] if 'family' in settings_json['Font'].keys() \
else 'Consolas'
font_size = settings_json['Font']['size'] if 'size' in settings_json['Font'].keys() else 10
self.current_font = QtGui.QFont(font_family, font_size)
self.TxtBuffer.setFont(self.current_font)
if 'Macros set' in settings_json.keys():
self.current_macros = data_types.get_macros_by_name(settings_json['Macros set'],
self.all_macros)
if self.current_macros:
self.port_settings.last_macros_set = settings_json['Macros set']
self.CBMacros.setCurrentText(self.port_settings.last_macros_set)
except (json.JSONDecodeError, AttributeError, KeyError, ValueError):
common_functions.error_message("Settings file is incorrect, default settings used")
def write_to_port(self, command) -> int:
"""
writes command to port, checks for error
:param command: command to write
:return: 0 if OK, -1 if error
"""
res = self.serial_port.write(command)
self.serial_port.flush()
if res != len(command):
common_functions.error_message('Data was not sent correctly')
return -1
return 0
def open_port(self):
"""
opens serial port and change state to scanning
:return:
"""
answer = self.usbhost.send_command("RstTmr")
if answer in common_functions.wrong_answers:
common_functions.error_message(
common_functions.answer_translate[answer])
return
self.scanning = True
def update_plot_data(self, data_x: float, data_y: List[float]):
"""
updates plot with new values
:param data_x: new x data
:param data_y: list with new y data
:return:
"""
self.data_x.append(data_x)
for (i, y) in enumerate(data_y):
try:
self.data_y[i].append(y)
except IndexError:
common_functions.error_message('Too many items in data')
for (i, line) in enumerate(self.data_lines):
line.setData(self.data_x, self.data_y[i])
def btn_select_pressed(self):
"""
enables timer if any button pressed, button is remembered in self.testing variable
:return:
"""
error = self.usbhost.send_command("rsttmr")
if error in common_functions.wrong_answers:
common_functions.error_message(
common_functions.answer_translate[error])
return
self.testing = self.sender()
self.scanning = True
self.retries = 0
self.LblInstruction.setText("Ждем ответа кнопки")
print("Successfully started timer")
def menu_open_pressed(self):
openfilename = QtWidgets.QFileDialog.getOpenFileName(
self, 'Выберите игру', "")[0]
if openfilename and openfilename.endswith(".xlsx"):
self.game, error = questiondata.create_game(openfilename)
if self.game:
if error:
common_functions.error_message(error)
self.state.set_game(self.game)
self.category_form = category.CategoryForm(self.game)
self.category_form.category_signal[str].connect(
self.category_selected)
self.category_form.show()
else:
common_functions.error_message(
'Файл не выбран или формат неверный (выберите .xlxs файл')
def baudrate_changed(self):
"""
change baudrate in settings
:return:
"""
if self.CBBaudrate.currentText() != 'Custom':
self.port_settings.baudrate = int(self.CBBaudrate.currentText())
else:
# noinspection PyCallByClass,PyArgumentList
text, ok = QtWidgets.QInputDialog.getText(self, 'Custom baudrate', 'Enter baudrate')
if ok:
try:
new_baudrate: Optional[int] = int(text)
except ValueError:
new_baudrate = None
if not new_baudrate or new_baudrate <= 0:
common_functions.error_message("Baudrate must be positive number")
else:
self.port_settings.baudrate = new_baudrate
def icon_clicked(self):
"""
selects icon for current macros.
:return:
"""
sender = self.sender()
icon_filename = QtWidgets.QFileDialog.getOpenFileName(
self, 'Select icon...', "")[0]
if icon_filename and os.path.splitext(
icon_filename.lower())[1] in data_types.icon_exts:
index = self.btn_icon_list.index(sender)
icon = QtGui.QIcon()
icon.addFile(icon_filename)
self.btn_send_list[index].setIcon(icon)
self.current_macros.macros[index].icon_path = icon_filename
self.current_icon_paths[index] = icon_filename
self.save()
elif icon_filename:
common_functions.error_message("Wrong icon format")
def load_settings(self, filename='settings.json'):
"""
loads settings from file if any and overwrites default
:return:
"""
if os.path.exists(filename):
with open(filename) as f:
try:
settings_json = json.load(f)
self.load_port_settings(settings_json)
self.load_text_settings(settings_json)
self.load_filter_settings(settings_json)
self.load_crc_settings(settings_json)
self.load_style_settings(settings_json)
self.load_macros_settings(settings_json)
except (json.JSONDecodeError, AttributeError, KeyError,
ValueError):
common_functions.error_message(
"Settings file is incorrect, default settings used")
def send_file(self):
"""
sends selected file data to serial port
:return:
"""
if self.port_settings.name and self.file_to_send:
if os.path.exists(self.file_to_send) and not os.path.isdir(
self.file_to_send):
with open(self.file_to_send, "rb") as f:
data = f.read()
res = self.write_data(data, False, False, False)
if res != -1:
# error = QtWidgets.QMessageBox()
# error.setIcon(QtWidgets.QMessageBox.Information)
# error.setText("File transmitted")
# error.setWindowTitle('Success')
# error.setStandardButtons(QtWidgets.QMessageBox.Ok)
# error.exec_()
self.statusbar.showMessage("File sent")
else:
common_functions.error_message("Check file or port")
def timerEvent(self):
"""
if timer as active, try to get button pressed
:return:
"""
if self.scanning:
print('scan')
caption = self.LblInstruction.text() + "."
self.LblInstruction.setText(caption)
self.retries += 1
button: int = common_functions.get_first_button(
self.usbhost, "idle", list())
if button:
self.CBlist[self.btnlist.index(self.testing)].setCurrentText(
"Кнопка %i" % button)
self.state_not_scanning()
if self.retries > retry_number:
common_functions.error_message(
"Ни одна кнопка не нажата в течение 10 секунд, попробуйте еще раз"
)
self.state_not_scanning()
def load(self):
"""
loads variable data from variables.json
:return:
"""
if os.path.exists("variables.json"):
with open("variables.json") as f:
try:
var_data = json.load(f)
if 'Variables' in var_data.keys() and isinstance(
var_data['Variables'], dict):
for key in var_data['Variables'].keys():
self.var_dict[key] = var_data['Variables'][key]
self.ListVariables.addItem(
"$%s = %s" % (key, var_data['Variables'][key]))
if 'Range' in var_data.keys() and isinstance(
var_data['Range'], dict):
range_data = var_data['Range']
try:
if 'name' in range_data.keys():
self.LineVarName.setText(range_data['name'])
if 'min_value' in range_data.keys():
self.SpinMin.setValue(range_data['min_value'])
if 'max_value' in range_data.keys():
self.SpinMax.setValue(range_data['max_value'])
if 'step' in range_data.keys():
self.SpinStep.setValue(range_data['step'])
if 'is_autosend' in range_data.keys():
self.CBAuto.setChecked(
range_data['is_autosend'])
if 'command' in range_data.keys():
self.LineCommand.setText(range_data['command'])
self.value_changed()
except (AttributeError, ValueError):
common_functions.error_message(
'Cannot load saved variables')
except json.JSONDecodeError:
common_functions.error_message(
"Cannot load saved variables")
