PyQt5 crashing with threading and progress bar - python-3.x

I have a progress bar that is controlled by a start stop button. The progress bar fills up using a thread. However, whenever I run the program it crashes at random times (different time each time program is run).
class Window(QWidget):
def __init__(self):
super().__init__()
self.initUI()
self.fill_thread = None
Thread for filling progress bar. I have tried using both time.sleep and QThread.msleep.
def fill_bar(self):
while not self.stop_fill and self.completed < 100:
self.completed += 0.5
QThread.msleep(100)
self.chargeprog.setValue(self.completed)
Buttons that alternate between start and stop that call the thread
def charging(self):
if self.chargebtn.text() == 'Start':
self.chargebtn.setText('Stop')
self.chargebtn.setStyleSheet('background-color:red')
self.fill_thread = threading.Thread(target=self.fill_bar)
self.stop_fill = False
self.fill_thread.start()
else:
self.stop_fill = True
self.fill_thread.join()
self.chargebtn.setText('Start')
self.chargebtn.setStyleSheet('background-color:limegreen')

window.py
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'window.ui'
#
# Created by: PyQt5 UI code generator 5.6
#
# WARNING! All changes made in this file will be lost!
from PyQt5 import QtCore, QtGui, QtWidgets
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(800, 600)
self.centralwidget = QtWidgets.QWidget(MainWindow)
self.centralwidget.setObjectName("centralwidget")
self.progressBar = QtWidgets.QProgressBar(self.centralwidget)
self.progressBar.setGeometry(QtCore.QRect(180, 150, 118, 23))
self.progressBar.setProperty("value", 24)
self.progressBar.setObjectName("progressBar")
self.pushButton = QtWidgets.QPushButton(self.centralwidget)
self.pushButton.setGeometry(QtCore.QRect(330, 150, 75, 23))
self.pushButton.setObjectName("pushButton")
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QtWidgets.QMenuBar(MainWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 800, 18))
self.menubar.setObjectName("menubar")
MainWindow.setMenuBar(self.menubar)
self.statusbar = QtWidgets.QStatusBar(MainWindow)
self.statusbar.setObjectName("statusbar")
MainWindow.setStatusBar(self.statusbar)
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def retranslateUi(self, MainWindow):
_translate = QtCore.QCoreApplication.translate
MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow"))
self.pushButton.setText(_translate("MainWindow", "PushButton"))
test.py
import sys
from PyQt5.QtWidgets import QApplication,QMainWindow
from PyQt5.QtCore import QThread,pyqtSignal
from window import Ui_MainWindow
class CThread(QThread):
valueChanged = pyqtSignal([int])
def __init__(self,value):
super().__init__()
self.stop_fill = False
self.completed = value
def run(self):
while not self.stop_fill and self.completed < 100:
self.completed += 0.5
self.sleep(1)
self.valueChanged.emit(self.completed)
class Window(QMainWindow,Ui_MainWindow):
def __init__(self):
super().__init__()
super().setupUi(self)
self.fill_thread = None
self.pushButton.clicked.connect(self.charging)
def charging(self):
if self.pushButton.text() == 'Start':
self.pushButton.setText('Stop')
self.pushButton.setStyleSheet('background-color:red')
print(self.progressBar.value())
self.fill_thread = CThread(self.progressBar.value())
self.fill_thread.valueChanged.connect(self.progressBar.setValue)
self.fill_thread.start()
else:
if self.fill_thread != None:
self.fill_thread.disconnect() # event unbind
self.fill_thread.stop_fill = True
self.fill_thread.wait()
self.fill_thread.quit()
print(self.fill_thread.isRunning())
self.pushButton.setText('Start')
self.pushButton.setStyleSheet('background-color:limegreen')
if __name__ == '__main__':
app = QApplication(sys.argv)
w = Window()
w.show()
sys.exit(app.exec_())
If you want communicate between multi-threads, you can try signal/slots.

Related

I tried to use the mutex. Why did it automatically stop without an error

