QT Signals and slot to transfer data from thread

[Albitroz]

Im trying to pass an event through signals and slots

All UI portion is handled by file "Analog_ui.py"
All data capture portion is handled by file "AI_DAQ.py"

Main code

"___________________________Create GUI____________________________________________"
from ast import Break
from asyncio import queues
from concurrent.futures import process
from itertools import starmap
import sys
from token import ISNONTERMINAL


#import QApplications and the required widgets from PyQt.QtWidgets
from PyQt5 import QtWidgets,QtCore, QtGui
from PyQt5.QtCore import Qt
from PyQt5.QtWidgets import QGridLayout, QLineEdit
from PyQt5.QtWidgets import QVBoxLayout
from PyQt5.QtWidgets import QApplication
from PyQt5.QtWidgets import QLabel, QHBoxLayout, QPushButton
from PyQt5.QtWidgets import QWidget
from PyQt5.QtWidgets import QMainWindow

import AI_DAQ 
from AI_DAQ import*
from multiprocessing import Process,Queue,Pipe


class Configure_MainWindow(object): 
    
    def Ui_Configure(self, MainWindow):
        MainWindow.resize(1100,600)
        self.centralwidget=QtWidgets.QWidget(MainWindow)
        
        #adding start and stop pushbutton
        self.pushButton1=QtWidgets.QPushButton(self.centralwidget)
        self.pushButton1.setGeometry(QtCore.QRect(1000,500,93,28))
        
        
        self.pushButton2=QtWidgets.QPushButton(self.centralwidget)
        self.pushButton2.setGeometry(QtCore.QRect(1000,550,93,28))
        
        self.Physicalchannel=QtWidgets.QLineEdit(self.centralwidget)
        self.Physicalchannel.setGeometry(QtCore.QRect(40,50,140,21))
        self.Physicalchannel.setText("Dev1")
        #self.Physicalchannel.insert()
   
        
        self.PhysicalchannelLabel=QtWidgets.QLabel(self.centralwidget)
        self.PhysicalchannelLabel.setGeometry(QtCore.QRect(40,25,111,21))
        
        self.MaxVolt=QtWidgets.QSpinBox(self.centralwidget)
        self.MaxVolt.setGeometry(QtCore.QRect(190,120,100,21))
        self.MaxVolt.setRange(0,5)
        self.MaxVolt.setValue(5)
        self.MaxVoltLabel=QtWidgets.QLabel(self.centralwidget)
        self.MaxVoltLabel.setGeometry(QtCore.QRect(190,90,60,28))
        
        self.MinVolt=QtWidgets.QSpinBox(self.centralwidget)
        self.MinVolt.setGeometry(QtCore.QRect(40,120,100,21))
        self.MinVolt.setRange(-5,0)
        self.MinVolt.setValue(-5)
        self.MinVoltLabel=QtWidgets.QLabel(self.centralwidget)
        self.MinVoltLabel.setGeometry(QtCore.QRect(40,90,60,28))
        
        self.SampleRate=QtWidgets.QSpinBox(self.centralwidget)
        self.SampleRate.setGeometry(QtCore.QRect(220,50,70,21))
        self.SampleRate.setRange(0,400)
        self.SampleRate.setValue(200)
        
        self.SampleRateLabel=QtWidgets.QLabel(self.centralwidget)
        self.SampleRateLabel.setGeometry(QtCore.QRect(220,25,60,28))
        
        """self.graphicsView= QtWidgets.QGraphicsView(self.centralwidget)
        self.graphicsView.setGeometry(QtCore.QRect(265,10,321,281))
        self.graphicsViewLabel=QtWidgets.QLabel(self.centralwidget)
        self.graphicsViewLabel.setGeometry(QtCore.QRect(100,10,60,10))"""
        
        
        MainWindow.setCentralWidget(self.centralwidget)
        
        self.retranslateUi(MainWindow)
        QtCore.QMetaObject.connectSlotsByName(MainWindow)
        
    def start(self):
        print("start button clicked")
        AI_DAQ.cfg_read_task("Dev1/ai0")
        
        
        """AI_DAQ.acquiredata.__get__(q)   
        item=q.get()
        print(item) """
    

        
        
        
    
                    
    def stop(self):
        print("Stopping Tread")
        AI_DAQ.stop_task()
        
        
   
                
    def retranslateUi(self, MainWindow):
        _translate = QtCore.QCoreApplication.translate
        MainWindow.setWindowTitle(_translate("MainWindow", "Analog Data Acquisition"))
        self.pushButton1.setText(_translate("MainWindow", "Start"))
        self.pushButton2.setText(_translate("MainWindow","Stop"))
        self.PhysicalchannelLabel.setText(_translate("MainWindow","Physical Channel"))
        self.MaxVoltLabel.setText(_translate("MainWindow","Max Voltage"))
        self.MinVoltLabel.setText(_translate("MainWindow", "Min Voltage"))
        self.SampleRateLabel.setText(_translate("MainWindow","Rate"))
        #self.graphicsViewLabel.setText(_translate("MainWindow","AnalogWave form"))
        
        self.pushButton1.clicked.connect(self.start)
        self.pushButton2.clicked.connect(self.stop)
        
               
    
                
