[Monitoring System] 4.1 세상에 더 빠른 방법이 - pyqtgraph

 

[Monitoring System] 3. UDP 통신으로 실시간 진동 데이터 Plotting(feat. matplotlib)

[Monitoring System] 4. UDP 통신으로 실시간 진동 데이터 FFT / STFT시각화(numpy, tensorflow, pytorch)

3~4에 구현한 matplotlib 기반 실시간 그래프 시각화는 약 1초에 한 번 정도 업데이트 되었고, 이는 객관적으로 봤을 때 빠르지 않았다. 1초에 25000개의 데이터를 받아오는 것을 감안했을 때 10만 개의 데이터를 한 번에 보여주므로 약 4번 업데이트하면 다른 그래프가 되었고, 뚝뚝 끊기는 것도 체감이 되었다. 

이 문제를 해결할 방안을 찾던 중, 더 빠른 plotting 방식 몇 가지를 추천받았는데 그 중 하나가 바로 pyqtgraph이다.

PyQtGraph — pyqtgraph 0.13.4.dev0 documentation

가지고 있는 다른 daq 장치 중 SpectraDAQ-200이 있는데, 같은 회사에서 지원하는 Spectra PLUS 모니터링 시스템과 거의 비슷한 수준의 시각화 능력을 보여주었다! 3번 글에서 구현한 부분을 pyqtgraph 기반으로 다시 만들었다. 한 번 보도록 하겠다.

import sys
from threading import Lock, Thread
import csv, socket, array

import pyqtgraph as pg

from PyQt5.QtWidgets import *
from PyQt5.QtCore import pyqtSlot, QTimer
from PyQt5.QtGui import QPalette, QColor, QFont

import torch
import numpy as np

from stft import show_result

pyqtgraph는 PyQt5~6을 기반으로 동작하므로 PyQt5 설치가 필수적이다. windows의 경우 pip로 설치하면 되고, Ubuntu 등에서는 좀 더 복합적인 방법이 필요한데 그 부분은 링크 참조.

ubutu 18.04 : pyqt5 설치

 

1. UI 구성

class Main(QWidget):
    def __init__(self):
        super().__init__()

        self.paused = False
        self.label = QLabel("Real-Time Graph")
        self.label.setFont(QFont("Arial", 20))

        # define plot
        self.orig = pg.PlotWidget(title="Original")
        self.orig.plotItem.setLabels(bottom='Samples', left="IEPE (mV)")
        self.orig.plotItem.getAxis('bottom').setPen(pg.mkPen(color='#000000'))
        self.orig.plotItem.getAxis('left').setPen(pg.mkPen(color='#000000'))
        self.orig.setBackground('w')
        self.orig.setStyleSheet("border: 1px solid black; padding-left:10px; padding-right:10px; background-color: white;")
        
        self.fft = pg.PlotWidget(title="FFT")
        self.fft.plotItem.setLabels(bottom="Frequency (Hz)", left="Amplitude")
        self.fft.plotItem.getAxis('bottom').setPen(pg.mkPen(color='#000000'))
        self.fft.plotItem.getAxis('left').setPen(pg.mkPen(color='#000000'))
        self.fft.setBackground('w')
        self.fft.setStyleSheet("border: 1px solid black; padding-left:10px; padding-right:10px; background-color: white;")

        # plot control button
        self.pause_button = QPushButton()
        self.pause_button.setText("Pause/Restart")
        self.pause_button.clicked.connect(self.toggle_event)
        self.pause_button.setMinimumSize(300, 50)
        self.pause_button.setStyleSheet("background-color: white; padding-left:10px; padding-right:10px; font-size: 15px; font-family: Arial;")

        # start record button
        self.record_button = QPushButton()
        self.record_button.setText("Start Recording")
        self.record_button.clicked.connect(self.start_recording)
        self.record_button.setMinimumSize(300, 50)
        self.record_button.setStyleSheet("background-color: white; font-size: 15px;font-family: Arial;")
        
        # data save button
        self.save_button = QPushButton()
        self.save_button.setText("Save Data")
        self.save_button.clicked.connect(self.save_data)
        self.save_button.setMinimumSize(300, 50)
        self.save_button.setStyleSheet("background-color: white; font-size: 15px;font-family: Arial;")

        # show entire data analysis button
        self.show_button = QPushButton()
        self.show_button.setText("Show Analysis")
        self.show_button.clicked.connect(show_result)
        self.show_button.setMinimumSize(300, 50)
        self.show_button.setStyleSheet("background-color: white; font-size: 15px;font-family: Arial;")

        buttons = QHBoxLayout()
        buttons.addWidget(self.pause_button)
        buttons.addWidget(self.record_button)
        buttons.addWidget(self.save_button)
        buttons.addWidget(self.show_button)

        box = QVBoxLayout()
        box.addWidget(self.label)
        box.addWidget(self.orig)
        box.addWidget(self.fft)
        box.addLayout(buttons)
        box.setSpacing(30)
        box.setContentsMargins(50,50,50,50)
        self.setLayout(box)

        # set Window
        self.setGeometry(800, 300, 1500, 1000)
        self.setWindowTitle("Real Time Data Graphs")

대부분 style sheet 적용과 관련된 내용이므로 자세히 봐야할 것은 이것 뿐이다.

self.orig = pg.PlotWidget(title="Original")
self.fft = pg.PlotWidget(title="FFT")