I tried to use the mutex. Why did it automatically stop without an error.
Running will stop automatically after a while
This is my code, which can be run directly. Please help me to see what the problem is
Is my method wrong? Is there a better way to achieve it? I don't want my interface to get stuck
`
import time
from PyQt5 import QtWidgets, QtCore
from PyQt5.QtCore import QWaitCondition, QMutex
from PyQt5.QtWidgets import QMainWindow, QMessageBox, QApplication, QDesktopWidget
from PyQt5.QtCore import pyqtSignal
import sys
from PyQt5.QtCore import QThread
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(800, 600)
self.centralwidget = QtWidgets.QWidget(MainWindow)
self.centralwidget.setObjectName("centralwidget")
self.horizontalLayout = QtWidgets.QHBoxLayout(self.centralwidget)
self.horizontalLayout.setObjectName("horizontalLayout")
self.pushButton = QtWidgets.QPushButton(self.centralwidget)
self.pushButton.setObjectName("pushButton")
self.horizontalLayout.addWidget(self.pushButton)
self.label = QtWidgets.QLabel(self.centralwidget)
self.label.setObjectName("label")
self.horizontalLayout.addWidget(self.label)
self.pushButton_2 = QtWidgets.QPushButton(self.centralwidget)
self.pushButton_2.setObjectName("pushButton_2")
self.horizontalLayout.addWidget(self.pushButton_2)
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QtWidgets.QMenuBar(MainWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 800, 23))
self.menubar.setObjectName("menubar")
MainWindow.setMenuBar(self.menubar)
self.statusbar = QtWidgets.QStatusBar(MainWindow)
self.statusbar.setObjectName("statusbar")
MainWindow.setStatusBar(self.statusbar)
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def retranslateUi(self, MainWindow):
_translate = QtCore.QCoreApplication.translate
MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow"))
self.pushButton.setText(_translate("MainWindow", "PushButton"))
self.label.setText(_translate("MainWindow", "TextLabel"))
self.pushButton_2.setText(_translate("MainWindow", "stop"))
class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.__init2__()
def __init2__(self):
self.search_running = False
self.ui.pushButton.clicked.connect(self.search)
self.ui.pushButton_2.clicked.connect(self.stop_search)
def stop_search(self):
if self.search_running:
reply = QMessageBox.information(self, 'notice', 'Do you want to stop searching?',
QMessageBox.Yes | QMessageBox.Cancel)
if reply == QMessageBox.Yes:
self.search_thread.terminate()
self.__thread.resume()
self.search_running = False
self.ui.pushButton.setEnabled(True)
else:
QMessageBox.information(self, 'tip', 'no search!', QMessageBox.Ok)
def search(self):
if not self.search_running:
self.search_running = True
self.ui.pushButton.setEnabled(False)
self.search_thread = Search_Thread()
self.search_thread.trigger.connect(lambda i: self.c(i))
self.search_thread.complete.connect(self.search_complete)
self.search_thread.start()
def c(self, i):
self.ui.label.setText(str(i))
self.search_thread.resume()
def search_complete(self):
self.__thread.resume()
self.search_running = False
self.ui.pushButton.setEnabled(True)
class Search_Thread(QThread):
trigger = pyqtSignal(int)
complete = pyqtSignal()
mutex = QMutex()
cond = QWaitCondition()
def __init__(self):
super().__init__()
def run(self):
self.mutex.lock()
for i in range(10000):
for j in range(10000):
print(j)
for k in range(10000):
# time.sleep(0.1)
self.trigger.emit(i + j + k)
# time.sleep(0.1)
self.cond.wait(self.mutex)
self.complete.emit()
self.mutex.unlock()
def resume(self):
self.cond.wakeAll()
if __name__ == '__main__':
app = QApplication(sys.argv)
window = MainWindow()
screen = QDesktopWidget().screenGeometry()
height = 100
width = 300
window.setGeometry(int((screen.width() - width) / 2), int((screen.height() - height) / 2), width, height)
window.setWindowTitle("test")
window.show()
sys.exit(app.exec())
`
help me,How to improve the code so that it does not stop automatically

Keeping track of a button status inside a thread (PyQt5)

