aswi2021vochomurka-gitlab/aswi2021vochomurka/view/main_view.py @ 7d28568e

import logging
import math

import matplotlib.pyplot as plt
from PyQt5 import QtGui
from PyQt5.QtCore import QSize, QThread, QObject, pyqtSignal
from PyQt5.QtWidgets import QMainWindow, QWidget, QMenuBar, QAction
from PyQt5.QtWidgets import QVBoxLayout
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
from matplotlib.backends.backend_qt5agg import NavigationToolbar2QT as NavigationToolbar

from aswi2021vochomurka.model.Message import Message
from aswi2021vochomurka.service.mqtt.mqtt_subscriber import MQTTSubscriber
from aswi2021vochomurka.service.subscriber import Subscriber
from aswi2021vochomurka.service.subscriber_callback import SubscriberCallback
from aswi2021vochomurka.service.subscriber_params import SubscriberParams, ConnectionParams
from aswi2021vochomurka.view.about import AboutDialog
from aswi2021vochomurka.view.help import HelpDialog
from aswi2021vochomurka.view.logger_view import LoggerView
from aswi2021vochomurka.view.settings import SettingsDialog


class Worker(QObject, SubscriberCallback):
    connected = pyqtSignal()
    disconnected = pyqtSignal()
    error = pyqtSignal(Exception)
    newMessage = pyqtSignal(Message)
    subscriber: Subscriber = None

    params = SubscriberParams(
        ["/home/1", "/home/2"],
        10,
        ConnectionParams("localhost", 1883, 60),
        True
    )

    def start(self):
        self.subscriber = MQTTSubscriber(self, self.params)
        self.subscriber.start()

    def stop(self):
        self.subscriber.stop()

    def onConnected(self):
        self.connected.emit()

    def onDisconnected(self):
        self.disconnected.emit()

    def onError(self):
        self.error.emit()

    def onMessage(self, message: Message):
        self.newMessage.emit(message)
        pass

    def onCloseTopic(self, topic: str):
        pass


class MainView(QMainWindow):
    worker: Worker = None
    workerThread: QThread = None

    def __init__(self):
        super(MainView, self).__init__()

        self.chartsNum = 0
        self.arrayData = []

        self.dataIndex = 0
        self.dataDict = {}

        self.figure = plt.figure(figsize=([500,500]))

        self.canvas = FigureCanvas(self.figure)
        self.toolbar = NavigationToolbar(self.canvas, self)

        self.setMinimumSize(QSize(440, 240))
        self.setWindowTitle("MQTT client")

        logger = self._createLoggerView()
        layout = QVBoxLayout()
        layout.addWidget(logger.widget)
        layout.addWidget(self.toolbar)
        layout.addWidget(self.canvas)

        widget = QWidget()
        widget.setLayout(layout)
        self.setCentralWidget(widget)
        self._createMenuBar()

        self.initSubscriber()

    def _createLoggerView(self):
        logger = LoggerView(self)
        formatter = logging.Formatter('%(asctime)s %(message)s', '%H:%M')
        logger.setFormatter(formatter)
        logger.setLevel(logging.INFO)
        logging.getLogger('').addHandler(logger)
        return logger

    def _createMenuBar(self):
        menuBar = QMenuBar(self)
        settingsAction = QAction("&Settings", self)
        settingsAction.triggered.connect(self.settings)
        helpAction = QAction("&Help", self)
        helpAction.triggered.connect(self.help)
        aboutAction = QAction("&About", self)
        aboutAction.triggered.connect(self.about)
        menuBar.addAction(settingsAction)
        menuBar.addAction(helpAction)
        menuBar.addAction(aboutAction)
        self.setMenuBar(menuBar)

    def plot(self, message: Message):
        self.figure.clear()

        if message.topic in self.dataDict:
            self.dataDict[message.topic].append(message.value)
        else:
            self.dataDict[message.topic] = [message.value]
            self.chartsNum += 1

        rows = math.ceil(self.chartsNum / 2)

        b = 0
        for a in self.dataDict.values():
            self.figure.add_subplot(rows, 2, b + 1)
            b += 1
            plt.plot(a)

        self.canvas.draw()

    def closeEvent(self, a0: QtGui.QCloseEvent) -> None:
        self.worker.stop()

    def settings(self):
        dialog = SettingsDialog()
        if dialog.exec_():
            self.reconnect()

    def help(self):
        dialog = HelpDialog()
        dialog.exec_()
        pass

    def about(self):
        dialog = AboutDialog()
        dialog.exec_()

    def disconnect(self):
        self.worker.stop()
        self.workerThread.quit()
        self.workerThread.wait()

    def reconnect(self):
        self.disconnect()
        self.workerThread.start()

    def initSubscriber(self):
        self.workerThread = QThread()
        self.worker = Worker()
        self.worker.moveToThread(self.workerThread)
        self.workerThread.started.connect(self.worker.start)
        self.worker.newMessage.connect(
            lambda message: self.plot(message)
        )
        self.workerThread.start()