def calibrate(self): self.logSomething('Kalibracja!') self.dialog = CalibrateDialogController() self.dialog.calibrateGetValue.clicked.connect(self.dialogGetValueClicked) self.dialog.calibrateInsertValue.clicked.connect(self.dialogInsertValueClicked) self.dialog.calibrate.clicked.connect(self.dialogCalibrateClicked) self.dialog.show()
class MainWindowController(QtWidgets.QMainWindow, Ui_MainWindow, metaclass=FinalMeta): ser = serial.Serial thread = None alive = threading.Event() file = None dev = None epWrite = None epRead = None dialog = None helpDialog = None authorsDialog = None message = [] manualWorkData = ["0","0"] testDataFrame = ["0","0"] loadTest = [[],[],[]] underWorkFlag = False isManualWork =False timer = None timerIterator = 0 def __init__(self, parent=None): super(MainWindowController, self).__init__(parent) self.setupUi(self) self.fill_ports_list() self.connectSignals() self.manualWorkStateChanged(False) self.terminal.clear() self.tabWidget.widget(1).setEnabled(False) self.logSomething("Aby zobaczyc dostepne komendy wpisz: help") def fill_ports_list(self): for portname in Functions.SerialFunctions.enumerateSerialPorts(): self.uartPortList.addItem(portname) def connectSignals(self): self.saveToFile.stateChanged.connect(self.saveToFileStateChanged) self.connectButton.clicked.connect(self.connectButtonPushed) self.stopButton.clicked.connect(self.stopButtonAction) self.manualWork.stateChanged.connect(self.manualWorkStateChanged) self.calibrateTens.clicked.connect(self.calibrate) self.actionZamknij.triggered.connect(self.closeWindow) self.actionPomoc.triggered.connect(self.helpClicked) self.actionAutorzy.triggered.connect(self.authorsClicked) self.quickSend.clicked.connect(self.interpretLineMessage) self.quickMessage.returnPressed.connect(self.interpretLineMessage) self.rescanButton.clicked.connect(self.rescanButtonClicked) self.actionManual.clicked.connect(self.actionManualClicked) self.engOneMin.clicked.connect(self.engOneMinClicked) self.engOnePlus.clicked.connect(self.engOnePlusClicked) self.engTwoMin.clicked.connect(self.engTwoMinClicked) self.engTwoPlus.clicked.connect(self.engTwoPlusClicked) self.engBothMin.clicked.connect(self.engBothMinClicked) self.engBothPlus.clicked.connect(self.engBothPlusClicked) def actionManualClicked(self): if self.actionManual.text() == "START": self.manualWorkData[0] = str(self.engOneInit.value()) self.manualWorkData[1] = str(self.engTwoInit.value()) if self.checkAndSendParameters(self.poleNumber.text(), self.poleNumberTwo.text(), self.safetyTime.value()): self.actionManual.setText("STOP") self.logSomething('Start pracy manualnej') else: Utils.ComunicationUtils.sendStop(self.ser) self.actionManual.setText("START") self.logSomething('Stop pracy manualnej') def rescanButtonClicked(self): self.uartPortList.clear() for portname in Functions.SerialFunctions.enumerateSerialPorts(): self.uartPortList.addItem(portname) def saveToFileStateChanged(self, state): if state == 0: self.groupBox.setEnabled(False) self.logSomething('Zapisywanie plikow wylaczone') else: self.groupBox.setEnabled(True) self.logSomething('Zapisywanie plikow wlaczone') def manualWorkStateChanged(self, state): if state == 0: if not self.underWorkFlag: self.manualGroupBox.setEnabled(False) self.logSomething('Praca manualna wylaczona') else: self.logSomething('Nie mozna zmieniac stanu pracy manualnej podczas trwania testu.') else: if not self.underWorkFlag: self.manualGroupBox.setEnabled(True) self.logSomething('Praca manualna wlaczona') self.isManualWork = True else: self.logSomething('Nie mozna zmieniac stanu pracy manualnej podczas trwania testu.') def connectButtonPushed(self): if self.usb_hid.isHidden(): self.uartConnection(self.uartPortList.currentText(), int(self.uartBaudRateList.currentText())) else: self.usbHIDConnection(self.vendorID.text(), self.productID.text()) def uartConnection(self, cur_item, baudrate): if self.connectButton.text() == u"Połącz": self.connectButton.setText(u"Rozłącz") if cur_item is not None: fullname = Functions.SerialFunctions.fullPortName(cur_item) try: self.tabWidget.setEnabled(False) self.ser = serial.Serial(port=fullname, baudrate=baudrate, timeout=None, writeTimeout=3) self.logSomething('Otwarto port %s' % cur_item) self.StartThread() except SerialException as e: self.logSomething('%s error:\n %s' % (cur_item, e)) self.tabWidget.setEnabled(True) self.connectButton.setText(u"Połącz") else: self.connectButton.setText(u"Połącz") if self.ser.isOpen(): self.StopThread() self.tabWidget.setEnabled(True) self.ser.close() self.logSomething('Zamknieto port %s' % cur_item) self.ser = None def usbHIDConnection(self, vendorIDText, productIDText): if vendorIDText is not "" and productIDText is not "" and len(vendorIDText) is 4 and len(productIDText) is 4: vendorId = Functions.MiscFunctions.stringToHex(vendorIDText) # 0x477 productId = Functions.MiscFunctions.stringToHex(productIDText) # 0x5620 if self.connectButton.text() == u"Połącz": self.connectButton.setText(u"Rozłącz") self.tabWidget.setEnabled(False) self.dev = usb.core.find(idVendor=vendorId, idProduct=productId) if self.dev is None: raise ValueError('Device not found') # get an endpoint instance cfg = self.dev.get_active_configuration() intf = cfg[(0, 0)] self.epWrite = intf[1] self.epRead = intf[0] assert self.epWrite is not None assert self.epRead is not None self.StartThread() else: self.connectButton.setText(u"Połącz") self.tabWidget.setEnabled(True) self.dev = None self.epRead = None self.epWrite = None self.StopThread() elif self.vendorID.text() is "" or self.productID.text() is "": self.logSomething('Please, fill all fileds needed to connect via USB HID.') else: self.logSomething('VendorId or ProductId have incorrect structure. It should consist of 4 characters.') def calibrate(self): self.logSomething('Kalibracja!') self.dialog = CalibrateDialogController() self.dialog.calibrateGetValue.clicked.connect(self.dialogGetValueClicked) self.dialog.calibrateInsertValue.clicked.connect(self.dialogInsertValueClicked) self.dialog.calibrate.clicked.connect(self.dialogCalibrateClicked) self.dialog.show() def stopButtonAction(self): if self.connectButton.text() == u"Rozłącz": Utils.ComunicationUtils.sendEmergencyStop(self.ser) self.logSomething("Stop awaryjny") else: self.logSomething("Polaczenie nie zostalo nawiazane") def StartThread(self): """Start the receiver thread""" self.thread = threading.Thread(target=self.CommunicationThread) self.thread.setDaemon(1) self.alive.set() self.thread.start() self.ser.rts = True self.ser.dtr = True def StopThread(self): """Stop the receiver thread, wait until it's finished.""" if self.thread is not None: self.alive.clear() # clear alive event for thread self.thread.join() # wait until thread has finished self.thread = None def CommunicationThread(self): """\ Thread that handles the incoming traffic. """ if self.usb_hid.isHidden(): Utils.ComunicationUtils.sendConnected(self.ser) while self.alive.isSet(): if self.usb_hid.isHidden(): data_left = self.ser.inWaiting() b = self.ser.read(data_left) if len(b) > 0: for i in range(0, len(b)): if type(b[i]) == int: byte = b[i] elif type(b[i]) == str: byte = ord(b[i]) if Utils.ComunicationUtils.isStartFrame(byte): self.message = [byte] elif Utils.ComunicationUtils.isStopFrame(byte): self.message.append(byte) self.dataRecieved(self.message) elif len(self.message) > 500: self.message = [] else: self.message.append(byte) else: try: data = self.dev.read(self.epRead, 1000) # print data sret = ''.join([chr(x) for x in data]) # print sret self.logSomething(sret) except usb.core.USBError as e: data = None if e.args == ('Operation timed out',): continue def writeToFile(self, pwm1=None, pwm2 = None, speed1=None, speed2=None, current1=None, current2=None, voltage=None,pressure=None): if self.file is not None: self.file.write(pwm1) self.file.write(';') self.file.write(pwm2) if (self.saveSpeed.isChecked() or self.saveCurrent.isChecked() or self.saveVoltage.isChecked() or self.savePressure.isChecked()): self.file.write(';') if self.saveSpeed.isChecked() and speed1 is not None and speed2 is not None: self.file.write(speed1) self.file.write(';') self.file.write(speed2) if (self.saveCurrent.isChecked() or self.saveVoltage.isChecked() or self.savePressure.isChecked()): self.file.write(';') if self.saveCurrent.isChecked() and current1 is not None and current2 is not None: self.file.write(current1) self.file.write(';') self.file.write(current2) if (self.saveVoltage.isChecked() or self.savePressure.isChecked()): self.file.write(';') if self.saveVoltage.isChecked() and voltage is not None: self.file.write(voltage) if (self.savePressure.isChecked()): self.file.write(';') if self.savePressure.isChecked() and pressure is not None: self.file.write(pressure) self.file.write('\n') def dialogGetValueClicked(self): if self.connectButton.text() == u"Rozłącz": Utils.ComunicationUtils.sendGetValue(self.ser) self.logSomething("Wyslano rzadanie podania wartosci z tensometru") else: self.logSomething("Polaczenie nie zostalo nawiazane") def dialogInsertValueClicked(self): self.logSomething("Dodano pomiar!") def dialogCalibrateClicked(self): if self.connectButton.text() == u"Rozłącz": if self.dialog.a is not None: Utils.ComunicationUtils.sendFunctionParameters(self.ser, self.dialog.a, self.dialog.b) self.logSomething("Wyslano parametry funkcji: y=" + str(self.dialog.a) + "x+" + str(self.dialog.b)) file = open("config.txt", 'w') file.write("ParamA="+str(self.dialog.a)+"\n") file.write("ParamB="+str(self.dialog.b)+"\n") file.close() else: self.logSomething("Za malo pomiarow") else: self.logSomething("Polaczenie nie zostalo nawiazane") def logSomething(self, string): self.terminal.appendPlainText(datetime.now().strftime("%H:%M:%S.%f") + ': ' + string) self.terminal.selectAll() cursor = self.terminal.textCursor() cursor.clearSelection() self.terminal.setTextCursor(cursor) self.terminal.verticalScrollBar().setValue(self.terminal.verticalScrollBar().maximum()) def dataRecieved(self, data): # string = "[%s]" % ", ".join(map(str, data)) # self.logSomething(string) if (data[1] & Utils.ComunicationUtils.FUNCTION_MASK) == Utils.ComunicationUtils.MEASURE: self.getMeassuresAndSaveThem(data) elif (data[1] & Utils.ComunicationUtils.FUNCTION_MASK) == Utils.ComunicationUtils.CALIBRATE_GET_VALUE: self.logSomething('Otrzymano wartosc') self.putValueToCalibrateDialog(data) elif (data[1] & Utils.ComunicationUtils.FUNCTION_MASK) == Utils.ComunicationUtils.SET_TEST_PARAMS: self.openFileAndStartTest() elif (data[1] & Utils.ComunicationUtils.FUNCTION_MASK) == Utils.ComunicationUtils.CONNECTION: self.connectedToDevice() elif (data[1] & Utils.ComunicationUtils.FUNCTION_MASK) == Utils.ComunicationUtils.START_TEST: self.startTestRecieved() elif (data[1] & Utils.ComunicationUtils.FUNCTION_MASK) == Utils.ComunicationUtils.STOP_TEST: self.testStopped() else: self.logSomething('Nieznany komunikat') def startTestRecieved (self): self.logSomething('Start testu') self.underWorkFlag = True if self.isManualWork: Utils.ComunicationUtils.sendPWMFrame(self.ser,self.manualWorkData) else: self.timerIterator = 0 self.testDataFrame = [self.loadTest[0][self.timerIterator],self.loadTest[1][self.timerIterator]] Utils.ComunicationUtils.sendPWMFrame(self.ser,self.testDataFrame) self.timer = threading.Timer(float(self.loadTest[2][self.timerIterator])/1000,self.timerInterrupt) self.timer.start() def timerInterrupt (self): self.timer.cancel() self.timerIterator += 1 if self.timerIterator < len(self.loadTest[0]): self.testDataFrame = [self.loadTest[0][self.timerIterator],self.loadTest[1][self.timerIterator]] Utils.ComunicationUtils.sendPWMFrame(self.ser,self.testDataFrame) self.timer = threading.Timer(float(self.loadTest[2][self.timerIterator])/1000,self.timerInterrupt) self.timer.start() elif self.timerIterator == len(self.loadTest[0]): Utils.ComunicationUtils.sendStop(self.ser) def testStopped (self): self.groupBox.setEnabled(True) self.saveToFile.setEnabled(True) self.logSomething("Koniec testu") if self.file is not None: self.logSomething('Zamknieto plik') self.file.close() self.file = None if self.actionManual.text() == "STOP": self.actionManual.setText("START") self.underWorkFlag = False def connectedToDevice (self): self.logSomething("Podlaczono do urzadzenia") try: f = open("config.txt",'r') self.logSomething("Wczytano plik konfiguracyjny.") firstLine = f.readline() splitOne = firstLine.split("=") paramA = float(splitOne[1]) secondLine = f.readline() splitTwo = secondLine.split("=") paramB = float(splitTwo[1]) Utils.ComunicationUtils.sendFunctionParameters(self.ser, paramA, paramB) f.close() except FileNotFoundError as e: self.logSomething("Nie znaleziono pliku konfiguracyjnego.") self.logSomething('Przed rozpoczeciem testow skalibruj tensometr.') def openFileAndStartTest (self): if self.groupBox.isEnabled(): self.groupBox.setEnabled(False) self.saveToFile.setEnabled(False) if self.fileName.text() is not None and self.fileName.text() != "": filename = self.fileName.text() + ".txt" self.file = open(filename, 'w') self.writeToFile('pwm1', 'pwm2', 'n1', 'n2', 'I1', 'I2', 'U', 'm') else: self.logSomething("Test zostanie zapisany z nazwa aktualnej daty") self.file = open(datetime.now().strftime("%y%m%d%H%M%S") + ".txt", 'w') self.writeToFile('pwm1', 'pwm2', 'n1', 'n2', 'I1', 'I2', 'U', 'm') Utils.ComunicationUtils.sendStartTest(self.ser) def checkAndSendParameters(self, poleNumberText, poleNumberTwoText, safetyTime): if self.connectButton.text() == u"Rozłącz": if self.poleNumber is not None: pNumber = int(poleNumberText) pNumber2 = int(poleNumberTwoText) if pNumber > 1: Utils.ComunicationUtils.sendTestParameters(self.ser, pNumber, pNumber2, safetyTime) self.logSomething("Parametry testu wyslane") return True else: self.logSomething("Zla wartosc liczby par biegunow") return False else: self.logSomething("Polaczenie nie zostalo nawiazane") return False def putValueToCalibrateDialog(self, data): i = data[1] & Utils.ComunicationUtils.NUMBER_MASK i += 2 meassure = 0 # meassure = (data[2] & Utils.ComunicationUtils.DATA_MASK)+((data[3] & Utils.ComunicationUtils.DATA_MASK)<<7)+((data[4] & Utils.ComunicationUtils.DATA_MASK)<<14) for j in range(2, i): jumpBit = (7 * (j - 2)) parsedData = (data[j] & Utils.ComunicationUtils.DATA_MASK) meassure += parsedData << jumpBit self.dialog.measure = meassure self.dialog.measurements.setText(str(meassure)) def getMeassuresAndSaveThem(self, data): i = data[1] & Utils.ComunicationUtils.NUMBER_MASK i += 2 n1 = 0 n2 = 0 for j in range(2, i): if j < 2 + ((i - 2) / 2): jumpBit = (7 * (j - 2)) parsedData = (data[j] & Utils.ComunicationUtils.DATA_MASK) n1 += parsedData << jumpBit else: jumpBit = int(7 * (j - 2 - ((i - 2) / 2))) parsedData = (data[j] & Utils.ComunicationUtils.DATA_MASK) n2 += parsedData << jumpBit oldI = i i += data[i] & Utils.ComunicationUtils.NUMBER_MASK i += 1 i1 = ((data[oldI + 1] & Utils.ComunicationUtils.DATA_MASK) + float("{0:.2f}".format(( (data[oldI + 2] & Utils.ComunicationUtils.DATA_MASK) / 100 - int(( (data[oldI + 2] & Utils.ComunicationUtils.DATA_MASK) / 100)))))) i2 = ((data[oldI + 3] & Utils.ComunicationUtils.DATA_MASK) + float("{0:.2f}".format((( (data[oldI + 4] & Utils.ComunicationUtils.DATA_MASK) / 100)- int(( (data[oldI + 4] & Utils.ComunicationUtils.DATA_MASK) / 100)))))) v = ((data[oldI + 5] & Utils.ComunicationUtils.DATA_MASK) + float("{0:.2f}".format(( (data[oldI + 6] & Utils.ComunicationUtils.DATA_MASK) / 100- int(( (data[oldI + 6] & Utils.ComunicationUtils.DATA_MASK) / 100)))))) oldI = i + 1 i += data[i] & Utils.ComunicationUtils.NUMBER_MASK i += 1 p = 0 #PWM1 i PWM2 w ramce z naciskiem for j in range(oldI+1, oldI+4): jumpBit = (7 * (j - (oldI+1))) parsedData = (data[j] & Utils.ComunicationUtils.DATA_MASK) p += parsedData << jumpBit if (data[oldI] & Utils.ComunicationUtils.DATA_MASK) == 0x01: p*=(-1) pwm1 = (data[oldI+4] & Utils.ComunicationUtils.DATA_MASK) pwm2 = (data[oldI+5] & Utils.ComunicationUtils.DATA_MASK) self.printMeasuresInLabels(str(pwm1), str(pwm2), str(n1), str(n2), str(i1), str(i2), str(v), str(p)) self.writeToFile(str(pwm1), str(pwm2), str(n1), str(n2), str(i1), str(i2), str(v), str(p)) def closeWindow(self): self.close() def helpClicked(self): self.helpDialog = HelpDialogController() self.helpDialog.show() def authorsClicked(self): self.auhtorsDialog = AuthorsDialogController() self.auhtorsDialog.show() def printMeasuresInLabels(self, pwm1, pwm2, speed1, speed2, current1, current2, voltage, pressure): self.PWMFirstMeter.setText(pwm1) self.PWMSecondMeter.setText(pwm2) self.speedMeterN1.setText(speed1) self.speedMeterN2.setText(speed2) self.currentMeterI1.setText(current1) self.currentMeterI2.setText(current2) self.voltageMeter.setText(voltage) self.pressureMeter.setText(pressure) def interpretLineMessage(self): message = self.quickMessage.text() self.logSomething("CMD: " + message) spl = message.split(' ') if spl[0] == Utils.CommandUtils.CONNECT_COMMAND: self.interpretConnectComman(spl) elif spl[0] == Utils.CommandUtils.START_COMMAND: self.interpretStartCommand(spl) elif spl[0] == Utils.CommandUtils.HELP_COMMAND: self.interpretHelpCommand(spl) elif spl[0] == Utils.CommandUtils.LOAD_COMMAND: self.interpretLoadCommand(spl) elif spl[0] == Utils.CommandUtils.STOP_COMMAND: self.interpretStopCommand(spl) elif spl[0] == Utils.CommandUtils.CLEAR_COMMAND: self.interpretClearCommand(spl) elif spl[0] == "crash": crashThisShit() else: self.logSomething("Bledna komenda") self.quickMessage.clear() def interpretClearCommand(self,spl): if len(spl) is 1: self.terminal.clear() else: self.logSomething("Bledna liczba przesylanych danych") def interpretConnectComman(self, spl): if len(spl) is 4: if spl[1] == "uart": self.uartConnection(spl[2], spl[3]) elif spl[1] == "usb": self.usbHIDConnection(spl[2], spl[3]) else: self.logSomething("Bledne parametry") else: self.logSomething("Bledna liczba przesylanych danych") def interpretStartCommand(self, spl): if len(spl) is 2: if spl[1] == "manual" and not self.underWorkFlag: if not self.manualWork.isChecked(): self.manualWork.setChecked(True) if self.actionManual.text() == "START": self.manualWorkData[0] = str(self.engOneInit.value()) self.manualWorkData[1] = str(self.engTwoInit.value()) if self.checkAndSendParameters(self.poleNumber.text(), self.poleNumberTwo.text(), self.safetyTime.value()): self.actionManual.setText("STOP") self.logSomething('Start pracy manualnej') elif spl[1] == "test" and not self.underWorkFlag: if len(self.loadTest[0]) > 0: if self.manualWork.isChecked(): self.manualWork.setChecked(False) if self.isManualWork: self.isManualWork = False if self.checkAndSendParameters(self.poleNumber.text(), self.poleNumberTwo.text(), self.safetyTime.value()): self.logSomething('Start testu') else: self.logSomething('Test nie zostal zaladowany, lub zaladowal sie blednie') else: self.logSomething("Bledna liczba przesylanych danych") def interpretHelpCommand(self, spl): if len(spl) is 1: self.logSomething("Pierwszy czlon to komenda, kolejne czlony to parametry") self.logSomething("connect [uart,usb] [serialport,vendorId] [baudrate,productId] - polaczenie do portu") self.logSomething("load [file.txt, absolut_path\\file.txt] - wczytanie testu z pliku") self.logSomething("start [manual, test] - start testu lub pracy manualnej") self.logSomething("stop [manual] - stop pracy manualnej") self.logSomething("clear - czyszcenie termianala") else: self.logSomething("Bledna liczba przesylanych danych") def interpretLoadCommand(self,spl): if len(spl) is 2: try: f = open(spl[1],'r') self.logSomething("Wczytano test z pliku.") testText = f.read() commands = testText.split(' ') if self.checkIfCommandsHaveCorrectShape(commands): for i in range(0,len(commands)): pwmFirst = commands[i].split(',')[0][1:] pwmSecond = commands[i].split(',')[1] time = commands[i].split(',')[2][:-1] if self.checkIfParamsAreCorrect(pwmFirst,pwmSecond,time,i): if i is 0: self.loadTest = [[],[],[]] self.loadTest[0].append(pwmFirst) self.loadTest[1].append(pwmSecond) self.loadTest[2].append(time) if i is len(commands)-1: self.logSomething("Parametry testu zostaly wczytane poprawnie.") except FileNotFoundError as e: self.logSomething("Nie znaleziono pliku.") else: self.logSomething("Bledna liczba przesylanych danych") def interpretStopCommand(self,spl): if len(spl) is 2: if spl[1] == "manual": if self.actionManual.text() == "STOP": Utils.ComunicationUtils.sendStop(self.ser) self.actionManual.setText("START") self.logSomething('Stop pracy manualnej') else: self.logSomething("Bledna liczba przesylanych danych") def checkIfParamsAreCorrect(self,pwmFirst,pwmSecond,time,i): if int(pwmFirst) < 0 or int(pwmFirst) > 100: self.logSomething("Blad: W "+ (i+1) + " komendzie 1 parametr jest niepoprawny.") return False if int(pwmSecond) < 0 or int(pwmSecond) > 100: self.logSomething("Blad: W "+ (i+1) + " komendzie 2 parametr jest niepoprawny.") return False if int(time) < 100: self.logSomething("Blad: W "+ (i+1) + " komendzie 3 parametr jest niepoprawny.") return False return True def checkIfCommandsHaveCorrectShape(self,commands): for i in range(0,len(commands)): if len(commands[i].split(',')) is not 3: self.logSomething("Blad: " +(i+1)+ " komenda jest niepoprawna.") return False if commands[i][0] != "[" and commands[i][len(commands[i])-1] != "]": self.logSomething("Blad: " +(i+1)+ " komenda jest niepoprawna.") return False return True def engOneMinClicked(self): self.manualWorkData[0] = self.manualEquation(self.manualWorkData[0], self.engOneJump.value(), True) self.sendManualDataWork() def engOnePlusClicked(self): self.manualWorkData[0] = self.manualEquation(self.manualWorkData[0], self.engOneJump.value(), False) self.sendManualDataWork() def engTwoMinClicked(self): self.manualWorkData[1] = self.manualEquation(self.manualWorkData[1], self.engTwoJump.value(), True) self.sendManualDataWork() def engTwoPlusClicked(self): self.manualWorkData[1] = self.manualEquation(self.manualWorkData[1], self.engTwoJump.value(), False) self.sendManualDataWork() def engBothMinClicked(self): self.doubleManualEquation(True) self.sendManualDataWork() def engBothPlusClicked(self): self.doubleManualEquation(False) self.sendManualDataWork() def manualEquation(self, data, jump, sub): if self.connectButton.text() == u"Rozłącz": if sub: number = int(data) - jump if number < 0: number = 0 data = str(number) return data else: number = int(data) + jump if number > 100: number = 100 data = str(number) return data else: self.logSomething("Polaczenie nie zostalo nawiazane") return data def doubleManualEquation(self, sub): if self.connectButton.text() == u"Rozłącz": if sub: number1 = int(self.manualWorkData[0]) - self.engBothJump.value() number2 = int(self.manualWorkData[1]) - self.engBothJump.value() if number1 < 0: number1 = 0 if number2 < 0: number2 = 0 self.manualWorkData[0] = str(number1) self.manualWorkData[1] = str(number2) else: number1 = int(self.manualWorkData[0]) + self.engBothJump.value() number2 = int(self.manualWorkData[1]) + self.engBothJump.value() if number1 > 100: number1 = 100 if number2 > 100: number2 = 100 self.manualWorkData[0] = str(number1) self.manualWorkData[1] = str(number2) else: self.logSomething("Polaczenie nie zostalo nawiazane") def sendManualDataWork(self): if self.connectButton.text() == u"Rozłącz": Utils.ComunicationUtils.sendPWMFrame(self.ser, self.manualWorkData) else: self.logSomething("Polaczenie nie zostalo nawiazane") def closeEvent(self,event): self.logSomething('Program zostal zamkniety') if self.file is not None: self.logSomething('Zamknieto plik') self.file.close() self.file = None if self.connectButton.text() == u"Rozłącz": self.connectButtonPushed()