I created this simple GUI that displays a conuter on a text box. I am using workers and threads (this is just a simplified program I have other threads). I want to be able to check the status of the push button inside the label update thread. for example if the user clicked, then the counter will increment by 5 instead of 1 (for this iteration only), basically I want to keep an eye on this button's status all the time.
here is my code for the counter, how do I add the button check functionality to it?
Edit: I've updated the code using signals and slots to print 'hi' as a start, yet I do not get any output when I run it.
from PyQt5 import QtCore, QtGui, QtWidgets
from PyQt5.QtCore import QPoint, QRect, QSize, Qt
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
from PyQt5.QtCore import *
import sys
import os
import cv2
import numpy as np
import time
############################# Telemtry widgets update ##########################
class DISPLAY(QObject):
acc1_val = pyqtSignal(int)
finished = pyqtSignal()
def run(self):
global cntr
cntr = 0
self.inst = Ui_MainWindow()
self.inst.flag.connect(self.update)
print('connected')
while 1:
cntr = cntr +1
time.sleep(1)
self.acc1_val.emit(cntr)
if(cntr > 50):
cntr = 0
self.finished.emit()
#pyqtSlot()
def update(self,flag):
print('hi')
print(flag)
############################ GUI #######################################
class Ui_MainWindow(QObject):
flag = pyqtSignal(int)
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(500, 500)
MainWindow.setFocusPolicy(QtCore.Qt.NoFocus)
self.centralwidget = QtWidgets.QWidget(MainWindow)
self.centralwidget.setObjectName("centralwidget")
self.Title = QtWidgets.QLabel(self.centralwidget)
self.Title.setGeometry(QtCore.QRect(30, 10, 421, 71))
font = QtGui.QFont()
font.setPointSize(24)
font.setBold(True)
font.setWeight(75)
self.Title.setFont(font)
self.Title.setObjectName("Title")
self.ACC1_X = QtWidgets.QLineEdit(self.centralwidget)
self.ACC1_X.setGeometry(QtCore.QRect(300, 300, 41, 31))
self.ACC1_X.setObjectName("ACC1_X")
self.btn = QtWidgets.QPushButton(self.centralwidget)
self.btn.setGeometry(QtCore.QRect(100, 100, 101, 41))
font = QtGui.QFont()
font.setPointSize(13)
self.btn.setFont(font)
self.btn.setObjectName("Release_btn")
self.btn.clicked.connect(self.release_callback)
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QtWidgets.QMenuBar(MainWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 1920, 22))
self.menubar.setObjectName("menubar")
MainWindow.setMenuBar(self.menubar)
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
###################### Display thread ######################
self.thread1 = QThread()
self.worker1 = DISPLAY()
self.worker1.moveToThread(self.thread1)
self.thread1.started.connect(self.worker1.run)
self.worker1.acc1_val.connect(self.Label_update)
self.thread1.finished.connect(self.worker1.deleteLater)
self.thread1.start()
def release_callback(self,flag):
self.x = 1
print(flag)
self.flag.emit(True)
def Label_update(self,acc_val):
self.ACC1_X.setText(str(acc_val))
#print(str(acc_val))
def retranslateUi(self, MainWindow):
_translate = QtCore.QCoreApplication.translate
MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow"))
self.btn.setText(_translate("MainWindow", "click me"))
self.Title.setText(_translate("MainWindow", "TEST"))
if __name__ == "__main__":
import sys
app = QtWidgets.QApplication(sys.argv)
MainWindow = QtWidgets.QMainWindow()
ui = Ui_MainWindow()
ui.setupUi(MainWindow)
MainWindow.show()
sys.exit(app.exec_())

How get text from QTextEdit in Pyqt5? [duplicate]

