CODEWITHSUNDEEP
pythonpyqtpyqt5
Slater
Slater

Reputation: 21

Issue with Timer scope in PyQt5

I am creating an oven monitoring program, that reaches out to some PID controllers over Modbus TCP. I am trying to implement an email alerting part that will monitor the temperature and if it's within tolerance. If it goes out of tolerance it is to send an email and then send another every 10 mins after that it stays out of tolerance. I am sure that I have something screwed up in my scope, but for the life of me I cannot figure out what. When the oven goes out of tolerance my 'inTolerance' function goes to work. It sends 1 email and should start the timer, but my 'is_alive' call does not return true. So when 'inTolerance' calls again it send another email and then bombs out as I believe it attempts to start another 't' timer.

Any help and a sanity check would be extremely helpful and appreciated.

from PyQt5 import QtCore, QtGui, QtWidgets
from modbusTest import Oven
from emailModule import emailer
import time
from threading import Timer




class Ui_Form(object):
    def setupUi(self, Form):
        Form.setObjectName("Form")
        Form.resize(170, 260)
        self.spinBox = QtWidgets.QSpinBox(Form)
        self.spinBox.setGeometry(QtCore.QRect(10, 90, 61, 20))
        self.spinBox.setObjectName("setpoint")
        self.lcdNumber = QtWidgets.QLCDNumber(Form)
        self.lcdNumber.setGeometry(QtCore.QRect(10, 10, 150, 60))
        self.lcdNumber.setObjectName("lcdNumber")
        self.pushButton = QtWidgets.QPushButton(Form)
        self.pushButton.setGeometry(QtCore.QRect(120, 89, 41, 22))
        self.pushButton.setObjectName("pushButton")
        self.lineEdit = QtWidgets.QLineEdit(Form)
        self.lineEdit.setGeometry(QtCore.QRect(10, 130, 105, 20))
        font = QtGui.QFont()
        font.setPointSize(8)
        self.lineEdit.setFont(font)
        self.lineEdit.setObjectName("lineEdit")
        self.spinBox_2 = QtWidgets.QSpinBox(Form)
        self.spinBox_2.setGeometry(QtCore.QRect(77, 90, 35, 20))
        self.spinBox_2.setObjectName("tolerance")
        self.spinBox_2.setValue(5)
        self.label = QtWidgets.QLabel(Form)
        self.label.setGeometry(QtCore.QRect(20, 70, 41, 15))
        self.label.setObjectName("label")
        self.label_2 = QtWidgets.QLabel(Form)
        self.label_2.setGeometry(QtCore.QRect(10, 112, 71, 16))
        self.label_2.setObjectName("label_2")
        self.listWidget = QtWidgets.QListWidget(Form)
        self.listWidget.setGeometry(QtCore.QRect(10, 160, 150, 91))
        self.listWidget.setObjectName("listWidget")
        self.label_3 = QtWidgets.QLabel(Form)
        self.label_3.setGeometry(QtCore.QRect(70, 70, 51, 16))
        self.label_3.setObjectName("label_3")
        self.pushButton_2 = QtWidgets.QPushButton(Form)
        self.pushButton_2.setGeometry(QtCore.QRect(120, 129, 40, 22))
        self.pushButton_2.setObjectName("pushButton_2")



        self.retranslateUi(Form)
        QtCore.QMetaObject.connectSlotsByName(Form)


        self.p1 = Oven('IP')
        self.p1.connect()
        self.lcdNumber.display(self.p1.readTemp())

        #print(self.t.is_alive())
        #self.t.start()
        #print(self.t.is_alive())


        #TODO set spinbox values to database table values
        ########################################################################################################

        self.tolerance =  float(self.spinBox_2.value())
        self.spinBox.setValue(self.p1.readSP())
        self.setPoint = float(self.spinBox.value())

        ########################################################################################################

        self.pushButton.clicked.connect(self.setter)
        QtCore.QTimer.singleShot(1000, self.displayer)

        self.pushButton_2.clicked.connect(self.emailerList)
        self.emailList = []
        self.t = Timer(10.0, None)


    def emailerList(self):
        if len(self.lineEdit.text()) == 0:
            None
        else:
            self.emailList.append(self.lineEdit.text())
            self.listWidget.addItem(self.lineEdit.text())
            self.lineEdit.clear()



    def displayer(self):
        temp = self.p1.readTemp()
        self.lcdNumber.display(temp)
        self.inTolerance(self.tolerance, temp, self.setPoint)
        QtCore.QTimer.singleShot(1000, self.displayer)

    def setter(self):
        self.setPoint = float(self.spinBox.value())
        self.p1.writeSP(self.setPoint)
        self.tolerance = float(self.spinBox_2.value())

    def inTolerance(self, tolerance, temp, setPoint):
        if temp > (setPoint + tolerance) or temp < (setPoint - tolerance):
            self.lcdNumber.setStyleSheet("background-color: rgb(255, 0, 0);")
            print(self.t.is_alive())
            if not self.t.is_alive():
                emailer(self.emailList, 'Test Oven', temp, setPoint)
                print('Email Sent')
                self.t.start()
                time.sleep(1)
                print(self.t.is_alive())
        else:
            self.t.cancel()
            self.lcdNumber.setStyleSheet("background-color: rgb(255, 255, 255);")

    def retranslateUi(self, Form):
        _translate = QtCore.QCoreApplication.translate
        Form.setWindowTitle(_translate("Form", "Form"))
        self.pushButton.setText(_translate("Form", "Set"))
        self.label.setText(_translate("Form", "Setpoint"))
        self.label_2.setText(_translate("Form", "Alarm Emails:"))
        self.label_3.setText(_translate("Form", "Tolerance"))
        self.pushButton_2.setText(_translate("Form", "Add"))


