def __init__(self, parent=None):
super(Widget, self).__init__(parent)
# self.message_le = QtWidgets.QLineEdit()
# self.send_btn = QtWidgets.QPushButton(text="Send",clicked=self.send)
# self.output_te = QtWidgets.QTextEdit(readOnly=True)
self.output_te = QtWidgets.QLabel("Carid ID")
self.button = QtWidgets.QPushButton(text="Connect",
checkable=True,
toggled=self.on_toggled)
lay = QtWidgets.QVBoxLayout(self)
# hlay = QtWidgets.QHBoxLayout()
# hlay.addWidget(self.message_le)
# hlay.addWidget(self.send_btn)
# lay.addLayout(hlay)
lay.addWidget(self.output_te)
lay.addWidget(self.button)
#================= For Serial Data From Arduino ======================
self.serial = QtSerialPort.QSerialPort(
'/dev/cu.usbmodem14101',
baudRate=QtSerialPort.QSerialPort.Baud9600,
readyRead=self.receive)
def _OpenSerialPort(self):
SerialPortName = self.UserInterface.SELSerialPort.itemText(
self.UserInterface.SELSerialPort.currentIndex()).split(" ")[0]
SerialPortBaudRate = int(
self.UserInterface.SELBaudRate.itemText(
self.UserInterface.SELBaudRate.currentIndex())[0:-5])
self.SerialPort = QtSerialPort.QSerialPort()
self.SerialPort.setPortName(SerialPortName)
self.SerialPort.setBaudRate(SerialPortBaudRate)
self.SerialPortInfo = QtSerialPort.QSerialPortInfo(self.SerialPort)
if not self.SerialPortInfo.isBusy():
try:
self.SerialPort.open(QtSerialPort.QSerialPort.ReadWrite)
self.SerialPort.readyRead.connect(self._SerialPortProcessor)
return True
except:
# Launch QTMessageBox
pass
else:
# Launch QTMessageBox
pass
return False
def toggled_connect(self, checked):
if checked:
i = self.port.index(':')
comPort = self.port[:i]
baudrate = int(flowSens_baud)
self.serial = QtSerialPort.QSerialPort(comPort,
baudRate=baudrate,
readyRead=self.receive)
self.logger.info('Created serial object at %s', comPort)
if not self.serial.isOpen():
if self.serial.open(QtCore.QIODevice.ReadWrite):
self.logger.info(
'successfully opened port (& set mode to ReadWrite)')
self.setConnected(True)
else:
self.logger.warning('could not successfully open port')
self.setConnected(False)
else:
self.setConnected(True)
else:
try:
if self.serial.isOpen():
self.serial.close()
self.logger.info('Closed serial port')
self.setConnected(False)
except AttributeError:
self.logger.debug(
'Cannot close port, serial object does not exist')
def __init__(self):
super().__init__()
self.setupUi(self)
self.serial_port = QtSerialPort.QSerialPort()
self.port_settings: data_types.ComSettings = data_types.ComSettings()
self.text_settings: data_types.TextSettings = data_types.TextSettings()
self.all_macros: List[data_types.MacroSet] = list()
self.current_macros: data_types.MacroSet = data_types.MacroSet(
name="", macros=list())
self.load_macros()
self.counter: int = 0
self.time_shown = False
self.tail = ""
self.file_to_send = ""
self.graph_form = Optional[terminal_graph.MainWindow]
self.graph = False
self.start_time = datetime.datetime.now()
self.settings_form: Optional[settings.Settings] = None
self.macros_form: Optional[macros.Macros] = None
self.ascii_form: Optional[ASCII_table.ASCIITable] = None
self.help_form: Optional[help.Help] = None
self.var_form: Optional[variables.Variables] = variables.Variables()
self.var_form.send_signal[str].connect(self.var_signal_send)
self.current_font = QtGui.QFont("Consolas", 10)
self.apply_styles()
self.macros_btns_list = list()
self.macros_ui()
self.load_settings()
self.serial_port_ui()
self.set_transmitzone_ui()
self.create_connections()
self.init_timer_data()
def __init__(self, parent=None):
super(Dialog, self).__init__()
self.setupUi()
self.arduino = QtSerialPort.QSerialPort()
self.arduino_available = False
# self.__get_information()
self.__configure()
def __init__(self, parent=None):
super(Widget, self).__init__(parent)
self.message_le = QtWidgets.QLineEdit()
self.send_btn = QtWidgets.QPushButton(
text="Send",
clicked=self.send
)
self.output_te = QtWidgets.QTextEdit(readOnly=True)
self.button = QtWidgets.QPushButton(
text="Connect",
checkable=True,
toggled=self.on_toggled
)
lay = QtWidgets.QVBoxLayout(self)
hlay = QtWidgets.QHBoxLayout()
hlay.addWidget(self.message_le)
hlay.addWidget(self.send_btn)
lay.addLayout(hlay)
lay.addWidget(self.output_te)
lay.addWidget(self.button)
self.serial = QtSerialPort.QSerialPort(
'COM5',
baudRate=QtSerialPort.QSerialPort.Baud115200,
readyRead=self.receive
)
def initSerialPort(self):
self.serial_instance = QtSerialPort.QSerialPort()
self.serial_instance.setPortName(self.serial_port_name)
self.serial_instance.setBaudRate(self.serial_baudrate)
self.serial_instance.setDataBits(self.serial_data_bits)
self.serial_instance.setParity(self.serial_parity)
self.serial_instance.setStopBits(self.serial_stop_bits)
def __init__(self, parent=None):
QtWidgets.QWidget.__init__(self, parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.freq_min.setValue(self.param_gps['freq_min'])
self.ui.freq_max.setValue(self.param_gps['freq_max'])
self.ui.freq_step.setValue(self.param_gps['freq_step'])
self.ui.radio_btn_gps.clicked.connect(self.reinit_values)
self.ui.radio_btn_glo.clicked.connect(self.reinit_values)
self.ui.freq_min.editingFinished.connect(self.reinit_param)
self.ui.freq_max.editingFinished.connect(self.reinit_param)
self.ui.freq_step.editingFinished.connect(self.reinit_param)
# self.ui.freq_min.valueChanged.connect(self.reinit_param)
# self.ui.freq_max.valueChanged.connect(self.reinit_param)
# self.ui.freq_step.valueChanged.connect(self.reinit_param)
self.ui.tx_btn.clicked.connect(self.tx_btn_clicked)
self.ui.refresh_btn.clicked.connect(self.refresh_ports)
self.setFixedSize(self.size())
self.refresh_ports()
self.ser_port = QtSerialPort.QSerialPort("COM0",
readyRead=self.receive)
self.msg = []
def open(self):
"""Open the serial port and initialize communications. If the port is already
open, this will close it first. If the current name is None, this will not open
anything. Returns True if the port is open, else False."""
if self._port is not None:
self.close()
if self._portname is None:
log.debug("No port name provided so not opening port.")
return False
return
self._port = QtSerialPort.QSerialPort()
self._port.setBaudRate(115200)
self._port.setPortName(self._portname)
# open the serial port, which should also reset the Arduino
if self._port.open(QtCore.QIODevice.ReadWrite):
log.info("Opened winch serial port %s", self._port.portName())
# always process data as it becomes available
self._port.readyRead.connect(self.read_input)
return True
else:
# Error codes: https://doc.qt.io/qt-5/qserialport.html#SerialPortError-enum
errcode = self._port.error()
if errcode == QtSerialPort.QSerialPort.PermissionError:
log.warning("Failed to open winch serial port %s with a QSerialPort PermissionError, which could involve an already running control process, a stale lock file, or dialout group permissions.", self._port.portName())
else:
log.warning("Failed to open winch serial port %s with a QSerialPort error code %d.", self._port.portName(), errcode)
self._port = None
return False
def getArduinoSerial(self):
print_debug(u"getArduinoSerial")
ports = serial.tools.list_ports.comports(include_links=False)
if len(ports) > 0:
device = False
for port in ports:
if 'ACM' in str(port):
self.arduino = QtSerialPort.QSerialPort(
port.device,
baudRate=QtSerialPort.QSerialPort.Baud9600,
readyRead=self.receive,
)
self.arduino.open(QIODevice.ReadWrite)
self.arduino.flush
if self.arduino.isOpen():
self.serialTimer.stop()
self.portDevice = port.device
device = True
print_debug(u"Device founded : {}".format(
self.portDevice))
self.alarmsManagerTimer.start()
break
if not device:
self.portDevice = u"NON CONNECTÉ"
print_debug("No device found :(")
else:
self.portDevice = u"NON CONNECTÉ"
print_debug(u"len(ports) < 1 :(")
def slot_connection(self):
if self.btn_connection.text(
) == self.btn_connection_name["connect"]: # connect : 연결하기
#활성화할 포트정보를 읽어옵니다.
baudRate = int(self.combo_baudRate.currentText())
portName = '/dev/' + self.combo_portName.currentText()
targetName = self.combo_target.currentText()
#시리얼통신을 관장할 객체를 생성하며 설정합니다.
self._comm = QtSerialPort.QSerialPort()
self._comm.setPortName(portName)
self._comm.setBaudRate(baudRate)
#시리얼 통신을 활성화하며 시리얼 통신포트로부터 수신되는 값을 감시할 스레드를 생성합니다.
self._comm.open(QIODevice.ReadWrite)
self.serialThread = self.serialThreadClass(self._comm, self.fig,
self.line_1, targetName)
self.btn_connection.setText(
self.btn_connection_name['close']) # close : 연결끊기
self.serialThread.start() # 스레드를 실행합니다.
else:
#시리얼포트가 열려있다면, 관련 리소스를 종료합니다.
if self._comm.isOpen() == True:
self.serialThread.stop()
self.serialThread.join()
self._comm.close()
self.btn_connection.setText(
self.btn_connection_name["connect"]) # connect : 연결하기
def __init__(self, device, postman, parent=None):
super(SerialThread, self).__init__(parent)
self.postman = postman
self.device = device
self.data = b''
self.serial = QtSerialPort.QSerialPort(self.device.info)
self.serial.readyRead.connect(self.handleSerial)
self.serial.error.connect(self.handleError)
def change_to_analysis_ui(self, item):
self.startbtn.setEnabled(True)
self.stopbtn.setEnabled(True)
self.checkBox.setEnabled(True)
self.stackedWidget.setCurrentIndex(1)
self.arduino = QtSerialPort.QSerialPort(
self.listWidget.itemWidget(item).name_1.text(),
baudRate=QtSerialPort.QSerialPort.Baud9600)
self.arduino.readyRead.connect(self.ReceiveData)
def __init__(self):
super(test_lunch, self).__init__()
uic.loadUi("lunch.ui", self)
self.CleanAgent = Cleaner()
self.available = False
self.font = QtGui.QFont()
self.font.setFamily("Arial")
self.font.setPointSize(15)
# self.platform = platform.system()
# print(self.platform)
try:
ports = list(serial.tools.list_ports.comports())
for p in ports:
if "0403" in p.hwid:
if p.device:
self.available = True
self.port = p.device
self.serial = QtSerialPort.QSerialPort(
self.port,
baudRate=QtSerialPort.QSerialPort.Baud115200,
readyRead=self.receive)
self.lunch.setStyleSheet("background-color : #fdd835")
else:
self.available = False
if not self.available:
self.lunch.setStyleSheet("background-color : #ef5350")
self.terminal.append(
"Flourine Tracer not detected!! please connect the device and relunch the program"
)
self.terminal.setStyleSheet("color: #ef5350 ")
except Exception:
exc_type, exc_value, exc_traceback = sys.exc_info()
print("*** Exception:", exc_type)
traceback.print_tb(exc_traceback, limit=1, file=sys.stdout)
######################## Buttons #######################################
self.lunch.clicked.connect(self.onClicked)
self.clean_data.clicked.connect(self.openDialog)
self.send_b.clicked.connect(self.send)
self.save_file.clicked.connect(self.saveFile)
### press Enter to send data
self.data_send.setText("send")
self.data_send.returnPressed.connect(self.send)
self.exc_com.clicked.connect(self.excute)
self.restart_bu.clicked.connect(self.restart)
self.clear_bu.clicked.connect(self.clear)
##ComboBox
self.comboBox.addItem(" ")
self.comboBox.addItem("2.5S")
self.comboBox.addItem("3S")
self.comboBox.addItem("5S")
def __init__(self):
super(SerialWidget, self).__init__()
# self.parentWidget = parent
self.ser = QtSerialPort.QSerialPort(
baudRate=QtSerialPort.QSerialPort.Baud115200)
# manage errors with error handler method
self.__connectionsList()
def __init__(self, parent=None):
super(SerialPortWidget, self).__init__()
self.ui = Ui_serialPortWidget()
self.ui.setupUi(self)
self.fillSerialPortFields()
self.serialPort = QtSerialPort.QSerialPort()
self.UpdateLabels()
self.ui.parityBox.currentIndexChanged.connect(self.UpdateLabels)
self.ui.stopBitsBox.currentIndexChanged.connect(self.UpdateLabels)
pass
def open_default_port(cls, protocol):
port_info = [
port for port in QtSerialPort.QSerialPortInfo.availablePorts()
if "arduino" in port.manufacturer().lower()
][0]
print(port_info.systemLocation())
port = QtSerialPort.QSerialPort(port_info)
port.open(QtCore.QIODevice.ReadWrite)
return SerialPortReader(protocol, port)
def __init__(self):
super().__init__()
self.setupUi(self)
self.CBBaudrate.activated.connect(self.baudrate_changed)
self.BtnReScan.clicked.connect(self.scan_ports)
self.BtnConnect.clicked.connect(self.connect)
self.BtnDisconnect.clicked.connect(self.disconnect)
self.BtnClear.clicked.connect(self.clear_pressed)
self.BtnClear.setShortcut('Esc')
self.BtnSend.clicked.connect(self.send_clicked)
self.BtnSend2.clicked.connect(self.send_clicked)
self.BtnCounter.clicked.connect(self.clear_counter)
self.BtnSave.clicked.connect(self.save_to_file)
self.BtnCreateMacros.clicked.connect(self.macros_pressed)
self.TxtTransmit.returnPressed.connect(self.send_clicked)
self.TxtTransmit2.returnPressed.connect(self.send_clicked)
self.BtnSettings.clicked.connect(self.settings_pressed)
self.BtnFile.clicked.connect(self.select_file)
self.BtnSendFile.clicked.connect(self.send_file)
self.BtnAscii.clicked.connect(self.ascii_show)
self.serial_port = QtSerialPort.QSerialPort()
self.serial_port.readyRead.connect(self.read_data)
self.serial_port.errorOccurred.connect(self.serial_error)
self.port_settings: data_types.ComSettings = data_types.ComSettings()
self.text_settings: data_types.TextSettings = data_types.TextSettings()
self.scan_ports()
self.all_macros: List[data_types.MacroSet] = list()
self.current_macros: data_types.MacroSet = data_types.MacroSet(name="", macros=list())
self.load_macros()
self.counter: int = 0
self.file_to_send = ""
self.start_time = datetime.datetime.now()
self.settings_form: Optional[settings.Settings] = None
self.macros_form: Optional[macros.Macros] = None
self.ascii_form: Optional[ASCII_table.ASCIITable] = None
self.colors: Dict[str, Tuple[int, int, int]] = \
{'background-color': (255, 255, 255), 'font-transmit': (50, 250, 00), 'font-receive': (0, 0, 0),
'bytes-color': (255, 0, 0)}
self.CBBaudrate.setCurrentText('115200')
self.current_font = QtGui.QFont("Consolas", 10)
self.TxtBuffer.setFont(self.current_font)
self.TxtBuffer.setTextBackgroundColor(QtGui.QColor(*self.colors['background-color']))
self.TxtBuffer.setTextColor(QtGui.QColor(*self.colors['font-transmit']))
self.macros_btns_list = [self.BtnMacros1, self.BtnMacros2, self.BtnMacros3, self.BtnMacros4, self.BtnMacros5,
self.BtnMacros6, self.BtnMacros7, self.BtnMacros8, self.BtnMacros9, self.BtnMacros10,
self.BtnMacros11, self.BtnMacros12, self.BtnMacros13, self.BtnMacros14,
self.BtnMacros15, self.BtnMacros16, self.BtnMacros17, self.BtnMacros18,
self.BtnMacros19, self.BtnMacros20]
for btn in self.macros_btns_list:
btn.clicked.connect(self.macro_btn_pressed)
self.CBMacros.currentTextChanged.connect(self.macros_selected)
self.load_settings()
def __init__(self, *args, **kwargs):
super(Ui, self).__init__(*args, **kwargs)
uic.loadUi('terminal_display.ui', self)
self.serialData = QByteArray().append("created ")
self.receivedData = QByteArray()
self.transmitData = QByteArray()
self.serialPort = QtSerialPort.QSerialPort()
self.serialPort.setPortName("COM10")
self.serialPort.setBaudRate(115200)
self.serialPort.setFlowControl(self.serialPort.NoFlowControl)
self.serialPort.setStopBits(self.serialPort.OneStop)
self.serialPort.readyRead.connect(self.onreadyread)
self.serialPort.bytesWritten.connect(self.onbyteswritten)
ports = QtSerialPort.QSerialPortInfo.availablePorts()
print(ports)
for eachPort in ports:
print(eachPort.portName())
print("open : ", self.serialPort.open(QtCore.QIODevice.ReadWrite),
self.serialPort.portName())
self.packet = b''
self.packetCounter = 0
palette = QPalette()
palette.setColor(QPalette.Window, QColor(53, 53, 53))
palette.setColor(QPalette.WindowText, QColor(255, 255, 255))
palette.setColor(QPalette.Base, QColor(25, 25, 25))
palette.setColor(QPalette.AlternateBase, QColor(53, 53, 53))
palette.setColor(QPalette.ToolTipBase, QColor(255, 255, 255))
palette.setColor(QPalette.ToolTipText, QColor(255, 255, 255))
palette.setColor(QPalette.Text, QColor(255, 255, 255))
palette.setColor(QPalette.Button, QColor(53, 53, 53))
palette.setColor(QPalette.ButtonText, QColor(255, 255, 255))
palette.setColor(QPalette.BrightText, QColor(255, 255, 255))
palette.setColor(QPalette.Link, QColor(42, 130, 218))
palette.setColor(QPalette.Highlight, QColor(42, 130, 218))
palette.setColor(QPalette.HighlightedText, QColor(0, 0, 0))
app.setPalette(palette)
'''
self.testTimer = QTimer()
self.testTimer.setInterval(10)
self.testTimer.timeout.connect(self.timeToSend)
self.i=0
self.counter=0
self.formattedi=""
self.bytearrayToSend=QByteArray(4,'a')
self.testTimer.start()
'''
self.show()
def __init__(self):
self.SerialPort = QtSerialPort.QSerialPort()
self.SerialPort.setBaudRate(115200)
self.SerialPort.setPortName("COM8")
self.SerialPort.readyRead.connect(self.ReadData)
self.DATA_WAIT_SIZE = 0
self.DATA_BUFFER = QByteArray()
self.DATA_MESSAGE = QByteArray()
self.FLAG_WAIT_DATA = False
def __init__(self,
port,
baud=115200,
samples=255,
min_value=0,
max_value=1023,
**kwargs):
super(SerialPlotter, self).__init__(**kwargs)
self._serial_port = port
self._serial_port_baud = baud
self.samples = samples
self.series = []
self.data = []
# set up chart
self.setWindowTitle('Serial Plotter')
self.setContentsMargins(0, 0, 0, 0)
self.chart = QtChart.QChart()
self.chart.setTheme(QtChart.QChart.ChartThemeDark)
# remove the annoying white border
self.chart.layout().setContentsMargins(0, 0, 0, 0)
self.chart.setBackgroundRoundness(0)
# set up chart view
self.chart_view = QtChart.QChartView(self.chart)
self.chart_view.setRenderHint(QtGui.QPainter.Antialiasing)
self.chart_view.setMinimumSize(800, 600)
# set up axis
self.x_axis = QtChart.QValueAxis()
self.x_axis.setRange(0, self.samples)
self.x_axis.setTitleText('Samples')
self.x_axis.setLabelFormat('%i')
self.y_axis = QtChart.QValueAxis()
self.y_axis.setRange(min_value, max_value)
self.y_axis.setTitleText('Values')
self.chart.addAxis(self.x_axis, Qt.AlignBottom)
self.chart.addAxis(self.y_axis, Qt.AlignLeft)
self.setCentralWidget(self.chart_view)
# Setup the serial port
self.serial = QtSerialPort.QSerialPort(
self._serial_port,
baudRate=self._serial_port_baud,
readyRead=self.on_serial_ready_read,
)
if not self.serial.open(QtCore.QIODevice.ReadWrite):
print('can\'t open serial port')
sys.exit(1)
self.show()
def __init__(self, serial_path,
baud_rate: QtSerialPort.QSerialPort.BaudRate):
super(ControllerRepository, self).__init__()
baud = map_baud_rate(baud_rate)
self.serial = QtSerialPort.QSerialPort(serial_path,
baudRate=baud,
readyRead=self.on_data_read)
self.signals = ControllerRepositorySignal()
self.serial.errorOccurred.connect(self.error)
self.signals.write_data.connect(self.on_write_data)
self.isOpen = False
self.signals.open.connect(self.on_open)
self.signals.close.connect(self.on_close)
def __init__(self):
super(mainApp, self).__init__()
loadUi("/home/didik/GUI-PyQty5-Projects/Serial Arduino LED Control V2/serialV2.ui", self)
#self.setWindowTitle("HELLO!")
self.sendON = '1'
self.sendOFF = '0'
self.on_btn.clicked.connect(self.onButton)
self.off_btn.clicked.connect(self.offButton)
self.connect_btn.clicked.connect(self.on_toggled)
self.serial = QtSerialPort.QSerialPort(
'/dev/ttyUSB0',
baudRate=QtSerialPort.QSerialPort.Baud9600,
)
def connect(self):
port = self.combo_ports.currentText()
print("Connecting to %s" % port)
self.serial = QtSerialPort.QSerialPort(
port,
baudRate=QtSerialPort.QSerialPort.Baud9600,
readyRead=self.receive)
if not self.serial.open(QIODevice.ReadWrite):
self.button_connect.setText('Connect')
else:
self.button_connect.setText('Disconnect')
if (self.check_date.checkState()):
self.setDateTime()
def open_dmx_output(self, name):
if self.dmxport is not None:
self.dmxport.close()
self.dmxport = None
self.dmxport = QtSerialPort.QSerialPort()
self.dmxport.setBaudRate(115200)
self.dmxport.setPortName(name)
if self.dmxport.open(QtCore.QIODevice.ReadWrite):
self.window.write("Opened DMX port %s" % self.dmxport.portName())
self.dmxport.readyRead.connect(self.dmx_data_received)
else:
self.window.write("Error opening DMX port %s" % self.dmxport.portName())
self.dmxport = None
def on_connect(self): #connect button has been pressed
self.serial = QtSerialPort.QSerialPort(
self.comboBox.currentText(),
baudRate=QtSerialPort.QSerialPort.Baud9600,
readyRead=self.receive)
self.Cbutton.setEnabled(False)
self.Dbutton.setEnabled(True)
self.MessageLabel.setText(
'Trying to connect to Arduino'
) #Trying to connect to Arduino - please wait
self.MessageLabel.repaint()
self.Cbutton.repaint()
self.Dbutton.repaint()
if not self.serial.isOpen():
if not self.serial.open(QtCore.QIODevice.ReadWrite):
self.button.setChecked(False)
def UpdateLabels(self):
dict_parity = {
QtSerialPort.QSerialPort().NoParity: "No Parity",
QtSerialPort.QSerialPort().EvenParity: "Even Parity",
QtSerialPort.QSerialPort().OddParity: "Odd Parity",
QtSerialPort.QSerialPort().SpaceParity: "Space Parity",
QtSerialPort.QSerialPort().MarkParity: "MarkParity"
}
dict_stopBits = {
QtSerialPort.QSerialPort().OneStop: "One Stop",
QtSerialPort.QSerialPort().TwoStop: "Two Stop",
QtSerialPort.QSerialPort().OneAndHalfStop: "1,5 Stop",
}
label = dict_parity[int(self.ui.parityBox.currentText())]
self.ui.parityInformation.setText(label)
label = dict_stopBits[int(self.ui.stopBitsBox.currentText())]
self.ui.StopBitsInformation.setText(label)
pass
def __init__(self):
QMainWindow.__init__(self)
Ui_Main.__init__(self)
self.setupUi(self)
self.get_saved_ingredients()
self.update_drink_list()
self.serial = QtSerialPort.QSerialPort('/dev/ttyACM0',
readyRead=self.receive)
self.serial.open(QtCore.QIODevice.OpenModeFlag.ReadWrite)
if not self.serial.isOpen():
print("Initializing without Serial.")
self.loadingDialog = LoadingDialog(self)
self.passwordDialog = PasswordDialog(self)
self.settingsDialog = SettingsDialog(self)
self.init_animations()
self.setWindowTitle("Choisissez une boisson!")
self.settings.clicked.connect(self.open_password)
def __init__(self, port_name: str) -> None:
"""Inicialize."""
super().__init__()
if str(QtCore.QSysInfo()) == "ios":
from pineboolib.q3widgets.messagebox import MessageBox
MessageBox.information(
None,
self.tr("Opción deshabilitada"),
self.tr("FLSerialPort no está disponible para IOS"),
MessageBox.Ok,
)
return
else:
from PyQt5 import QtSerialPort # type: ignore [attr-defined] # noqa: F821
self._obj = QtSerialPort.QSerialPort(port_name)
def setSerial(self, deviceName, baudRate):
deviceName = deviceName.lstrip("ASRL").rstrip("::INSTR")
baudMap = {
"1200": QtSerialPort.QSerialPort.Baud1200,
"2400": QtSerialPort.QSerialPort.Baud2400,
"4800": QtSerialPort.QSerialPort.Baud4800,
"9600": QtSerialPort.QSerialPort.Baud9600,
"19200": QtSerialPort.QSerialPort.Baud19200,
"38400": QtSerialPort.QSerialPort.Baud38400,
"57600": QtSerialPort.QSerialPort.Baud57600,
"115200": QtSerialPort.QSerialPort.Baud115200,
}
self.serial = QtSerialPort.QSerialPort(deviceName,
baudRate=baudMap[baudRate],
readyRead=self.receive)
self.serial.open(QIODevice.ReadOnly)
print(self.serial.isOpen())