This question already has an answer here:
Get text from qtextedit and assign it to a variable
(1 answer)
Closed 2 years ago.
I need get text from QTextEdit, but have such trouble: Traceback (most recent call last):
File "main.py", line 28, in otpravit_naz
textboxValue = self.textEdit.text()
AttributeError: 'MyWin' object has no attribute 'textEdit'
This is my code(main.py):
import sys
from PyQt5 import QtCore, QtGui, QtWidgets
from PyQt5.QtCore import *
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from test import *
import socket
sock = socket.socket()
class MyWin(QtWidgets.QMainWindow):
def __init__(self, parent=None):
QtWidgets.QWidget.__init__(self, parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.otpravit.clicked.connect(self.otpravit_naz)
def mbox(self, body, title='Error'):
dialog = QMessageBox(QMessageBox.Information, title, body)
dialog.exec_()
def otpravit_naz(self):
print("1")
textboxValue = self.textEdit.text()
print(textboxValue)
#sock.connect(('192.168.1.16', 9090))
sock.connect(("192.168.1.45", 9090))
sock.send(b'textboxValue')
sock.close()
if __name__ == "__main__":
app = QtWidgets.QApplication(sys.argv)
myapp = MyWin()
myapp.show()
sys.exit(app.exec_())
And ui form:
from PyQt5 import QtCore, QtGui, QtWidgets
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(517, 283)
self.centralwidget = QtWidgets.QWidget(MainWindow)
self.centralwidget.setObjectName("centralwidget")
self.verticalLayoutWidget = QtWidgets.QWidget(self.centralwidget)
self.verticalLayoutWidget.setGeometry(QtCore.QRect(60, 20, 421, 201))
self.verticalLayoutWidget.setObjectName("verticalLayoutWidget")
self.verticalLayout = QtWidgets.QVBoxLayout(self.verticalLayoutWidget)
self.verticalLayout.setSizeConstraint(QtWidgets.QLayout.SetFixedSize)
self.verticalLayout.setContentsMargins(0, 0, 0, 0)
self.verticalLayout.setSpacing(23)
self.verticalLayout.setObjectName("verticalLayout")
self.textEdit = QtWidgets.QTextEdit(self.verticalLayoutWidget)
self.textEdit.setObjectName("textEdit")
self.verticalLayout.addWidget(self.textEdit)
self.label = QtWidgets.QLabel(self.verticalLayoutWidget)
self.label.setLineWidth(0)
self.label.setMidLineWidth(0)
self.label.setAlignment(QtCore.Qt.AlignCenter)
self.label.setObjectName("label")
self.verticalLayout.addWidget(self.label)
self.list = QtWidgets.QComboBox(self.verticalLayoutWidget)
self.list.setObjectName("list")
self.list.addItem("")
self.list.addItem("")
self.list.addItem("")
self.verticalLayout.addWidget(self.list)
self.otpravit = QtWidgets.QPushButton(self.verticalLayoutWidget)
self.otpravit.setObjectName("otpravit")
self.verticalLayout.addWidget(self.otpravit)
self.verticalLayout.setStretch(0, 20)
self.verticalLayout.setStretch(1, 20)
self.verticalLayout.setStretch(2, 20)
self.verticalLayout.setStretch(3, 20)
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QtWidgets.QMenuBar(MainWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 517, 21))
self.menubar.setObjectName("menubar")
MainWindow.setMenuBar(self.menubar)
self.statusbar = QtWidgets.QStatusBar(MainWindow)
self.statusbar.setObjectName("statusbar")
MainWindow.setStatusBar(self.statusbar)
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def retranslateUi(self, MainWindow):
_translate = QtCore.QCoreApplication.translate
MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow"))
self.label.setText(_translate("MainWindow", "Предмет:"))
self.list.setItemText(0, _translate("MainWindow", "Русский"))
self.list.setItemText(1, _translate("MainWindow", "Литература"))
self.list.setItemText(2, _translate("MainWindow", "Английский"))
self.otpravit.setText(_translate("MainWindow", "Отправить"))
if __name__ == "__main__":
import sys
app = QtWidgets.QApplication(sys.argv)
MainWindow = QtWidgets.QMainWindow()
ui = Ui_MainWindow()
ui.setupUi(MainWindow)
MainWindow.show()
sys.exit(app.exec_())
If it very stupid troble, pls don't kick me
You're "installing" the GUI on the self.ui object, so every widget that is on the ui is actually accessible as self.ui.someWidget.
Also, QTextEdit doesn't have a text() property, but toPlainText():
def otpravit_naz(self):
print("1")
textboxValue = self.ui.textEdit.toPlainText()
print(textboxValue)
I suggest you to never edit the files generated with pyuic, but always use them as imported modules; read more on using Designer; also, be careful to set the main layout on the central widget, not on its children, and add everything to that layout, otherwise the children widgets could be hidden whenever the window is resized.

Global variable not working in dialog form

