RuntimeError：主线程不在主循环中-绘制两个图

Question

I'm trying to get a value from a DHT11 temp sensor, then plot it through a GUI main window widget that has three buttons, the first one is to start getting the value from the sensor, the second one is to plot the value in realtime, and the third one to plot the FFT of the value.

The problem is that I can't saperate the the realtime plot and the FFT plot in two figures, because every time I change the plt.figure(1) under def plotFFTButton_clicked(self): to plt.figure(2) I get the folowing error when I press the FFT plotting button: RuntimeError: main thread is not in main loop

The other problem is that I can't delete the plt.figure(1) under def runValue(self): because it will give me the same error.

I would be thankful if somebody can help me finding the issue with my code.

from PyQt4 import QtCore, QtGui
import sys
import time
from threading import Event, Thread

from mainwindow import Ui_MainWindow

from PyQt4.Qt import QString, QFileDialog
from pylab import *

import threading
from threading import Thread

#DH11 tempSensor Library
import Adafruit_DHT

#Library to find FFT and FFTshift 
from scipy.fftpack import fft, fftshift

from numpy import linspace

class dataAcquisition(QtGui.QMainWindow, Ui_MainWindow):
    def __init__(self, parent=None):        
        super(dataAcquisition, self).__init__(parent)
        self.setupUi(self)

        self.startButton.clicked.connect(self.startButton_clicked)
        self.th = Thread(target = self.runValue)

        self.plotRTButton.clicked.connect(self.plotRTButton_clicked)

        self.plotFFTButton.clicked.connect(self.plotFFTButton_clicked)

        self.Value = 0.0
        self.X = 0.0
        self.Y = 0.0

        self.ChageValueState = False
    def runValue(self):
        self.X = []
        self.Y = []
        i = 0.0

        plt.figure(1) #an error comes out if I delete this

        while True:
            self.ChageValueState = True

            self.Value = Adafruit_DHT.read_retry(11, 4)[1]  ‫#‬Or you could give the self.Value any number

            i += 0.10
            self.X.append(i)
            self.Y.append(self.Value)
            pause(0.01)

    def startButton_clicked(self):
        self.th.start()

    def plotRTButton_clicked(self):
        plt.figure(1)
        ax1 = subplot(3, 1, 1)
        Line1 = plot(0,0,'r-')[0]

        Line1.set_xdata(self.X)
        Line1.set_ydata(self.Y)
        ax1.relim()
        ax1.autoscale_view()

    def plotFFTButton_clicked(self):
        Fs = 8000
        N = 256
        f = linspace(-Fs/2, Fs/2, N)

        plt.figure(1) #an error comes out if I plot in a new figure

        ax2 = plt.subplot(3, 1, 2)
        Line2 = plot(f,0*f,'r-')[0]

        FFT = log10(abs(fft(self.Y, N)))
        FFT = fftshift(FFT)

        Line2.set_ydata(FFT)
        ax2.relim()
        ax2.autoscale_view()

if __name__ == '__main__':
    app = QtGui.QApplication(sys.argv)
    MainWindow = dataAcquisition()
    MainWindow.show()
    sys.exit(app.exec_())

Answer 1

the error is a safety precaution that prevents interference in threads. each figure is a or has variables within matplotlib such that if multiple threads are working on separate figures at the same time one thread can corrupt the other's variable. the python threads class detects that multiple objects in parallel are trying to access same class and reacts. It usually finishes first thread and stops the others.

in your code you never close figure 1 and thus cannot create a figure 2 in a separate thread without risking interference. so you could do one thread for acquiring data and another to do the FFT of that data and the third one can plot. the plotting thread will have to work in such a way that it sleeps until it is triggered when data is collected so it would add raw data to figure(1) and then when triggered again by the end of the FFT, the data will be added to figure(2).(loop that checks raw data for new, then checks FFT for new. only if true do something) (recommend using a queue) since they are no longer two separate threads you no longer have to close one before running the other.

if you truly wanted to plot in parallel copy matplotlib to a file with new name and plot one figure with it and the other with matplotlib.

Answer 2

I am afraid this is not completely trivial code, since you say you're a beginner. But then again it's not a completely trivial problem. This it what does the job for me. Call 'add' from eg a GUI thread to put events (functions to be executed) in the queue, and then call 'execute' from your graphics thread to execute them on that thread. If you have multiple graphics threads, you'll have multiple queues.

Note that apart from TaskQueue, there's also a cyclic scheduler TaskRing. You don't need that now, but this is just a piece of production code, so I've made it generally applicable to multithread scheduling problems.

class TaskBuffer:
    def __init__ (self):
        self.tasks = []

    def add (self, task):
        self.tasks.append (task)

    def execute (self, time):
        for task in self.tasks:
            try:
                task (time)
            except:
                lg.debug ('{} {}'.format (self.skipMessage, task))

class TaskRing (TaskBuffer):
    skipMessage = 'Ring task skipped:'

taskRing = TaskRing ()

class TaskQueue (TaskBuffer):
    skipMessage = 'Queue task skipped:'

    def execute (self, time):
        super () .execute (time)
        self.tasks = []

taskQueue = TaskQueue ()