if __name__ == "__main__":
    import sys
    sys_argv = sys.argv
    sys_argv += ['--style', 'Fusion']
    app = QtWidgets.QApplication(sys_argv)
    Form = QtWidgets.QWidget()
    ui = Ui_Form()
    ui.setupUi(Form)
    Form.show()
    sys.exit(app.exec_())

Upvotes: 0

Views: 90

Answers (1)

musicamante
musicamante

Reputation: 48231

The main reason of your issue is that you're calling cancel(), which causes the timer to invalidate itself even if it has not been started yet, and the result is that after this the timer will be never actually started.

After that there is another problem: Thread objects can only be started once, and you would need to create a new Timer object whenever you want to start it again.

That said, you should not mix timer objects, and when dealing with threads it's usually better to use what Qt provides.

In your case, the solution is to use a QElapsedTimer, which is an object that can return the elapsed time since it was (re)started.

Note that I'm using a QWidget class (and simplified the ui just for this example), more about that after the code.

class Window(QtWidgets.QWidget):
    def __init__(self, parent=None):
        super(Window, self).__init__(parent)
        self.resize(170, 260)
        layout = QtWidgets.QGridLayout(self)

        self.lcdNumber = QtWidgets.QLCDNumber(self)
        layout.addWidget(self.lcdNumber, 0, 0, 1, 2)

        self.spinBox = QtWidgets.QSpinBox(self)
        layout.addWidget(self.spinBox, 1, 0)

        self.spinBox_2 = QtWidgets.QSpinBox(self)
        layout.addWidget(self.spinBox_2, 1, 1)
        self.spinBox_2.setValue(5)


        self.p1 = Oven('P1')
        self.p1.connect()
        self.lcdNumber.display(self.p1.readTemp())

        self.tolerance =  float(self.spinBox_2.value())
        self.setPoint = float(self.spinBox.value())

        self.emailList = []

        # create a timer that will call displayer each second; having a reference
        # to the timer allows to stop it if required
        self.displayerTimer = QtCore.QTimer(interval=1000, timeout=self.displayer)
        self.displayerTimer.start()
        self.elapsedTimer = QtCore.QElapsedTimer()

    def displayer(self):
        temp = self.p1.readTemp()
        self.lcdNumber.display(temp)
        self.inTolerance(self.tolerance, temp, self.setPoint)

    def inTolerance(self, tolerance, temp, setPoint):
        if temp > (setPoint + tolerance) or temp < (setPoint - tolerance):
            self.lcdNumber.setStyleSheet("background-color: rgb(255, 0, 0);")
            if not self.elapsedTimer.isValid():
                # the timer has not been started or has been invalidated
                self.elapsedTimer.start()
            elif self.elapsedTimer.elapsed() > 10000:
                # ten seconds have passed, send the email
                emailer(self.emailList, 'Test Oven', temp, setPoint)
                # restart the timer, otherwise another mail could possibly be
                # sent again the next cycle
                self.elapsedTimer.start()
            # in any other case, the elapsed time is less than the limit, just
            # go on
        else:
            # temperature is within tolerance, invalidate the timer so that it can
            # be restarted when necessary
            self.elapsedTimer.invalidate()
            self.lcdNumber.setStyleSheet("background-color: rgb(255, 255, 255);")


if __name__ == "__main__":
    import sys
    sys_argv = sys.argv
    sys_argv += ['--style', 'Fusion']
    app = QtWidgets.QApplication(sys_argv)
    window = Window()
    window.show()
    sys.exit(app.exec_())

As said, I'm using a QWidget class.
It seems like you're using the output of the pyuic utility to create your program, which is something you should never do. You should create your program in a separate script, and use that generated file as an imported module. The py file created from pyuic should NEVER be edited.
In this case I created the interface completely from the code, but you can still recreate your ui in designer and use the generated py file as explained in the documentation (the third method, multiple inheritance approach, is usually the best).

Upvotes: 1

Related Questions