I show a dialog from main. In the dialog, I change the value of a global variable. But after the dialog closes, the global variable does not change the value.
I use PyQt5. Here is the code I call the dialog and change the variable value. I use varA to store dialog result.
def Clicked(self):
global varA
dialog = clssDialog()
dialog.exec_()
print(varA)
dialog ui
class clssDialog(QDialog):
def __init__(self):
super(clssDialog, self).__init__()
#some code
In dialog. I use:
def btnClosed(self):
global varA
varA=value
self.close()
Edit: Full code
main.py
from PyQt5 import QtCore, QtGui, QtWidgets
from dialog import *
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(219, 62)
self.centralwidget = QtWidgets.QWidget(MainWindow)
self.centralwidget.setObjectName("centralwidget")
self.verticalLayout = QtWidgets.QVBoxLayout(self.centralwidget)
self.verticalLayout.setObjectName("verticalLayout")
self.pushButton = QtWidgets.QPushButton(self.centralwidget)
self.pushButton.setObjectName("pushButton")
self.pushButton.clicked.connect(self.Clicked)
self.verticalLayout.addWidget(self.pushButton)
MainWindow.setCentralWidget(self.centralwidget)
self.statusbar = QtWidgets.QStatusBar(MainWindow)
self.statusbar.setObjectName("statusbar")
MainWindow.setStatusBar(self.statusbar)
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def retranslateUi(self, MainWindow):
_translate = QtCore.QCoreApplication.translate
MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow"))
self.pushButton.setText(_translate("MainWindow", "Open form"))
def Clicked(self):
global varA
varA=""
dialog = clssDialog()
dialog.exec_()
print("value: " + varA)
if __name__ == "__main__":
import sys
app = QtWidgets.QApplication(sys.argv)
MainWindow = QtWidgets.QMainWindow()
ui = Ui_MainWindow()
ui.setupUi(MainWindow)
MainWindow.show()
sys.exit(app.exec_())
dialog.py
from PyQt5 import QtCore, QtGui, QtWidgets
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
class clssDialog(QDialog):
def __init__(self):
super(clssDialog, self).__init__()
self.verticalLayout = QtWidgets.QVBoxLayout(self)
self.verticalLayout.setObjectName("verticalLayout")
self.pushButton = QtWidgets.QPushButton(self)
self.pushButton.setObjectName("pushButton")
self.pushButton.clicked.connect(self.btnClosed)
self.verticalLayout.addWidget(self.pushButton)
self.setWindowTitle("Dialog")
self.pushButton.setText("Close")
def btnClosed(self):
global varA
varA="123"
self.close()
It is not recommended to change the file created in QT Designer.
It is not necessary or advisable to use global variables. I also recommend reading Why are global variables evil?
Try it:
import sys
from PyQt5 import QtCore, QtGui, QtWidgets
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
#from dialog import *
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(219, 62)
self.centralwidget = QtWidgets.QWidget(MainWindow)
self.centralwidget.setObjectName("centralwidget")
self.verticalLayout = QtWidgets.QVBoxLayout(self.centralwidget)
self.verticalLayout.setObjectName("verticalLayout")
self.pushButton = QtWidgets.QPushButton(self.centralwidget)
self.pushButton.setObjectName("pushButton")
self.pushButton.clicked.connect(self.Clicked)
self.verticalLayout.addWidget(self.pushButton)
MainWindow.setCentralWidget(self.centralwidget)
self.statusbar = QtWidgets.QStatusBar(MainWindow)
self.statusbar.setObjectName("statusbar")
MainWindow.setStatusBar(self.statusbar)
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def retranslateUi(self, MainWindow):
_translate = QtCore.QCoreApplication.translate
MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow"))
self.pushButton.setText(_translate("MainWindow", "Open form"))
# def Clicked(self):
# global varA
# varA=""
# dialog = ClssDialog()
# dialog.exec_()
# print("value: " + varA)
class ClssDialog(QDialog):
# def __init__(self):
# super(ClssDialog, self).__init__()
def __init__(self, parent=None):
super(ClssDialog, self).__init__(parent)
self.parent = parent
self.verticalLayout = QtWidgets.QVBoxLayout(self)
self.verticalLayout.setObjectName("verticalLayout")
self.pushButton = QtWidgets.QPushButton(self)
self.pushButton.setObjectName("pushButton")
self.pushButton.clicked.connect(self.btnClosed)
self.verticalLayout.addWidget(self.pushButton)
self.setWindowTitle("Dialog")
self.pushButton.setText("Close")
def btnClosed(self):
# global varA
self.parent.varA = "123"
self.close()
class ExampleApp(QtWidgets.QMainWindow, Ui_MainWindow):
def __init__(self):
super().__init__()
self.setupUi(self)
self.varA = ""
def Clicked(self):
# global varA
# varA=""
dialog = ClssDialog(self)
dialog.exec_()
print("value: " + self.varA)
if __name__ == "__main__":
app = QApplication(sys.argv)
view = ExampleApp()
view.show()
sys.exit(app.exec_())