"""_______________Main function_________________ """  


if __name__=='__main__':
    
    #Create an instance of QApplication
    app=QtWidgets.QApplication(sys.argv)
    MainWindow=QtWidgets.QMainWindow()
    # Show GUI
    ui=Configure_MainWindow()
    ui.Ui_Configure(MainWindow) 
    MainWindow.show() #Windows are hidden by default
    #Execute the eventloop
    sys.exit(app.exec_())
    #app.exec_()
  
  
def displaydata(self,q1):
    print(q1.get())
          
    
    
    

Data Producer

from signal import Handlers, Signals, signal
import threading
from turtle import delay, goto
from unittest import signals
import PyQt5
import matplotlib.pyplot as plt
import nidaqmx
from nidaqmx import constants
import nidaqmx.system
import time
#from queue import Queue
import queue
from multiprocessing import Process,Queue,Pipe
import numpy as np
import Analog_ui
from Analog_ui import*

#variables declaration
buffer_in_size=1000
buffer_in_size_cfg = round(buffer_in_size * 1)
task_in=nidaqmx.Task()
running=True
# Initializing a queue
q=queue.Queue()
#q=queue()

#q =Queue(maxsize = 1000) 
    
def ai_read():
    print("Inside Thread")
    task_in.start()
    global running
    global data
    while running:
            msg=task_in.read(number_of_samples_per_channel=100)
            data=np.append(msg,buffer_in_size)
            acquiredata()
            if running:
                break
            
      
    running = False  
           
    task_in.stop()
    task_in.close()   
    return 0
    
def stop_task():
    global running
    running = True   
    print("stopped")
    

def cfg_read_task(chname):
    print(chname)
    system=nidaqmx.system.System.local()
    device=system.devices['Dev1']
    phys_chan=device.ai_physical_chans['ai0']
    task_in.ai_channels.add_ai_voltage_chan(chname,min_val=-5,max_val=5)
    task_in.timing.cfg_samp_clk_timing (rate=100,sample_mode=constants.AcquisitionType.CONTINUOUS,samps_per_chan=buffer_in_size_cfg)
    print("Task configured")
    #configure thread starting
    thread_ai=threading.Thread(target=ai_read)
    thread_ai.start()
    #thread_ai.join()
    
    
def  acquiredata():
    q1=q.put(data)
    mysignal=signal(str,Handlers)
    #q1.connect(Analog_ui.Configure_MainWindow.displaydata)
    mysignal.Connect(Analog_ui.displaydata)
   

Here im trying to pass an event in the form of signal and slot to display module

but here i get an error Argument missing handler

Is this the correct method to use signal and slot?

[JonB]

@Albitroz said in QT Signals and slot to transfer data from thread:

but here i get an error Argument missing handler

Where??

• Commented out #q1.connect(Analog_ui.Configure_MainWindow.displaydata) ??
• mysignal.Connect(Analog_ui.displaydata) ?? What is Connect() method??
• What is signal() in mysignal=signal(str,Handlers)?
• What is from signal import Handlers, Signals, signal all about?

When you paste hundreds of lines of code please give people a clue what you are asking about.