self.pause_button = QPushButton()
self.pause_button.setText("Pause/Restart")
self.pause_button.clicked.connect(self.toggle_event)

pg.PlotWidget 은 matplotlib 의 일종의 subplot 같은 역할을 한다. 버튼은 거의 유사하므로 넘어간다.

그리고 HBox Layout에 버튼들을 가로로 쭉 넣어주고, VBox Layout에 그래프와 버튼들을 싹 넣어주면 이런 그래프가 생긴다.

제법 그럴듯하다(뿌듯)

original signal graph와 fft graph 모두 선그래프 이므로 아래와 같이 선언해줄 수 있다.

# set line graph
self.orig_p = self.orig.plot(pen='b')
self.fft_p = self.fft.plot(pen='r')

pyqtgraph에서 matplotlib의 animation과 유사한 결과를 내도록 해주는 것이 바로 Timer이다. 설정한 시간마다 함수를 호출해서 데이터를 갱신하도록 하고, 이 갱신한 데이터를 그 함수에서 그래프를 그리도록 다른 함수를 호출해서 그래프를 갱신한다.

# set timer - animation controller
self.mytimer = QTimer()
self.mytimer.start(25)  
self.mytimer.timeout.connect(self.get_data)

self.draw_chart()
self.show()

 

2. 데이터 갱신 / 그래프 그리기

def draw_chart(self):
    """
    Update plot data and calculate FFT.
    """
    # update original signal graph
    self.orig_p.setData(self.graph_data)  

    # update fft graph
    Fs = 25600.0
    n = len(self.graph_data)

    # pytorch fft
    graph_data = torch.Tensor(self.graph_data)
    graph_data.to("cuda:0")
    fft_data = torch.fft.rfft(graph_data) / n
    frequency = torch.arange(0.0, Fs/2.0, Fs/n)

    self.fft_p.setData(frequency[:len(fft_data)//2], np.abs(fft_data[:len(fft_data)//2]))


@pyqtSlot()
def get_data(self):
    """
    Separate plotting data from entire data.
    """
    data_lock.acquire()
    if len(entire_data) > 110000:
        self.graph_data = entire_data[len(entire_data) - 100000:]
    else:
        self.graph_data = entire_data
    data_lock.release()
    self.draw_chart()

이 부분은 matplotlib으로 구현했을 때와 거의 같다. 그때는 set이었다면 이번에는 setData를 썼다는 정도의 차이만 있다.

@pyqtSlot()은 signal을 수신하였을 때 실행되는 signal controller라는 뜻이다. 위에서 timer를 선언할 때 timeout이 되었다는 시그널이 발생하면 get_data 함수가 불리는 식이다.

3. 버튼 함수 선언

def toggle_event(self):
    """
    Control animation. Pause/Restart.
    """
    if self.paused:
        self.mytimer.start()
    else:
        self.mytimer.stop()
    self.paused = not self.paused

def start_recording(self) -> None:
    """
    Set start point of saving data.
    """
    data_lock.acquire()
    self.pos = len(entire_data) - 1
    data_lock.release()
    print("Recording started.")

def save_data(self) -> None:
    """
    Save entire voltage data in csv.
    During save data, graph plotting will be paused.
    Using lock.
    """
    self.mytimer.stop()
    print("Saving...")

    data_lock.acquire()
    f = open("data.csv", "w")
    target = csv.writer(f)
    target.writerow(entire_data[self.pos:])
    data_lock.release()

    print("Saved {0} Data. Restart plotting.".format(len(entire_data)))
    self.mytimer.start()

animation.stop이 timer의 stop과 start로 변한 것을 제외하면 달라진 점이 없다. 요것도 넘어간다. 당연히 UDP 통신을 하는 Thread 코드도 달라진 것이 없다.

def run() -> None:
    """
    UDP data receive function.
    Using lock.
    """
    print("Connected", flush=True)
    while True:
        data = serverSocket.recv(32768)
        signals = array.array('d')
        signals.frombytes(data)
        data_lock.acquire()
        entire_data.extend(signals)
        data_lock.release()

 

4. Main 함수 작성

if __name__ == "__main__":
    app = QApplication(sys.argv)
    pal = app.palette()
    pal.setColor(QPalette.Window, QColor(245,245,245))
    app.setPalette(pal)

    ex = Main()

    # define socket setting and bind
    server = ('YOUR_IP_ADDRESS', 2001)
    serverSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    serverSocket.bind(server)

    # set data / data lock
    entire_data = [0, 0]
    data_lock = Lock()

    # start UDP in another thread
    t = Thread(target=run, args=())
    t.start()

    sys.exit(app.exec_())

PyQt 창을 실행시키기 위한 코드만 조금 추가되었다. 이렇게 바꿔주면 끝! 사실 matplotlib에서 pyqt로 라이브러리만 갈아탄 건데도 성능차이가 엄청나게 났다. 지연시간이 체감 20배는 줄어든 느낌... 진짜 실시간이라는 느낌이 강해졌다.

STFT를 계산해서 저장한 데이터를 시각화하는 부분은 matplotlib으로 남겨뒀다. 그쪽이 더 보기는 좋기도 하고, 성능도 중요하지 않기 때문이다. 

여담으로 pyqtgraph를 사용하니 STFT도 실시간으로 시각화가 가능해졌는데, 데이터가 데이터다 보니 당장은 실시간으로 본다고 달라지지 않을 것 같아 적용하지 않았다.

 

아무튼 완성본은 요렇게~