Display Sensor Output on QLCDNumber using PyQT5

So I have developed a code which will detect a voltage off a transducer and then output an average voltage, my question here is how can I get this value to update as my sensor value changes, currently it is prinitng the initial value and then not updating, I created a mainwindow using QTDesigner, and I am using Python3 and PyQt5 library to write the code.
is this even possible? if so how?
This is my code:
import sys
from PyQt5 import QtCore, QtGui, QtWidgets
from PyQt5.QtGui import QPixmap
import RPi.GPIO as GPIO
import Test_rc
import time
import board
import busio
from adafruit_ads1x15.single_ended import ADS1115
i2c = busio.I2C(board.SCL,board.SDA)
adc = ADS1115(i2c)
GAIN = 2/3
c1 = 525.4
c2=28152
GPIO.setmode(GPIO.BCM)
Relay_1 = 27
Transducer = 17
GPIO.setup(Transducer,GPIO.IN)
GPIO.setup(Relay_1, GPIO.OUT)
GPIO.output(Relay_1, GPIO.HIGH)
GPIO.output(Relay_1, GPIO.LOW)
def Pressure_Reading():
while True:
time.sleep(0.02)
r0 = adc.read_volts(0,gain = GAIN, data_rate=None)
r1 = adc.read_adc(0, gain = GAIN, data_rate =None)
Pressure_Volts = r0*94.72436287
Pressure_adc = r1*(c1/c2)
time.sleep(0.02)
r01= adc.read_volts(0,gain = GAIN, data_rate=None)
r11= adc.read_adc(0, gain = GAIN, data_rate =None)
Pressure_Volts2 = r01*94.72436287
Pressure_adc2 = r11*(c1/c2)
time.sleep(0.02)
r02= adc.read_volts(0,gain = GAIN, data_rate=None)
r12= adc.read_adc(0, gain = GAIN, data_rate =None)
Pressure_Volts3 = r02*94.72436287
Pressure_adc3 = r12*(c1/c2)
time.sleep(0.02)
r03 = adc.read_volts(0,gain = GAIN, data_rate=None)
r13 = adc.read_adc(0, gain = GAIN, data_rate =None)
Pressure_Volts4 = r03*94.72436287
Pressure_adc4 = r13*(c1/c2)
time.sleep(0.02)
r04= adc.read_volts(0,gain = GAIN, data_rate=None)
r14= adc.read_adc(0, gain = GAIN, data_rate =None)
Pressure_Volts5 = r04*94.72436287
Pressure_adc5 = r14*(c1/c2)
Pressure_Volts_Avg = (Pressure_Volts+Pressure_Volts2+Pressure_Volts3+Pressure_Volts4+Pressure_Volts5)/5
Pressure_adc_Avg = (Pressure_adc+Pressure_adc2+Pressure_adc3+Pressure_adc4+Pressure_adc5)/5
Pressure_Avg = (Pressure_Volts_Avg+Pressure_adc_Avg)/2
return Pressure_Avg
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(788, 424)
self.centralwidget = QtWidgets.QWidget(MainWindow)
self.centralwidget.setObjectName("centralwidget")
self.stackedWidget = QtWidgets.QStackedWidget(self.centralwidget)
self.stackedWidget.setGeometry(QtCore.QRect(10, 0, 761, 501))
self.stackedWidget.setObjectName("stackedWidget")
self.page_3 = QtWidgets.QWidget()
self.page_3.setObjectName("page_3")
self.label = QtWidgets.QLabel(self.page_3)
self.label.setGeometry(QtCore.QRect(200, 0, 341, 61))
font = QtGui.QFont()
font.setFamily("Arial Black")
font.setPointSize(22)
font.setBold(True)
font.setWeight(75)
self.label.setFont(font)
self.label.setAlignment(QtCore.Qt.AlignCenter)
self.label.setObjectName("label")
self.pushButton_2 = QtWidgets.QPushButton(self.page_3)
self.pushButton_2.setGeometry(QtCore.QRect(220, 170, 141, 41))
self.pushButton_2.setObjectName("pushButton_2")
self.pushButton = QtWidgets.QPushButton(self.page_3)
self.pushButton.setGeometry(QtCore.QRect(380, 170, 141, 41))
self.pushButton.setObjectName("pushButton")
self.label_2 = QtWidgets.QLabel(self.page_3)
self.label_2.setGeometry(QtCore.QRect(120, 260, 541, 141))
self.label_2.setObjectName("label_2")
self.groupBox_2 = QtWidgets.QGroupBox(self.page_3)
self.groupBox_2.setGeometry(QtCore.QRect(90, 40, 101, 221))
self.groupBox_2.setTitle("")
self.groupBox_2.setObjectName("groupBox_2")
self.verticalLayout_2 = QtWidgets.QVBoxLayout(self.groupBox_2)
self.verticalLayout_2.setObjectName("verticalLayout_2")
self.label_7 = QtWidgets.QLabel(self.groupBox_2)
self.label_7.setObjectName("label_7")
self.verticalLayout_2.addWidget(self.label_7)
self.lcdNumber = QtWidgets.QLCDNumber(self.groupBox_2)
self.lcdNumber.setObjectName("lcdNumber")
self.verticalLayout_2.addWidget(self.lcdNumber)
self.lcdNumber.display(Pressure_Reading())
I've input all the code up until the lcdnumber calling.
The rest of the code after the mainwindow class, I have my code control a relay and push buttons navigate a few pages, this part of the code runs fine
class ControlMainWindow(QtWidgets.QMainWindow):
def __init__(self,parent=None):
super(ControlMainWindow,self).__init__(parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.SettingsButton.clicked.connect(lambda:self.ui.stackedWidget.setCurrentIndex(1))
self.ui.pushButton_5.clicked.connect(lambda:self.ui.stackedWidget.setCurrentIndex(0))
self.ui.pushButton.clicked.connect(self.OnSwitch)
self.ui.pushButton_2.clicked.connect(self.OffSwitch)
self.ui.DelayButton.clicked.connect(self.Delay_Switch)
def OnSwitch(self):
GPIO.output(Relay_1, GPIO.HIGH)
def OffSwitch(self):
GPIO.output(Relay_1, GPIO.LOW)
def Delay_Switch(self):
time.sleep(5)
GPIO.output(Relay_1,GPIO.HIGH)
if __name__ == "__main__":
app = QtWidgets.QApplication(sys.argv)
mySW = ControlMainWindow()
mySW.show()
sys.exit(app.exec_())
Sorry. I'm not familiar with some of the modules that you use.
In general, it might look like this:
main.py
import sys
from random import randint
from PyQt5.QtWidgets import QApplication, QMainWindow
from PyQt5.QtCore import QTimer
from ui import Ui_MainWindow
class Form(QMainWindow):
def __init__(self):
super().__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.i = 0
self.voltageMin = 180
self.voltageMax = 180
self.ui.lcdNumberCur.display(self.i)
self.ui.pushButton.clicked.connect(self.startTimer)
self.timer = QTimer(self)
self.timer.setInterval(1000)
self.timer.timeout.connect(self.updateData)
self.show()
def startTimer(self):
if self.ui.pushButton.text() == "Start Timer":
self.timer.start(1000)
self.ui.pushButton.setText("Stop Timer")
else:
self.ui.pushButton.setText("Start Timer")
self.timer.stop()
def updateData(self):
voltage = randint(90, 260) # <--- insert your average voltage here
self.ui.lcdNumberCur.display(voltage)
if voltage > self.voltageMax:
self.voltageMax = voltage
self.ui.lcdNumberMax.display(self.voltageMax)
elif voltage < self.voltageMin:
self.voltageMin = voltage
self.ui.lcdNumberMin.display(self.voltageMin)
if __name__ == '__main__':
app = QApplication(sys.argv)
frm = Form()
sys.exit(app.exec_())
ui.py
from PyQt5 import QtCore, QtGui, QtWidgets
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(500, 300)
self.centralwidget = QtWidgets.QWidget(MainWindow)
self.centralwidget.setObjectName("centralwidget")
self.groupBox = QtWidgets.QGroupBox(self.centralwidget)
self.groupBox.setGeometry(QtCore.QRect(0, 0, 400, 200))
self.groupBox.setObjectName("groupBox")
self.lcdNumberMax = QtWidgets.QLCDNumber(self.groupBox)
self.lcdNumberMax.setGeometry(QtCore.QRect(225, 10, 151, 41))
self.lcdNumberMax.setObjectName("lcdNumberMax")
self.lcdNumberCur = QtWidgets.QLCDNumber(self.groupBox)
self.lcdNumberCur.setGeometry(QtCore.QRect(225, 55, 151, 41))
self.lcdNumberCur.setObjectName("lcdNumberCur")
self.lcdNumberMin = QtWidgets.QLCDNumber(self.groupBox)
self.lcdNumberMin.setGeometry(QtCore.QRect(225, 100, 151, 41))
self.lcdNumberMin.setObjectName("lcdNumberMin")
self.label = QtWidgets.QLabel(self.groupBox)
self.label.setGeometry(QtCore.QRect(20, 50, 150, 50))
self.label.setObjectName("label")
self.labelMax = QtWidgets.QLabel(self.groupBox)
self.labelMax.setGeometry(QtCore.QRect(20, 8, 150, 50))
self.labelMax.setObjectName("labelMax")
self.labelMin = QtWidgets.QLabel(self.groupBox)
self.labelMin.setGeometry(QtCore.QRect(20, 95, 150, 50))
self.labelMin.setObjectName("labelMin")
self.pushButton = QtWidgets.QPushButton("pushButton", self.groupBox) #(self.scrollAreaWidgetContents)
self.pushButton.setGeometry(QtCore.QRect(180, 165, 75, 23))
self.pushButton.setObjectName("pushButton")
MainWindow.setCentralWidget(self.centralwidget)
self.statusbar = QtWidgets.QStatusBar(MainWindow)
self.statusbar.setObjectName("statusbar")
MainWindow.setStatusBar(self.statusbar)
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def retranslateUi(self, MainWindow):
_translate = QtCore.QCoreApplication.translate
MainWindow.setWindowTitle(_translate("MainWindow", "LCDNumber - Timer(Start-Stop)"))
self.groupBox.setTitle(_translate("MainWindow", "Data"))
self.label.setText(_translate("MainWindow", "Current voltage in the network"))
self.labelMin.setText(_translate("MainWindow", "Min voltage in the network"))
self.labelMax.setText(_translate("MainWindow", "Max voltage in the network"))
self.pushButton.setText(_translate("MainWindow", "Start Timer"))
if __name__ == "__main__":
import sys
app = QtWidgets.QApplication(sys.argv)
MainWindow = QtWidgets.QMainWindow()
ui = Ui_MainWindow()
ui.setupUi(MainWindow)
MainWindow.show()
sys.exit(app.exec_())
Ok, so getting caught up in all the gui stuff, I had to implement threading and remove the functions from within the gui thread. Because the question regarded the output of the sensor I removed all the code irrelevant to it and included just the code required for the Sensor.. I hope this makes sense.
This resolved the issue:
class Worker(QtCore.QThread):
valueFound = QtCore.pyqtSignal(int, name="valueFound")
GAIN = 2/3
c1 = 525.4
c2=28152
Relay_1 = 27
def __init__(self, parent=None):
super(Worker, self).__init__(parent)
self.runFlag = False
self.i2c = busio.I2C(board.SCL,board.SDA)
self.adc = ADS1115(self.i2c)
GPIO.setmode(GPIO.BCM)
GPIO.setup(self.Relay_1, GPIO.OUT)
GPIO.output(self.Relay_1, GPIO.HIGH)
GPIO.output(self.Relay_1, GPIO.LOW)
def startThread(self):
self.runFlag = True
self.start()
def stopThread(self):
self.runFlag = False
def run(self):
while self.runFlag:
self.valueFound.emit(self.Pressure_Reading())
......
def run(self):
while self.runFlag:
self.valueFound.emit(self.Pressure_Reading())
.....
self.worker = Worker(self)
self.worker.valueFound.connect(self.OnValueFound)
.....
self.worker.startThread()
def closeEvent(self, event):
self.worker.stopThread()
while self.worker.isRunning():
pass
event.accept()
def OnValueFound(self, value):
self.ui.lcdNumber.display(value)
The addition of these allowed the program to continuously update the LCD Number.

Resources