class MainWindow(QMainWindow):
receiveUpdateSignal = pyqtSignal(str)
errorSignal = pyqtSignal(str)
showSerialComboboxSignal = pyqtSignal()
setDisableSettingsSignal = pyqtSignal(bool)
isDetectSerialPort = False
receiveCount = 0
sendCount = 0
isScheduledSending = False
DataPath = "./"
isHideSettings = False
isHideFunctinal = True
app = None
isWaveOpen = False
def __init__(self,app):
super().__init__()
self.app = app
pathDirList = sys.argv[0].replace("\\", "/").split("/")
pathDirList.pop()
self.DataPath = os.path.abspath("/".join(str(i) for i in pathDirList))
if not os.path.exists(self.DataPath + "/" + parameters.strDataDirName):
pathDirList.pop()
self.DataPath = os.path.abspath("/".join(str(i) for i in pathDirList))
self.DataPath = (self.DataPath + "/" + parameters.strDataDirName).replace("\\", "/")
self.initVar()
self.initWindow()
self.initTool()
self.initEvent()
self.programStartGetSavedParameters()
def __del__(self):
pass
def initTool(self):
self.com = serial.Serial()
def initVar(self):
self.keyControlPressed = False
self.baudrateCustomStr = "custom, input baudrate"
def initWindow(self):
QToolTip.setFont(QFont('SansSerif', 10))
# main layout
frameWidget = QWidget()
mainWidget = QSplitter(Qt.Horizontal)
frameLayout = QVBoxLayout()
self.settingWidget = QWidget()
self.settingWidget.setProperty("class","settingWidget")
self.receiveSendWidget = QSplitter(Qt.Vertical)
self.functionalWiget = QWidget()
settingLayout = QVBoxLayout()
sendReceiveLayout = QVBoxLayout()
sendFunctionalLayout = QVBoxLayout()
mainLayout = QHBoxLayout()
self.settingWidget.setLayout(settingLayout)
self.receiveSendWidget.setLayout(sendReceiveLayout)
self.functionalWiget.setLayout(sendFunctionalLayout)
mainLayout.addWidget(self.settingWidget)
mainLayout.addWidget(self.receiveSendWidget)
mainLayout.addWidget(self.functionalWiget)
mainLayout.setStretch(0,2)
mainLayout.setStretch(1, 6)
mainLayout.setStretch(2, 2)
menuLayout = QHBoxLayout()
mainWidget.setLayout(mainLayout)
frameLayout.addLayout(menuLayout)
frameLayout.addWidget(mainWidget)
frameWidget.setLayout(frameLayout)
self.setCentralWidget(frameWidget)
# option layout
self.settingsButton = QPushButton()
self.skinButton = QPushButton("")
# self.waveButton = QPushButton("")
self.aboutButton = QPushButton()
self.functionalButton = QPushButton()
self.encodingCombobox = ComboBox()
self.encodingCombobox.addItem("ASCII")
self.encodingCombobox.addItem("UTF-8")
self.encodingCombobox.addItem("UTF-16")
self.encodingCombobox.addItem("GBK")
self.encodingCombobox.addItem("GB2312")
self.encodingCombobox.addItem("GB18030")
self.settingsButton.setProperty("class", "menuItem1")
self.skinButton.setProperty("class", "menuItem2")
self.aboutButton.setProperty("class", "menuItem3")
self.functionalButton.setProperty("class", "menuItem4")
# self.waveButton.setProperty("class", "menuItem5")
self.settingsButton.setObjectName("menuItem")
self.skinButton.setObjectName("menuItem")
self.aboutButton.setObjectName("menuItem")
self.functionalButton.setObjectName("menuItem")
# self.waveButton.setObjectName("menuItem")
menuLayout.addWidget(self.settingsButton)
menuLayout.addWidget(self.skinButton)
# menuLayout.addWidget(self.waveButton)
menuLayout.addWidget(self.aboutButton)
menuLayout.addStretch(0)
menuLayout.addWidget(self.encodingCombobox)
menuLayout.addWidget(self.functionalButton)
# widgets receive and send area
self.receiveArea = QTextEdit()
self.sendArea = QTextEdit()
self.clearReceiveButtion = QPushButton(parameters.strClearReceive)
self.sendButtion = QPushButton(parameters.strSend)
self.sendHistory = ComboBox()
sendWidget = QWidget()
sendAreaWidgetsLayout = QHBoxLayout()
sendWidget.setLayout(sendAreaWidgetsLayout)
buttonLayout = QVBoxLayout()
buttonLayout.addWidget(self.clearReceiveButtion)
buttonLayout.addStretch(1)
buttonLayout.addWidget(self.sendButtion)
sendAreaWidgetsLayout.addWidget(self.sendArea)
sendAreaWidgetsLayout.addLayout(buttonLayout)
sendReceiveLayout.addWidget(self.receiveArea)
sendReceiveLayout.addWidget(sendWidget)
sendReceiveLayout.addWidget(self.sendHistory)
sendReceiveLayout.setStretch(0, 7)
sendReceiveLayout.setStretch(1, 2)
sendReceiveLayout.setStretch(2, 1)
# widgets serial settings
serialSettingsGroupBox = QGroupBox(parameters.strSerialSettings)
serialSettingsLayout = QGridLayout()
serialReceiveSettingsLayout = QGridLayout()
serialSendSettingsLayout = QGridLayout()
serialPortLabek = QLabel(parameters.strSerialPort)
serailBaudrateLabel = QLabel(parameters.strSerialBaudrate)
serailBytesLabel = QLabel(parameters.strSerialBytes)
serailParityLabel = QLabel(parameters.strSerialParity)
serailStopbitsLabel = QLabel(parameters.strSerialStopbits)
self.serialPortCombobox = ComboBox()
self.serailBaudrateCombobox = ComboBox()
self.serailBaudrateCombobox.addItem("9600")
self.serailBaudrateCombobox.addItem("19200")
self.serailBaudrateCombobox.addItem("38400")
self.serailBaudrateCombobox.addItem("57600")
self.serailBaudrateCombobox.addItem("74880")
self.serailBaudrateCombobox.addItem("115200")
self.serailBaudrateCombobox.addItem("921600")
self.serailBaudrateCombobox.addItem("1000000")
self.serailBaudrateCombobox.addItem("1500000")
self.serailBaudrateCombobox.addItem("2000000")
self.serailBaudrateCombobox.addItem("4500000")
self.serailBaudrateCombobox.addItem(self.baudrateCustomStr)
self.serailBaudrateCombobox.setCurrentIndex(4)
self.serailBaudrateCombobox.setEditable(True)
self.serailBytesCombobox = ComboBox()
self.serailBytesCombobox.addItem("5")
self.serailBytesCombobox.addItem("6")
self.serailBytesCombobox.addItem("7")
self.serailBytesCombobox.addItem("8")
self.serailBytesCombobox.setCurrentIndex(3)
self.serailParityCombobox = ComboBox()
self.serailParityCombobox.addItem("None")
self.serailParityCombobox.addItem("Odd")
self.serailParityCombobox.addItem("Even")
self.serailParityCombobox.addItem("Mark")
self.serailParityCombobox.addItem("Space")
self.serailParityCombobox.setCurrentIndex(0)
self.serailStopbitsCombobox = ComboBox()
self.serailStopbitsCombobox.addItem("1")
self.serailStopbitsCombobox.addItem("1.5")
self.serailStopbitsCombobox.addItem("2")
self.serailStopbitsCombobox.setCurrentIndex(0)
self.checkBoxRts = QCheckBox("rts")
self.checkBoxDtr = QCheckBox("dtr")
self.serialOpenCloseButton = QPushButton(parameters.strOpen)
serialSettingsLayout.addWidget(serialPortLabek,0,0)
serialSettingsLayout.addWidget(serailBaudrateLabel, 1, 0)
serialSettingsLayout.addWidget(serailBytesLabel, 2, 0)
serialSettingsLayout.addWidget(serailParityLabel, 3, 0)
serialSettingsLayout.addWidget(serailStopbitsLabel, 4, 0)
serialSettingsLayout.addWidget(self.serialPortCombobox, 0, 1)
serialSettingsLayout.addWidget(self.serailBaudrateCombobox, 1, 1)
serialSettingsLayout.addWidget(self.serailBytesCombobox, 2, 1)
serialSettingsLayout.addWidget(self.serailParityCombobox, 3, 1)
serialSettingsLayout.addWidget(self.serailStopbitsCombobox, 4, 1)
serialSettingsLayout.addWidget(self.checkBoxRts, 5, 0,1,1)
serialSettingsLayout.addWidget(self.checkBoxDtr, 5, 1,1,1)
serialSettingsLayout.addWidget(self.serialOpenCloseButton, 6, 0,1,2)
serialSettingsGroupBox.setLayout(serialSettingsLayout)
settingLayout.addWidget(serialSettingsGroupBox)
# serial receive settings
serialReceiveSettingsGroupBox = QGroupBox(parameters.strSerialReceiveSettings)
self.receiveSettingsAscii = QRadioButton(parameters.strAscii)
self.receiveSettingsHex = QRadioButton(parameters.strHex)
self.receiveSettingsAscii.setChecked(True)
self.receiveSettingsAutoLinefeed = QCheckBox(parameters.strAutoLinefeed)
self.receiveSettingsAutoLinefeedTime = QLineEdit(parameters.strAutoLinefeedTime)
self.receiveSettingsAutoLinefeed.setMaximumWidth(75)
self.receiveSettingsAutoLinefeedTime.setMaximumWidth(75)
serialReceiveSettingsLayout.addWidget(self.receiveSettingsAscii,1,0,1,1)
serialReceiveSettingsLayout.addWidget(self.receiveSettingsHex,1,1,1,1)
serialReceiveSettingsLayout.addWidget(self.receiveSettingsAutoLinefeed, 2, 0, 1, 1)
serialReceiveSettingsLayout.addWidget(self.receiveSettingsAutoLinefeedTime, 2, 1, 1, 1)
serialReceiveSettingsGroupBox.setLayout(serialReceiveSettingsLayout)
settingLayout.addWidget(serialReceiveSettingsGroupBox)
# serial send settings
serialSendSettingsGroupBox = QGroupBox(parameters.strSerialSendSettings)
self.sendSettingsAscii = QRadioButton(parameters.strAscii)
self.sendSettingsHex = QRadioButton(parameters.strHex)
self.sendSettingsAscii.setChecked(True)
self.sendSettingsScheduledCheckBox = QCheckBox(parameters.strScheduled)
self.sendSettingsScheduled = QLineEdit(parameters.strScheduledTime)
self.sendSettingsScheduledCheckBox.setMaximumWidth(75)
self.sendSettingsScheduled.setMaximumWidth(75)
self.sendSettingsCFLF = QCheckBox(parameters.strCRLF)
self.sendSettingsCFLF.setChecked(False)
serialSendSettingsLayout.addWidget(self.sendSettingsAscii,1,0,1,1)
serialSendSettingsLayout.addWidget(self.sendSettingsHex,1,1,1,1)
serialSendSettingsLayout.addWidget(self.sendSettingsScheduledCheckBox, 2, 0, 1, 1)
serialSendSettingsLayout.addWidget(self.sendSettingsScheduled, 2, 1, 1, 1)
serialSendSettingsLayout.addWidget(self.sendSettingsCFLF, 3, 0, 1, 2)
serialSendSettingsGroupBox.setLayout(serialSendSettingsLayout)
settingLayout.addWidget(serialSendSettingsGroupBox)
settingLayout.setStretch(0, 5)
settingLayout.setStretch(1, 2.5)
settingLayout.setStretch(2, 2.5)
# right functional layout
self.filePathWidget = QLineEdit()
self.openFileButton = QPushButton("Open File")
self.sendFileButton = QPushButton("Send File")
self.clearHistoryButton = QPushButton("Clear History")
self.addButton = QPushButton(parameters.strAdd)
fileSendGroupBox = QGroupBox(parameters.strSendFile)
fileSendGridLayout = QGridLayout()
fileSendGridLayout.addWidget(self.filePathWidget, 0, 0, 1, 1)
fileSendGridLayout.addWidget(self.openFileButton, 0, 1, 1, 1)
fileSendGridLayout.addWidget(self.sendFileButton, 1, 0, 1, 2)
fileSendGroupBox.setLayout(fileSendGridLayout)
sendFunctionalLayout.addWidget(fileSendGroupBox)
sendFunctionalLayout.addWidget(self.clearHistoryButton)
sendFunctionalLayout.addWidget(self.addButton)
sendFunctionalLayout.addStretch(1)
self.isHideFunctinal = True
self.hideFunctional()
# main window
self.statusBarStauts = QLabel()
self.statusBarStauts.setMinimumWidth(80)
self.statusBarStauts.setText("<font color=%s>%s</font>" %("#008200", parameters.strReady))
self.statusBarSendCount = QLabel(parameters.strSend+"(bytes): "+"0")
self.statusBarReceiveCount = QLabel(parameters.strReceive+"(bytes): "+"0")
self.statusBar().addWidget(self.statusBarStauts)
self.statusBar().addWidget(self.statusBarSendCount,2)
self.statusBar().addWidget(self.statusBarReceiveCount,3)
# self.statusBar()
self.resize(800, 500)
self.MoveToCenter()
self.setWindowTitle(parameters.appName+" V"+str(helpAbout.versionMajor)+"."+str(helpAbout.versionMinor))
icon = QIcon()
print("icon path:"+self.DataPath+"/"+parameters.appIcon)
icon.addPixmap(QPixmap(self.DataPath+"/"+parameters.appIcon), QIcon.Normal, QIcon.Off)
self.setWindowIcon(icon)
if sys.platform == "win32":
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID("comtool")
self.show()
print("config file path:",parameters.configFilePath)
def initEvent(self):
self.serialOpenCloseButton.clicked.connect(self.openCloseSerial)
self.sendButtion.clicked.connect(self.sendData)
self.receiveUpdateSignal.connect(self.updateReceivedDataDisplay)
self.clearReceiveButtion.clicked.connect(self.clearReceiveBuffer)
self.serialPortCombobox.clicked.connect(self.portComboboxClicked)
self.serailBaudrateCombobox.currentIndexChanged.connect(self.baudrateIndexChanged)
self.serailBaudrateCombobox.editTextChanged.connect(self.baudrateIndexChanged)
self.sendSettingsHex.clicked.connect(self.onSendSettingsHexClicked)
self.sendSettingsAscii.clicked.connect(self.onSendSettingsAsciiClicked)
self.errorSignal.connect(self.errorHint)
self.showSerialComboboxSignal.connect(self.showCombobox)
# self.showBaudComboboxSignal.connect(self.showBaudCombobox)
self.setDisableSettingsSignal.connect(self.setDisableSettings)
self.sendHistory.currentIndexChanged.connect(self.sendHistoryIndexChanged)
self.settingsButton.clicked.connect(self.showHideSettings)
self.skinButton.clicked.connect(self.skinChange)
self.aboutButton.clicked.connect(self.showAbout)
self.openFileButton.clicked.connect(self.selectFile)
self.sendFileButton.clicked.connect(self.sendFile)
self.clearHistoryButton.clicked.connect(self.clearHistory)
self.addButton.clicked.connect(self.functionAdd)
self.functionalButton.clicked.connect(self.showHideFunctional)
self.sendArea.currentCharFormatChanged.connect(self.sendAreaFontChanged)
# self.waveButton.clicked.connect(self.openWaveDisplay)
self.checkBoxRts.clicked.connect(self.rtsChanged)
self.checkBoxDtr.clicked.connect(self.dtrChanged)
self.myObject=MyClass(self)
slotLambda = lambda: self.indexChanged_lambda(self.myObject)
self.serialPortCombobox.currentIndexChanged.connect(slotLambda)
# @QtCore.pyqtSlot(str)
def indexChanged_lambda(self, obj):
mainObj = obj.arg
# print("item changed:",mainObj.serialPortCombobox.currentText())
self.serialPortCombobox.setToolTip(mainObj.serialPortCombobox.currentText())
def openCloseSerialProcess(self):
try:
if self.com.is_open:
self.receiveProgressStop = True
self.com.close()
self.setDisableSettingsSignal.emit(False)
else:
try:
self.com.baudrate = int(self.serailBaudrateCombobox.currentText())
self.com.port = self.serialPortCombobox.currentText().split(" ")[0]
if not self.com.port:
raise Exception("please select port")
self.com.bytesize = int(self.serailBytesCombobox.currentText())
self.com.parity = self.serailParityCombobox.currentText()[0]
self.com.stopbits = float(self.serailStopbitsCombobox.currentText())
self.com.timeout = None
if self.checkBoxRts.isChecked():
self.com.rts = False
else:
self.com.rts = True
if self.checkBoxDtr.isChecked():
self.com.dtr = False
else:
self.com.dtr = True
self.com.open()
# print("open success")
# print(self.com)
self.setDisableSettingsSignal.emit(True)
self.receiveProcess = threading.Thread(target=self.receiveData)
self.receiveProcess.setDaemon(True)
self.receiveProcess.start()
except Exception as e:
self.com.close()
self.receiveProgressStop = True
self.errorSignal.emit( parameters.strOpenFailed +"\n"+ str(e))
self.setDisableSettingsSignal.emit(False)
except Exception as e:
print(e)
def setDisableSettings(self, disable):
if disable:
self.serialOpenCloseButton.setText(parameters.strClose)
self.statusBarStauts.setText("<font color=%s>%s</font>" % ("#008200", parameters.strReady))
self.serialPortCombobox.setDisabled(True)
self.serailBaudrateCombobox.setDisabled(True)
self.serailParityCombobox.setDisabled(True)
self.serailStopbitsCombobox.setDisabled(True)
self.serailBytesCombobox.setDisabled(True)
self.serialOpenCloseButton.setDisabled(False)
else:
self.serialOpenCloseButton.setText(parameters.strOpen)
self.statusBarStauts.setText("<font color=%s>%s</font>" % ("#f31414", parameters.strClosed))
self.serialPortCombobox.setDisabled(False)
self.serailBaudrateCombobox.setDisabled(False)
self.serailParityCombobox.setDisabled(False)
self.serailStopbitsCombobox.setDisabled(False)
self.serailBytesCombobox.setDisabled(False)
self.programExitSaveParameters()
def openCloseSerial(self):
t = threading.Thread(target=self.openCloseSerialProcess)
t.setDaemon(True)
t.start()
def rtsChanged(self):
if self.checkBoxRts.isChecked():
self.com.setRTS(False)
else:
self.com.setRTS(True)
def dtrChanged(self):
if self.checkBoxDtr.isChecked():
self.com.setDTR(False)
else:
self.com.setDTR(True)
def portComboboxClicked(self):
self.detectSerialPort()
def getSendData(self):
data = self.sendArea.toPlainText()
if self.sendSettingsCFLF.isChecked():
data = data.replace("\n", "\r\n")
if self.sendSettingsHex.isChecked():
if self.sendSettingsCFLF.isChecked():
data = data.replace("\r\n", " ")
else:
data = data.replace("\n", " ")
data = self.hexStringB2Hex(data)
if data == -1:
self.errorSignal.emit( parameters.strWriteFormatError)
return -1
else:
data = data.encode(self.encodingCombobox.currentText(),"ignore")
return data
def sendData(self):
try:
if self.com.is_open:
data = self.getSendData()
if data == -1:
return
# print(self.sendArea.toPlainText())
# print("send:",data)
self.sendCount += len(data)
self.com.write(data)
data = self.sendArea.toPlainText()
self.sendHistoryFindDelete(data)
self.sendHistory.insertItem(0,data)
self.sendHistory.setCurrentIndex(0)
self.receiveUpdateSignal.emit("")
# scheduled send
if self.sendSettingsScheduledCheckBox.isChecked():
if not self.isScheduledSending:
t = threading.Thread(target=self.scheduledSend)
t.setDaemon(True)
t.start()
except Exception as e:
self.errorSignal.emit(parameters.strWriteError)
# print(e)
def scheduledSend(self):
self.isScheduledSending = True
while self.sendSettingsScheduledCheckBox.isChecked():
self.sendData()
try:
time.sleep(int(self.sendSettingsScheduled.text().strip())/1000)
except Exception:
self.errorSignal.emit(parameters.strTimeFormatError)
self.isScheduledSending = False
def receiveData(self):
self.receiveProgressStop = False
self.timeLastReceive = 0
while(not self.receiveProgressStop):
try:
# length = self.com.in_waiting
length = max(1, min(2048, self.com.in_waiting))
bytes = self.com.read(length)
if bytes!= None:
# if self.isWaveOpen:
# self.wave.displayData(bytes)
self.receiveCount += len(bytes)
if self.receiveSettingsAutoLinefeed.isChecked():
if time.time() - self.timeLastReceive> int(self.receiveSettingsAutoLinefeedTime.text())/1000:
if self.sendSettingsCFLF.isChecked():
self.receiveUpdateSignal.emit("\r\n")
else:
self.receiveUpdateSignal.emit("\n")
self.timeLastReceive = time.time()
if self.receiveSettingsHex.isChecked():
strReceived = self.asciiB2HexString(bytes)
self.receiveUpdateSignal.emit(strReceived)
else:
self.receiveUpdateSignal.emit(bytes.decode(self.encodingCombobox.currentText(),"ignore"))
except Exception as e:
# print("receiveData error")
# if self.com.is_open and not self.serialPortCombobox.isEnabled():
# self.openCloseSerial()
# self.serialPortCombobox.clear()
# self.detectSerialPort()
if 'multiple access' in str(e):
self.errorSignal.emit("device disconnected or multiple access on port?")
break
# time.sleep(0.009)
def updateReceivedDataDisplay(self,str):
if str != "":
curScrollValue = self.receiveArea.verticalScrollBar().value()
self.receiveArea.moveCursor(QTextCursor.End)
endScrollValue = self.receiveArea.verticalScrollBar().value()
self.receiveArea.insertPlainText(str)
if curScrollValue < endScrollValue:
self.receiveArea.verticalScrollBar().setValue(curScrollValue)
else:
self.receiveArea.moveCursor(QTextCursor.End)
self.statusBarSendCount.setText("%s(bytes):%d" %(parameters.strSend ,self.sendCount))
self.statusBarReceiveCount.setText("%s(bytes):%d" %(parameters.strReceive ,self.receiveCount))
def onSendSettingsHexClicked(self):
data = self.sendArea.toPlainText().replace("\n","\r\n")
data = self.asciiB2HexString(data.encode())
self.sendArea.clear()
self.sendArea.insertPlainText(data)
def onSendSettingsAsciiClicked(self):
try:
data = self.sendArea.toPlainText().replace("\n"," ").strip()
self.sendArea.clear()
if data != "":
data = self.hexStringB2Hex(data).decode(self.encodingCombobox.currentText(),'ignore')
self.sendArea.insertPlainText(data)
except Exception as e:
# QMessageBox.information(self,parameters.strWriteFormatError,parameters.strWriteFormatError)
print("format error")
def baudrateIndexChanged(self):
if self.serailBaudrateCombobox.currentText() == self.baudrateCustomStr:
self.serailBaudrateCombobox.clearEditText()
def sendHistoryIndexChanged(self):
self.sendArea.clear()
self.sendArea.insertPlainText(self.sendHistory.currentText())
def clearReceiveBuffer(self):
self.receiveArea.clear()
self.receiveCount = 0
self.sendCount = 0
self.receiveUpdateSignal.emit(None)
def MoveToCenter(self):
qr = self.frameGeometry()
cp = QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
def errorHint(self,str):
QMessageBox.information(self, str, str)
def closeEvent(self, event):
reply = QMessageBox.question(self, 'Sure To Quit?',
"Are you sure to quit?", QMessageBox.Yes |
QMessageBox.No, QMessageBox.No)
if reply == QMessageBox.Yes:
self.com.close()
self.receiveProgressStop = True
self.programExitSaveParameters()
event.accept()
else:
event.ignore()
def findSerialPort(self):
self.port_list = list(serial.tools.list_ports.comports())
return self.port_list
def portChanged(self):
self.serialPortCombobox.setCurrentIndex(0)
self.serialPortCombobox.setToolTip(str(self.portList[0]))
def detectSerialPort(self):
if not self.isDetectSerialPort:
self.isDetectSerialPort = True
t = threading.Thread(target=self.detectSerialPortProcess)
t.setDaemon(True)
t.start()
def showCombobox(self):
self.serialPortCombobox.showPopup()
def detectSerialPortProcess(self):
while(1):
portList = self.findSerialPort()
if len(portList)>0:
currText = self.serialPortCombobox.currentText()
self.serialPortCombobox.clear()
for i in portList:
showStr = str(i[0])+" "+str(i[1])
if i[0].startswith("/dev/cu.Bluetooth-Incoming-Port"):
continue
self.serialPortCombobox.addItem(showStr)
index = self.serialPortCombobox.findText(currText)
if index>=0:
self.serialPortCombobox.setCurrentIndex(index)
else:
self.serialPortCombobox.setCurrentIndex(0)
break
time.sleep(1)
self.showSerialComboboxSignal.emit()
self.isDetectSerialPort = False
def sendHistoryFindDelete(self,str):
self.sendHistory.removeItem(self.sendHistory.findText(str))
def asciiB2HexString(self,strB):
strHex = binascii.b2a_hex(strB).upper()
return re.sub(r"(?<=\w)(?=(?:\w\w)+$)", " ", strHex.decode())+" "
def hexStringB2Hex(self,hexString):
dataList = hexString.split(" ")
j = 0
for i in dataList:
if len(i) > 2:
return -1
elif len(i) == 1:
dataList[j] = "0" + i
j += 1
data = "".join(dataList)
try:
data = bytes.fromhex(data)
except Exception:
return -1
# print(data)
return data
def programExitSaveParameters(self):
paramObj = parameters.ParametersToSave()
paramObj.baudRate = self.serailBaudrateCombobox.currentIndex()
paramObj.dataBytes = self.serailBytesCombobox.currentIndex()
paramObj.parity = self.serailParityCombobox.currentIndex()
paramObj.stopBits = self.serailStopbitsCombobox.currentIndex()
paramObj.skin = self.param.skin
if self.receiveSettingsHex.isChecked():
paramObj.receiveAscii = False
if not self.receiveSettingsAutoLinefeed.isChecked():
paramObj.receiveAutoLinefeed = False
else:
paramObj.receiveAutoLinefeed = True
paramObj.receiveAutoLindefeedTime = self.receiveSettingsAutoLinefeedTime.text()
if self.sendSettingsHex.isChecked():
paramObj.sendAscii = False
if not self.sendSettingsScheduledCheckBox.isChecked():
paramObj.sendScheduled = False
paramObj.sendScheduledTime = self.sendSettingsScheduled.text()
if not self.sendSettingsCFLF.isChecked():
paramObj.useCRLF = False
paramObj.sendHistoryList.clear()
for i in range(0,self.sendHistory.count()):
paramObj.sendHistoryList.append(self.sendHistory.itemText(i))
if self.checkBoxRts.isChecked():
paramObj.rts = 1
else:
paramObj.rts = 0
if self.checkBoxDtr.isChecked():
paramObj.dtr = 1
else:
paramObj.dtr = 0
paramObj.encodingIndex = self.encodingCombobox.currentIndex()
f = open(parameters.configFilePath,"wb")
f.truncate()
pickle.dump(paramObj, f)
pickle.dump(paramObj.sendHistoryList,f)
f.close()
def programStartGetSavedParameters(self):
paramObj = parameters.ParametersToSave()
try:
f = open(parameters.configFilePath, "rb")
paramObj = pickle.load( f)
paramObj.sendHistoryList = pickle.load(f)
f.close()
except Exception as e:
f = open(parameters.configFilePath, "wb")
f.close()
self.serailBaudrateCombobox.setCurrentIndex(paramObj.baudRate)
self.serailBytesCombobox.setCurrentIndex(paramObj.dataBytes)
self.serailParityCombobox.setCurrentIndex(paramObj.parity)
self.serailStopbitsCombobox.setCurrentIndex(paramObj.stopBits)
if paramObj.receiveAscii == False:
self.receiveSettingsHex.setChecked(True)
if paramObj.receiveAutoLinefeed == False:
self.receiveSettingsAutoLinefeed.setChecked(False)
else:
self.receiveSettingsAutoLinefeed.setChecked(True)
self.receiveSettingsAutoLinefeedTime.setText(paramObj.receiveAutoLindefeedTime)
if paramObj.sendAscii == False:
self.sendSettingsHex.setChecked(True)
if paramObj.sendScheduled == False:
self.sendSettingsScheduledCheckBox.setChecked(False)
else:
self.sendSettingsScheduledCheckBox.setChecked(True)
self.sendSettingsScheduled.setText(paramObj.sendScheduledTime)
if paramObj.useCRLF == False:
self.sendSettingsCFLF.setChecked(False)
else:
self.sendSettingsCFLF.setChecked(True)
for i in range(0, len(paramObj.sendHistoryList)):
str = paramObj.sendHistoryList[i]
self.sendHistory.addItem(str)
if paramObj.rts == 0:
self.checkBoxRts.setChecked(False)
else:
self.checkBoxRts.setChecked(True)
if paramObj.dtr == 0:
self.checkBoxDtr.setChecked(False)
else:
self.checkBoxDtr.setChecked(True)
self.encodingCombobox.setCurrentIndex(paramObj.encodingIndex)
self.param = paramObj
def keyPressEvent(self, event):
if event.key() == Qt.Key_Control:
self.keyControlPressed = True
elif event.key() == Qt.Key_Return or event.key()==Qt.Key_Enter:
if self.keyControlPressed:
self.sendData()
elif event.key() == Qt.Key_L:
if self.keyControlPressed:
self.sendArea.clear()
elif event.key() == Qt.Key_K:
if self.keyControlPressed:
self.receiveArea.clear()
def keyReleaseEvent(self,event):
if event.key() == Qt.Key_Control:
self.keyControlPressed = False
def sendAreaFontChanged(self,font):
print("font changed")
def functionAdd(self):
QMessageBox.information(self, "On the way", "On the way")
def showHideSettings(self):
if self.isHideSettings:
self.showSettings()
self.isHideSettings = False
else:
self.hideSettings()
self.isHideSettings = True
def showSettings(self):
self.settingWidget.show()
self.settingsButton.setStyleSheet(
parameters.strStyleShowHideButtonLeft.replace("$DataPath",self.DataPath))
def hideSettings(self):
self.settingWidget.hide()
self.settingsButton.setStyleSheet(
parameters.strStyleShowHideButtonRight.replace("$DataPath", self.DataPath))
def showHideFunctional(self):
if self.isHideFunctinal:
self.showFunctional()
self.isHideFunctinal = False
else:
self.hideFunctional()
self.isHideFunctinal = True
def showFunctional(self):
self.functionalWiget.show()
self.functionalButton.setStyleSheet(
parameters.strStyleShowHideButtonRight.replace("$DataPath",self.DataPath))
def hideFunctional(self):
self.functionalWiget.hide()
self.functionalButton.setStyleSheet(
parameters.strStyleShowHideButtonLeft.replace("$DataPath", self.DataPath))
def skinChange(self):
if self.param.skin == 1: # light
file = open(self.DataPath + '/assets/qss/style-dark.qss', "r")
self.param.skin = 2
else: # elif self.param.skin == 2: # dark
file = open(self.DataPath + '/assets/qss/style.qss', "r")
self.param.skin = 1
self.app.setStyleSheet(file.read().replace("$DataPath", self.DataPath))
def showAbout(self):
QMessageBox.information(self, "About","<h1 style='color:#f75a5a';margin=10px;>"+parameters.appName+
'</h1><br><b style="color:#08c7a1;margin = 5px;">V'+str(helpAbout.versionMajor)+"."+
str(helpAbout.versionMinor)+"."+str(helpAbout.versionDev)+
"</b><br><br>"+helpAbout.date+"<br><br>"+helpAbout.strAbout())
def selectFile(self):
oldPath = self.filePathWidget.text()
if oldPath=="":
oldPath = os.getcwd()
fileName_choose, filetype = QFileDialog.getOpenFileName(self,
"SelectFile",
oldPath,
"All Files (*);;")
if fileName_choose == "":
return
self.filePathWidget.setText(fileName_choose)
def sendFile(self):
filename = self.filePathWidget.text()
if not os.path.exists(filename):
self.errorSignal.emit("File path error\npath:%s" %(filename))
return
try:
f = open(filename, "rb")
except Exception as e:
self.errorSignal.emit("Open file %s failed! \n %s" %(filename, str(e)))
return
self.com.write(f.read()) #TODO: optimize send in new thread
f.close()
def clearHistory(self):
self.param.sendHistoryList.clear()
self.sendHistory.clear()
self.errorSignal.emit("History cleared!")
def autoUpdateDetect(self):
auto = autoUpdate.AutoUpdate()
if auto.detectNewVersion():
auto.OpenBrowser()
def openDevManagement(self):
os.system('start devmgmt.msc')
class Serial(COMM):
'''
call sequence:
onInit
onWidget
onUiInitDone
isConnected
send
getConfig
'''
id = "serial"
name = _("Serial")
showSerialComboboxSignal = pyqtSignal(list)
showSwitchSignal = pyqtSignal(ConnectionStatus)
def onInit(self, config):
self.com = serial.Serial()
self.config = config
default = {
"port": None,
"baudrate": 115200,
"bytesize": 8,
"parity": "None",
"stopbits": "1",
"flowcontrol": "None",
"rts": False,
"dtr": False,
}
for k in default:
if not k in self.config:
self.config[k] = default[k]
self.widgetConfMap = {
"port": None,
"baudrate": None,
"bytesize": None,
"parity": None,
"stopbits": None,
"flowcontrol": None,
"rts": None,
"dtr": None,
}
self.isOpened = False
self.busy = False
self.status = ConnectionStatus.CLOSED
self.isDetectSerialPort = False
self.widget = None
self.baudrateCustomStr = _("Custom, input baudrate")
def disconnect(self):
if self.isConnected():
self.openCloseSerial()
def onDel(self):
if self.isConnected():
self.openCloseSerial()
def __del__(self):
try:
self.com.close()
self.status = ConnectionStatus.CLOSED
time.sleep(
0.05
) # wait for child threads, not wait also ok, cause child threads are daemon
except Exception:
pass
def getConfig(self):
'''
get config, dict type
'''
return self.config
def onUiInitDone(self):
for key in self.config:
self.setSerialConfig(key, self.widgetConfMap[key],
self.config[key])
self.detectSerialPort()
def onWidget(self):
self.widget = QWidget()
serialSettingsLayout = QGridLayout()
serialPortLabek = QLabel(_("Port"))
serailBaudrateLabel = QLabel(_("Baudrate"))
serailBytesLabel = QLabel(_("DataBytes"))
serailParityLabel = QLabel(_("Parity"))
serailStopbitsLabel = QLabel(_("Stopbits"))
serialFlowControlLabel = QLabel(_("Flow control"))
self.serialPortCombobox = ComboBox()
self.serailBaudrateCombobox = ComboBox()
for baud in parameters.defaultBaudrates:
self.serailBaudrateCombobox.addItem(str(baud))
self.serailBaudrateCombobox.addItem(self.baudrateCustomStr)
self.serailBaudrateCombobox.setCurrentIndex(5)
self.serailBaudrateCombobox.setEditable(True)
self.serailBytesCombobox = ComboBox()
self.serailBytesCombobox.addItem("5")
self.serailBytesCombobox.addItem("6")
self.serailBytesCombobox.addItem("7")
self.serailBytesCombobox.addItem("8")
self.serailBytesCombobox.setCurrentIndex(3)
self.serailParityCombobox = ComboBox()
self.serailParityCombobox.addItem("None")
self.serailParityCombobox.addItem("Odd")
self.serailParityCombobox.addItem("Even")
self.serailParityCombobox.addItem("Mark")
self.serailParityCombobox.addItem("Space")
self.serailParityCombobox.setCurrentIndex(0)
self.serailStopbitsCombobox = ComboBox()
self.serailStopbitsCombobox.addItem("1")
self.serailStopbitsCombobox.addItem("1.5")
self.serailStopbitsCombobox.addItem("2")
self.serailStopbitsCombobox.setCurrentIndex(0)
self.serialFlowControlCombobox = ComboBox()
self.serialFlowControlCombobox.addItem("None")
self.serialFlowControlCombobox.addItem("XON/XOFF")
self.serialFlowControlCombobox.addItem("RTS/CTS")
self.serialFlowControlCombobox.addItem("DSR/DTR")
self.serialFlowControlCombobox.setCurrentIndex(0)
self.checkBoxRTS = QCheckBox("rts")
self.checkBoxDTR = QCheckBox("dtr")
self.checkBoxRTS.setToolTip(
_("Check to enable(usually output low level)"))
self.checkBoxDTR.setToolTip(
_("Check to enable(usually output low level)"))
self.serialOpenCloseButton = QPushButton(_("OPEN"))
serialSettingsLayout.addWidget(serialPortLabek, 0, 0)
serialSettingsLayout.addWidget(serailBaudrateLabel, 1, 0)
serialSettingsLayout.addWidget(serailBytesLabel, 2, 0)
serialSettingsLayout.addWidget(serailParityLabel, 3, 0)
serialSettingsLayout.addWidget(serailStopbitsLabel, 4, 0)
serialSettingsLayout.addWidget(serialFlowControlLabel, 5, 0)
serialSettingsLayout.addWidget(self.serialPortCombobox, 0, 1)
serialSettingsLayout.addWidget(self.serailBaudrateCombobox, 1, 1)
serialSettingsLayout.addWidget(self.serailBytesCombobox, 2, 1)
serialSettingsLayout.addWidget(self.serailParityCombobox, 3, 1)
serialSettingsLayout.addWidget(self.serailStopbitsCombobox, 4, 1)
serialSettingsLayout.addWidget(self.serialFlowControlCombobox, 5, 1)
serialSettingsLayout.addWidget(self.checkBoxRTS, 6, 0, 1, 1)
serialSettingsLayout.addWidget(self.checkBoxDTR, 6, 1, 1, 1)
serialSettingsLayout.addWidget(self.serialOpenCloseButton, 7, 0, 1, 2)
self.widget.setLayout(serialSettingsLayout)
self.widgetConfMap["port"] = self.serialPortCombobox
self.widgetConfMap["baudrate"] = self.serailBaudrateCombobox
self.widgetConfMap["bytesize"] = self.serailBytesCombobox
self.widgetConfMap["parity"] = self.serailParityCombobox
self.widgetConfMap["stopbits"] = self.serailStopbitsCombobox
self.widgetConfMap["flowcontrol"] = self.serialFlowControlCombobox
self.widgetConfMap["rts"] = self.checkBoxRTS
self.widgetConfMap["dtr"] = self.checkBoxDTR
self.initEvet()
return self.widget
def initEvet(self):
self.serialPortCombobox.clicked.connect(self.detectSerialPort)
self.showSerialComboboxSignal.connect(self.showCombobox)
self.serialPortCombobox.currentIndexChanged.connect(
lambda: self.onSerialConfigChanged("port", self.serialPortCombobox,
str))
self.serailBaudrateCombobox.currentIndexChanged.connect(
lambda: self.onSerialConfigChanged("baudrate",
self.serailBaudrateCombobox,
int,
caller="index change"))
self.serailBaudrateCombobox.editTextChanged.connect(
lambda: self.onSerialConfigChanged("baudrate",
self.serailBaudrateCombobox,
int,
caller="text change"))
self.serailBytesCombobox.currentIndexChanged.connect(
lambda: self.onSerialConfigChanged("bytesize", self.
serailBytesCombobox, int))
self.serailParityCombobox.currentIndexChanged.connect(
lambda: self.onSerialConfigChanged("parity", self.
serailParityCombobox, str))
self.serailStopbitsCombobox.currentIndexChanged.connect(
lambda: self.onSerialConfigChanged("stopbits", self.
serailStopbitsCombobox, str))
self.serialFlowControlCombobox.currentIndexChanged.connect(
lambda: self.onSerialConfigChanged("flowcontrol", self.
serialFlowControlCombobox, str))
self.checkBoxRTS.clicked.connect(
lambda: self.onSerialConfigChanged("rts", self.checkBoxRTS, bool))
self.checkBoxDTR.clicked.connect(
lambda: self.onSerialConfigChanged("dtr", self.checkBoxDTR, bool))
self.serialOpenCloseButton.clicked.connect(self.openCloseSerial)
self.showSwitchSignal.connect(self.showSwitch)
def onSerialConfigChanged(self, conf_type, obj, value_type, caller=""):
if conf_type == "port":
obj.setToolTip(obj.currentText())
newPort = obj.currentText().split(" ")[0]
if newPort and not self.isDetectSerialPort and (
newPort != self.config["port"] or not self.com.port):
self.config["port"] = newPort
print("-- set to new port:", self.config["port"])
try:
self.com.port = self.config["port"]
except Exception as e:
msg = _("Open Failed") + "\n" + str(e)
self.status = ConnectionStatus.CLOSED
self.onConnectionStatus.emit(self.status, msg)
self.showSwitchSignal.emit(self.status)
elif conf_type in ["baudrate", "bytesize", "parity", "stopbits"]:
# custom baudrate input
text = obj.currentText()
if conf_type == "baudrate" and ((not text)
or text == self.baudrateCustomStr):
self.serailBaudrateCombobox.clearEditText()
return
self.config[conf_type] = value_type(text.split(" ")[0])
print("-- set serial {} to {}".format(conf_type,
self.config[conf_type]))
if conf_type == "parity":
self.com.__setattr__(conf_type, self.config[conf_type][0])
elif conf_type == "stopbits":
self.com.__setattr__(conf_type, float(self.config[conf_type]))
else:
self.com.__setattr__(conf_type, self.config[conf_type])
elif conf_type == "flowcontrol":
self.config[conf_type] = value_type(
obj.currentText().split(" ")[0])
if self.config[conf_type] == "XON/XOFF":
self.com.xonxoff = True
else:
self.com.xonxoff = False
if self.config[conf_type] == "RTS/CTS":
self.com.rtscts = True
else:
self.com.rtscts = False
if self.config[conf_type] == "DSR/DTR":
self.com.dsrdtr = True
else:
self.com.dsrdtr = False
elif conf_type in ["rts", "dtr"]:
self.config[conf_type] = obj.isChecked()
self.com.__setattr__(conf_type, self.config[conf_type])
def setSerialConfig(self, conf_type, obj, value):
def getCommboboxItems(obj):
values = []
for i in range(len(obj)):
values.append(obj.itemText(i))
return values
if conf_type == "port":
values = getCommboboxItems(obj)
idx = 0
try:
idx = values.index(str(value))
except Exception:
# print(f"-- set {obj} index {idx} error, value {value}, items {values}")
pass
obj.setCurrentIndex(idx)
elif conf_type in ["baudrate", "bytesize", "parity", "stopbits"]:
values = getCommboboxItems(obj)
idx = 0
try:
idx = values.index(str(value))
except Exception:
print(
f"-- set {obj} index {idx} error, value {value}, items {values}"
)
obj.setCurrentIndex(idx)
if conf_type == "parity":
value = value[0]
elif conf_type == "stopbits":
value = float(value)
self.com.__setattr__(conf_type, value)
if conf_type == "baudrate":
self.oneByteTime = 1 / (
self.com.baudrate /
(self.com.bytesize + 2 + self.com.stopbits)
) # 1 byte use time
elif conf_type == "flowcontrol":
values = getCommboboxItems(obj)
idx = 0
try:
idx = values.index(str(value))
except Exception:
print(
f"-- set {obj} index {idx} error, value {value}, items {values}"
)
obj.setCurrentIndex(idx)
if value == "XON/XOFF":
self.com.xonxoff = True
else:
self.com.xonxoff = False
if value == "RTS/CTS":
self.com.rtscts = True
else:
self.com.rtscts = False
if value == "DSR/DTR":
self.com.dsrdtr = True
else:
self.com.dsrdtr = False
elif conf_type in ["rts", "dtr"]:
obj.setChecked(value)
self.com.__setattr__(conf_type, value)
def openCloseSerial(self):
if self.busy:
return
self.busy = True
if self.serialOpenCloseButton.text() == _("OPEN"):
self.isOpened = False
else:
self.isOpened = True
t = threading.Thread(target=self.openCloseSerialProcess)
t.setDaemon(True)
t.start()
def openCloseSerialProcess(self):
if self.isOpened:
print("-- close serial")
try:
# set status first to prevent auto reconnect
self.status = ConnectionStatus.CLOSED
self.com.close()
except Exception:
pass
self.onConnectionStatus.emit(self.status, "")
self.showSwitchSignal.emit(self.status)
else:
try:
print("-- open serial")
self.onConnectionStatus.emit(ConnectionStatus.CONNECTING, "")
self.com.open()
self.status = ConnectionStatus.CONNECTED
self.onConnectionStatus.emit(self.status, "")
self.showSwitchSignal.emit(self.status)
self.receiveProcess = threading.Thread(
target=self.receiveDataProcess)
self.receiveProcess.setDaemon(True)
self.receiveProcess.start()
except Exception as e:
try:
self.com.close()
except Exception:
pass
msg = _("Open Failed") + "\n" + str(e)
self.hintSignal.emit("error", _("Error"), msg)
self.status = ConnectionStatus.CLOSED
self.onConnectionStatus.emit(self.status, msg)
self.showSwitchSignal.emit(self.status)
self.busy = False
def detectSerialPort(self):
if not self.isDetectSerialPort:
self.isDetectSerialPort = True
t = threading.Thread(target=self.detectSerialPortProcess)
t.setDaemon(True)
t.start()
def detectSerialPortProcess(self):
items = []
while 1:
portList = self.findSerialPort()
if len(portList) > 0:
for p in portList:
showStr = "{} {} - {}".format(p.device, p.name,
p.description)
if p.manufacturer:
showStr += ' - {}'.format(p.manufacturer)
if p.pid:
showStr += ' - pid(0x{:04X})'.format(p.pid)
if p.vid:
showStr += ' - vid(0x{:04X})'.format(p.vid)
if p.serial_number:
showStr += ' - v{}'.format(p.serial_number)
if p.device.startswith("/dev/cu.Bluetooth-Incoming-Port"):
continue
items.append(showStr)
break
time.sleep(0.5)
self.showSerialComboboxSignal.emit(items)
# @pyqtSlot(list)
def showCombobox(self, items):
set = -1
self.serialPortCombobox.clear()
for item in items:
self.serialPortCombobox.addItem(item)
if self.config["port"]:
index = self.serialPortCombobox.findText(
self.config["port"], Qt.MatchContains)
if index >= 0:
set = index
self.serialPortCombobox.showPopup()
self.isDetectSerialPort = False
if set <= 0:
# set to first port in list
self.onSerialConfigChanged("port", self.serialPortCombobox, str)
else:
self.serialPortCombobox.setCurrentIndex(set)
# @pyqtSlot(ConnectionStatus)
def showSwitch(self, status):
if status == ConnectionStatus.CLOSED:
self.serialOpenCloseButton.setText(_("OPEN"))
self.serialOpenCloseButton.setProperty("class", "")
elif status == ConnectionStatus.CONNECTED:
self.serialOpenCloseButton.setText(_("CLOSE"))
self.serialOpenCloseButton.setProperty("class", "")
else:
self.serialOpenCloseButton.setText(_("CLOSE"))
self.serialOpenCloseButton.setProperty("class", "warning")
self.updateStyle(self.serialOpenCloseButton)
def updateStyle(self, widget):
self.widget.style().unpolish(widget)
self.widget.style().polish(widget)
self.widget.update()
def findSerialPort(self):
self.port_list = list(serial.tools.list_ports.comports())
return self.port_list
def portExits(self, port):
ports = self.findSerialPort()
devices = []
for p in ports:
devices.append(p.device)
if port in devices:
return True
return False
def receiveDataProcess(self):
waitingReconnect = False
self.com.timeout = 0.001
buffer = b''
t = 0
while self.status != ConnectionStatus.CLOSED:
if waitingReconnect:
if self.portExits(self.com.port):
try:
self.onConnectionStatus.emit(
ConnectionStatus.CONNECTING, "")
self.com.open()
print("-- reopen serial")
waitingReconnect = False
self.onConnectionStatus.emit(
ConnectionStatus.CONNECTED, _("Reconnected"))
self.showSwitchSignal.emit(ConnectionStatus.CONNECTED)
continue
except Exception as e:
pass
time.sleep(0.01)
continue
try:
length = max(1, self.com.in_waiting)
data = self.com.read(length)
if data:
t = time.time()
if length == 1 and not buffer: # just start receive
buffer += data
continue
buffer += data
if buffer and (time.time() - t > self.oneByteTime *
2): # no new data in next frame
try:
self.onReceived(buffer)
except Exception as e:
print("-- error in onReceived callback:", e)
buffer = b''
except Exception as e:
if (self.status != ConnectionStatus.CLOSED):
# close as fast as we can to release port
try:
self.com.close()
except Exception:
pass
waitingReconnect = True
self.onConnectionStatus.emit(ConnectionStatus.LOSE,
_("Connection lose!"))
self.showSwitchSignal.emit(ConnectionStatus.LOSE)
def send(self, data: bytes):
self.com.write(data)
def isConnected(self):
return self.status == ConnectionStatus.CONNECTED
class Plugin(Plugin_Base):
'''
call sequence:
set vars like hintSignal, hintSignal
onInit
onWidget
onUiInitDone
send
onReceived
getConfig
'''
# vars set by caller
isConnected = lambda: False
send = lambda x, y: None # send(data_bytes=None, file_path=None, callback=lambda ok,msg:None)
hintSignal = None # hintSignal.emit(type(error, warning, info), title, msg)
configGlobal = {}
# other vars
connParent = "dbg" # parent id
connChilds = [] # children ids
id = "protocol"
name = _("protocol")
enabled = False # user enabled this plugin
active = False # using this plugin
showReceiveDataSignal = pyqtSignal(str)
def __init__(self):
super().__init__()
if not self.id:
raise ValueError(f"var id of Plugin {self} should be set")
def onInit(self, config):
'''
init params, DO NOT take too long time in this func
'''
default = {
"version":
1,
"sendAscii":
True,
"useCRLF":
False,
"sendEscape":
True,
"code":
defaultProtocols.copy(),
"currCode":
"default",
"customSendItems": [{
"text": "hello",
"remark": "hello",
"icon": "fa5.hand-paper"
}, {
"text": "\\x01\\x03\\x03\\x03\\x03\\x01",
"remark": "pre",
"icon": "ei.arrow-left",
"shortcut": [[16777234, "Left"]]
}, {
"text": "\\x01\\x04\\x04\\x04\\x04\\x01",
"remark": "next",
"icon": "ei.arrow-right",
"shortcut": [[16777236, "Right"]]
}, {
"text": "\\x01\\x01\\x01\\x01\\x01\\x01",
"remark": "ok",
"icon": "fa.circle-o",
"shortcut": [[16777220, "Return"]]
}, {
"text": "\\x01\\x02\\x02\\x02\\x02\\x01",
"remark": "ret",
"icon": "ei.return-key",
"shortcut": [[16777216, "Esc"]]
}]
}
self.config = config
for k in default:
if not k in self.config:
self.config[k] = default[k]
self.editingDefaults = False
self.codeGlobals = {
"unpack": unpack,
"pack": pack,
"crc": crc,
"encoding": self.configGlobal["encoding"],
"print": self.print
}
self.encodeMethod = lambda x: x
self.decodeMethod = lambda x: x
self.pressedKeys = []
self.keyModeClickTime = 0
def print(self, *args, **kw_args):
end = "\n"
start = "[MSG]: "
if "end" in kw_args:
end = kw_args["end"]
if "start" in kw_args:
start = kw_args["start"]
string = start + " ".join(map(str, args)) + end
self.showReceiveDataSignal.emit(string)
class ModeButton(QPushButton):
onFocusIn = pyqtSignal(QFocusEvent)
onFocusOut = pyqtSignal(QFocusEvent)
def __init__(self, text, eventFilter, parent=None) -> None:
super().__init__(text, parent)
self.installEventFilter(eventFilter)
def focusInEvent(self, event):
self.onFocusIn.emit(event)
def focusOutEvent(self, event):
self.onFocusOut.emit(event)
def onWidgetMain(self, parent):
self.mainWidget = QSplitter(Qt.Vertical)
self.receiveWidget = TextEdit()
font = QFont(
'Menlo,Consolas,Bitstream Vera Sans Mono,Courier New,monospace, Microsoft YaHei',
10)
self.receiveWidget.setFont(font)
self.receiveWidget.setLineWrapMode(TextEdit.NoWrap)
self.clearBtn = QPushButton("")
self.keyBtneventFilter = self.ModeButtonEventFilter(
self.onModeBtnKeyPressEvent, self.onModeBtnKeyReleaseEvent)
self.keyModeBtn = self.ModeButton(_("Key mode"),
self.keyBtneventFilter)
layoutClearMode = QHBoxLayout()
layoutClearMode.addWidget(self.clearBtn)
layoutClearMode.addWidget(self.keyModeBtn)
clearModeWidget = QWidget()
clearModeWidget.setLayout(layoutClearMode)
utils_ui.setButtonIcon(self.clearBtn, "mdi6.broom")
self.addButton = QPushButton("")
utils_ui.setButtonIcon(self.addButton, "fa.plus")
self.customSendScroll = QScrollArea()
self.customSendScroll.setMinimumHeight(
parameters.customSendItemHeight + 20)
self.customSendScroll.setWidgetResizable(True)
self.customSendScroll.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.customSendScroll.setHorizontalScrollBarPolicy(
Qt.ScrollBarAlwaysOff)
cutomSendItemsWraper = QWidget()
self.customSendScroll.setWidget(cutomSendItemsWraper)
# wrapper widget
cutomSendItemsWraper0 = QWidget()
cutomSendItemsWraper0.setProperty("class", "scrollbar2")
layout0 = QVBoxLayout()
layout0.setContentsMargins(0, 8, 0, 0)
cutomSendItemsWraper0.setLayout(layout0)
layout0.addWidget(self.customSendScroll)
customSendItemsLayoutWrapper = QVBoxLayout()
customSendItemsLayoutWrapper.setContentsMargins(0, 0, 0, 0)
cutomSendItemsWraper.setLayout(customSendItemsLayoutWrapper)
# items container
self.customItems = QWidget()
self.customSendItemsLayout = QVBoxLayout()
self.customSendItemsLayout.setContentsMargins(0, 0, 0, 0)
self.customItems.setLayout(self.customSendItemsLayout)
customSendItemsLayoutWrapper.addWidget(self.customItems)
customSendItemsLayoutWrapper.addWidget(self.addButton)
customSendItemsLayoutWrapper.addStretch(0)
self.mainWidget.addWidget(self.receiveWidget)
self.mainWidget.addWidget(clearModeWidget)
self.mainWidget.addWidget(cutomSendItemsWraper0)
self.mainWidget.setStretchFactor(0, 2)
self.mainWidget.setStretchFactor(1, 1)
self.mainWidget.setStretchFactor(2, 11)
# event
self.addButton.clicked.connect(lambda: self.insertSendItem())
def clearReceived():
self.receiveWidget.clear()
self.statusBar.clear()
self.clearBtn.clicked.connect(clearReceived)
def keyModeOn(event):
self.keyModeBtn.setProperty("class", "deleteBtn")
utils_ui.updateStyle(self.mainWidget, self.keyModeBtn)
self.keyModeClickTime = time.time()
# show all shortcut
widgets = self.customItems.findChildren(QPushButton, "editRemark")
for i, w in enumerate(widgets):
shortcut = "+".join(
(name for v, name in self.config["customSendItems"][i]
["shortcut"]))
w.setText(shortcut)
utils_ui.updateStyle(self.mainWidget, w)
def keyModeOff(event):
self.keyModeBtn.setProperty("class", "")
utils_ui.updateStyle(self.mainWidget, self.keyModeBtn)
self.keyModeClickTime = 0
# remove all preesed keys even them not release actually, to avoid window swith by ALT+TAB bug
self.pressedKeys = []
# hide all shortcut
widgets = self.customItems.findChildren(QPushButton, "editRemark")
for w in widgets:
w.setText("")
def keyModeTuggle():
if self.keyModeBtn.property("class") == "deleteBtn":
if time.time() - self.keyModeClickTime < 0.2:
return
else:
self.keyModeBtn.clearFocus()
self.keyModeBtn.onFocusIn.connect(keyModeOn)
self.keyModeBtn.onFocusOut.connect(keyModeOff)
self.keyModeBtn.clicked.connect(keyModeTuggle)
return self.mainWidget
def onWidgetSettings(self, parent):
root = QWidget()
rootLayout = QVBoxLayout()
rootLayout.setContentsMargins(0, 0, 0, 0)
root.setLayout(rootLayout)
setingGroup = QGroupBox(_("En-decoding settings"))
layout = QGridLayout()
setingGroup.setLayout(layout)
self.codeItems = ComboBox()
self.codeItemCustomStr = _("Custom, input name")
self.codeItemLoadDefaultsStr = _("Load defaults")
self.codeItems.setEditable(True)
self.codeWidget = PlainTextEdit()
self.saveCodeBtn = QPushButton(_("Save"))
self.saveCodeBtn.setEnabled(False)
self.deleteCodeBtn = QPushButton(_("Delete"))
btnLayout = QHBoxLayout()
btnLayout.addWidget(self.saveCodeBtn)
btnLayout.addWidget(self.deleteCodeBtn)
layout.addWidget(QLabel(_("Defaults")), 0, 0, 1, 1)
layout.addWidget(self.codeItems, 0, 1, 1, 1)
layout.addWidget(QLabel(_("Code")), 1, 0, 1, 1)
layout.addWidget(self.codeWidget, 1, 1, 1, 1)
layout.addLayout(btnLayout, 2, 1, 1, 1)
serialSendSettingsLayout = QGridLayout()
sendGroup = QGroupBox(_("Send settings"))
sendGroup.setLayout(serialSendSettingsLayout)
self.sendSettingsAscii = QRadioButton(_("ASCII"))
self.sendSettingsHex = QRadioButton(_("HEX"))
self.sendSettingsAscii.setToolTip(
_("Get send data as visible format, select encoding method at top right corner"
))
self.sendSettingsHex.setToolTip(
_("Get send data as hex format, e.g. hex '31 32 33' equal to ascii '123'"
))
self.sendSettingsAscii.setChecked(True)
self.sendSettingsCRLF = QCheckBox(_("<CRLF>"))
self.sendSettingsCRLF.setToolTip(
_("Select to send \\r\\n instead of \\n"))
self.sendSettingsCRLF.setChecked(False)
self.sendSettingsEscape = QCheckBox(_("Escape"))
self.sendSettingsEscape.setToolTip(
_("Enable escape characters support like \\t \\r \\n \\x01 \\001"))
serialSendSettingsLayout.addWidget(self.sendSettingsAscii, 0, 0, 1, 1)
serialSendSettingsLayout.addWidget(self.sendSettingsHex, 0, 1, 1, 1)
serialSendSettingsLayout.addWidget(self.sendSettingsCRLF, 1, 0, 1, 1)
serialSendSettingsLayout.addWidget(self.sendSettingsEscape, 1, 1, 1, 1)
rootLayout.addWidget(sendGroup)
rootLayout.addWidget(setingGroup)
# event
self.sendSettingsAscii.clicked.connect(lambda: self.bindVar(
self.sendSettingsAscii, self.config, "sendAscii", bool))
self.sendSettingsHex.clicked.connect(lambda: self.bindVar(
self.sendSettingsHex, self.config, "sendAscii", bool, invert=True))
self.sendSettingsCRLF.clicked.connect(lambda: self.bindVar(
self.sendSettingsCRLF, self.config, "useCRLF", bool))
self.sendSettingsEscape.clicked.connect(lambda: self.bindVar(
self.sendSettingsEscape, self.config, "sendEscape", bool))
self.saveCodeBtn.clicked.connect(self.saveCode)
self.deleteCodeBtn.clicked.connect(self.deleteCode)
self.codeWidget.onSave = self.saveCode
return root
def onWidgetStatusBar(self, parent):
self.statusBar = statusBar(rxTxCount=True)
return self.statusBar
def onUiInitDone(self):
'''
UI init done, you can update your widget here
this method runs in UI thread, do not block too long
'''
newItems = []
for item in self.config["customSendItems"]:
item = self.insertSendItem(item, load=True)
newItems.append(item)
self.config["customSendItems"] = newItems
self.sendSettingsAscii.setChecked(self.config["sendAscii"])
self.sendSettingsHex.setChecked(not self.config["sendAscii"])
self.sendSettingsCRLF.setChecked(self.config["useCRLF"])
self.sendSettingsEscape.setChecked(self.config["sendEscape"])
self.showReceiveDataSignal.connect(self.showReceivedData)
# init decoder and encoder
for k in self.config["code"]:
self.codeItems.addItem(k)
self.codeItems.addItem(self.codeItemCustomStr)
self.codeItems.addItem(self.codeItemLoadDefaultsStr)
name = self.config["currCode"]
idx = self.codeItems.findText(self.config["currCode"])
if idx < 0:
idx = 0
name = "default"
self.codeItems.setCurrentIndex(idx)
self.selectCode(name)
self.codeItems.currentIndexChanged.connect(
self.onCodeItemChanged
) # add here to avoid self.selectCode trigger
self.codeWidget.textChanged.connect(self.onCodeChanged)
class ModeButtonEventFilter(QObject):
def __init__(self, keyPressCb, keyReleaseCb) -> None:
super().__init__()
self.keyPressCb = keyPressCb
self.keyReleaseCb = keyReleaseCb
def eventFilter(self, obj, evt):
if evt.type() == QEvent.KeyPress:
# prevent default key events
self.keyPressCb(evt)
return True
elif evt.type() == QEvent.KeyRelease:
self.keyReleaseCb(evt)
return True
return False
def onModeBtnKeyPressEvent(self, event):
# send by shortcut
key = event.key()
self.pressedKeys.append(key)
for item in self.config["customSendItems"]:
if not "shortcut" in item:
continue
shortcut = item["shortcut"]
if len(shortcut) == len(self.pressedKeys):
same = True
for i in range(len(shortcut)):
if shortcut[i][0] != self.pressedKeys[i]:
same = False
break
if same:
self.sendCustomItem(item)
def onModeBtnKeyReleaseEvent(self, event):
key = event.key()
if key in self.pressedKeys:
self.pressedKeys.remove(key)
def onKeyPressEvent(self, event):
pass
def onKeyReleaseEvent(self, event):
pass
def insertSendItem(self, item=None, load=False):
# itemsNum = self.customSendItemsLayout.count() + 1
# height = parameters.customSendItemHeight * (itemsNum + 1) + 20
# topHeight = self.receiveWidget.height() + 100
# if height + topHeight > self.funcParent.height():
# height = self.funcParent.height() - topHeight
# if height < 0:
# height = self.funcParent.height() // 3
# self.customSendScroll.setMinimumHeight(height)
if not item:
item = {"text": "", "remark": None, "icon": None}
if type(item) == str:
item = {"text": item, "remark": None}
text = item["text"]
remark = item["remark"]
itemWidget = QWidget()
layout = QHBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
itemWidget.setLayout(layout)
cmd = QLineEdit(text)
if remark:
send = QPushButton(remark)
else:
send = QPushButton("")
if (not "icon" in item) or not item["icon"]:
item["icon"] = "fa.send"
if not "shortcut" in item:
item["shortcut"] = []
utils_ui.setButtonIcon(send, item["icon"])
editRemark = QPushButton("")
editRemark.setObjectName("editRemark")
utils_ui.setButtonIcon(editRemark, "ei.pencil")
editRemark.setProperty("class", "remark")
cmd.setToolTip(text)
send.setToolTip(text)
cmd.textChanged.connect(lambda: self.onCustomItemChange(
self.customSendItemsLayout.indexOf(itemWidget), cmd, send))
send.setProperty("class", "smallBtn")
def sendCustomData(idx):
self.sendCustomItem(self.config["customSendItems"][idx])
send.clicked.connect(lambda: sendCustomData(
self.customSendItemsLayout.indexOf(itemWidget)))
delete = QPushButton("")
utils_ui.setButtonIcon(delete, "fa.close")
delete.setProperty("class", "deleteBtn")
layout.addWidget(cmd)
layout.addWidget(send)
layout.addWidget(editRemark)
layout.addWidget(delete)
delete.clicked.connect(lambda: self.deleteSendItem(
self.customSendItemsLayout.indexOf(itemWidget), itemWidget,
[send, editRemark, delete]))
def changeRemark(idx, obj):
if not "icon" in self.config["customSendItems"][idx]:
self.config["customSendItems"][idx]["icon"] = None
shortcut = []
if "shortcut" in self.config["customSendItems"][idx]:
shortcut = self.config["customSendItems"][idx]["shortcut"]
ok, remark, icon, shortcut = EditRemarDialog(
obj.text(), self.config["customSendItems"][idx]["icon"],
shortcut).exec()
if ok:
obj.setText(remark)
if icon:
utils_ui.setButtonIcon(obj, icon)
else:
obj.setIcon(QIcon())
self.config["customSendItems"][idx]["remark"] = remark
self.config["customSendItems"][idx]["icon"] = icon
self.config["customSendItems"][idx]["shortcut"] = shortcut
editRemark.clicked.connect(lambda: changeRemark(
self.customSendItemsLayout.indexOf(itemWidget), send))
self.customSendItemsLayout.addWidget(itemWidget)
if not load:
self.config["customSendItems"].append(item)
return item
def deleteSendItem(self, idx, item, iconItems=[]):
for obj in iconItems:
utils_ui.clearButtonIcon(obj)
item.setParent(None)
self.config["customSendItems"].pop(idx)
# itemsNum = self.customSendItemsLayout.count()
# height = parameters.customSendItemHeight * (itemsNum + 1) + 20
# topHeight = self.receiveWidget.height() + 100
# if height + topHeight > self.funcParent.height():
# height = self.funcParent.height() - topHeight
# self.customSendScroll.setMinimumHeight(height)
def showReceivedData(self, text: str):
curScrollValue = self.receiveWidget.verticalScrollBar().value()
self.receiveWidget.moveCursor(QTextCursor.End)
endScrollValue = self.receiveWidget.verticalScrollBar().value()
self.receiveWidget.insertPlainText(text)
if curScrollValue < endScrollValue:
self.receiveWidget.verticalScrollBar().setValue(curScrollValue)
else:
self.receiveWidget.moveCursor(QTextCursor.End)
def onReceived(self, data: bytes):
self.statusBar.addRx(len(data))
try:
data = self.decodeMethod(data)
except Exception as e:
self.hintSignal.emit("error", _("Error"),
_("Run decode error") + " " + str(e))
return
if not data:
return
for plugin in self.connChilds:
plugin.onReceived(data)
if type(data) != str:
data = self.decodeReceivedData(data, self.configGlobal["encoding"],
not self.config["sendAscii"],
self.config["sendEscape"])
self.showReceiveDataSignal.emit(data + "\n")
def sendData(self, data_bytes=None):
try:
data_bytes = self.encodeMethod(data_bytes)
except Exception as e:
self.hintSignal.emit("error", _("Error"),
_("Run encode error") + " " + str(e))
return
if data_bytes:
self.send(data_bytes, callback=self.onSent)
def onSent(self, ok, msg, length, path):
if ok:
self.statusBar.addTx(length)
else:
self.hintSignal.emit("error", _("Error"),
_("Send data failed!") + " " + msg)
def sendCustomItem(self, item):
text = item["text"]
dateBytes = self.parseSendData(text, self.configGlobal["encoding"],
self.config["useCRLF"],
not self.config["sendAscii"],
self.config["sendEscape"])
if dateBytes:
self.sendData(data_bytes=dateBytes)
def onCustomItemChange(self, idx, edit, send):
text = edit.text()
edit.setToolTip(text)
send.setToolTip(text)
self.config["customSendItems"][idx].update({
"text": text,
"remark": send.text()
})
def onCodeItemChanged(self):
if self.editingDefaults:
return
self.editingDefaults = True
if self.codeItems.currentText() == self.codeItemCustomStr:
self.codeItems.clearEditText()
self.editingDefaults = False
return
if self.codeItems.currentText() == self.codeItemLoadDefaultsStr:
for name in defaultProtocols:
idx = self.codeItems.findText(name)
if idx >= 0:
self.codeItems.removeItem(idx)
self.codeItems.insertItem(self.codeItems.count() - 2, name)
self.config["code"][name] = defaultProtocols[name]
self.codeItems.setCurrentIndex(0)
self.selectCode(self.codeItems.currentText())
self.editingDefaults = False
return
# update code from defaults
self.selectCode(self.codeItems.currentText())
self.editingDefaults = False
def selectCode(self, name):
if name in [self.codeItemCustomStr, self.codeItemLoadDefaultsStr
] or not name or not name in self.config["code"]:
print(f"name {name} invalid")
return
self.config["currCode"] = name
self.codeWidget.clear()
self.codeWidget.insertPlainText(self.config["code"][name])
ok, e, d = self.getEnDecodeMethod(self.codeWidget.toPlainText())
if ok:
self.encodeMethod = e
self.decodeMethod = d
self.saveCodeBtn.setText(_("Save"))
self.saveCodeBtn.setEnabled(False)
def getEnDecodeMethod(self, code):
func = lambda x: x
try:
exec(code, self.codeGlobals)
if (not "decode"
in self.codeGlobals) or not "encode" in self.codeGlobals:
raise ValueError(
_("decode and encode method should be in code"))
return True, self.codeGlobals["encode"], self.codeGlobals["decode"]
except Exception as e:
msg = _("Method error") + "\n" + str(e)
self.hintSignal.emit("error", _("Error"), msg)
return False, func, func
def onCodeChanged(self):
changed = True
name = self.codeItems.currentText()
if name in self.config["code"]:
codeSaved = self.config["code"][name]
code = self.codeWidget.toPlainText()
if code == codeSaved:
changed = False
if changed:
self.saveCodeBtn.setText(_("Save") + " *")
self.saveCodeBtn.setEnabled(True)
else:
self.saveCodeBtn.setText(_("Save"))
self.saveCodeBtn.setEnabled(False)
def saveCode(self):
self.editingDefaults = True
name = self.codeItems.currentText()
if name in [self.codeItemCustomStr, self.codeItemLoadDefaultsStr
] or not name:
self.hintSignal.emit("warning", _("Warning"),
_("Please input code profile name first"))
self.editingDefaults = False
return
idx = self.codeItems.findText(name)
if idx < 0:
self.codeItems.insertItem(self.codeItems.count() - 2, name)
self.editingDefaults = False
code = self.codeWidget.toPlainText()
ok, e, d = self.getEnDecodeMethod(code)
if ok:
self.encodeMethod = e
self.decodeMethod = d
self.config["code"][name] = code
self.saveCodeBtn.setText(_("Save"))
self.saveCodeBtn.setEnabled(False)
def deleteCode(self):
self.editingDefaults = True
name = self.codeItems.currentText()
itemsConfig = [self.codeItemCustomStr, self.codeItemLoadDefaultsStr]
# QMessageBox.infomation()
if name in itemsConfig or not name:
self.hintSignal.emit(
"warning", _("Warning"),
_("Please select a code profile name first to delete"))
self.editingDefaults = False
return
idx = self.codeItems.findText(name)
if idx < 0:
self.editingDefaults = False
return
self.codeItems.removeItem(idx)
self.config["code"].pop(name)
name = list(self.config["code"].keys())
if len(name) > 0:
name = name[0]
self.codeItems.setCurrentText(name)
self.selectCode(name)
self.editingDefaults = False
