Merge pull request #5 from vedranMv/dev-1.0

Dev-1.0

Author: Vedran

README.md

@@ -1,39 +1,50 @@
 [Data dashboard](https://github.com/vedranMv/dataDashboard) [![Build Status](https://ci1.vedran.ml/api/badges/vedranMv/dataDashboard/status.svg)](https://ci1.vedran.ml/vedranMv/dataDashboard) [![License](https://img.shields.io/badge/license-GPL%20v3.0-brightgreen.svg)](/License)
 =======
- (QT based app for data visualization)
+ (QT based app for real-time data visualization)
 
-Data dashboard is a program based on QT framework that can be used to to visualize some of the common data types that one comes in contact when working with sensors. Although it was developed as during my work with IMU, and is mostly centered around it, it should be versatile enough for other sensors and purposes as well.
+Data dashboard is a program based on QT framework that can be used to to visualize some of the common data types that one comes in contact when working with sensors. Although it was developed during my work with IMU, and is mostly centered around it, it should be versatile enough for other sensors and purposes as well.
 
-It's currently a work in progress, but once completed it should to be able to:
-* Read data from serial port and or network socket (real input channel)
+It is currently possible to:
+* Read data from serial port or network socket (real input channel)
+* Show estimated incoming data rate
 * Define data frame (specify start/end of frame character, as well as data separator char)
 * Perform basic math (addition, subtraction, abs value) on multiple input channels and visualize result of the operations (virtual input channels)
 * Log input channels into a file
 * Visualize 3D orientation by taking either euler angles or quaternion as input
 * Visualize linear data series (flexible number of input channels)
 * Plot data in 3D scatter plot (or 2D by specifying one of the inputs as 0)
 * Create dashboard consisting of any combination of the visualizations above on runtime
+* Preserve settings between runs in a configuration file
+* Internal app log for easier troubleshooting
 
 ## Demo of current progress
-``/doc`` folder contains few screenshoots, demonstrating the functionality
+Few screenshots from ``/doc``, demonstrating the UI
 
-Demo video: https://vedran.ml/public/projects/datadashboard/demo.mp4
+[<img src="doc/dashboard.PNG" width="500" />](doc/dashboard.PNG)
+
+[<img src="doc/input.PNG" width="500" />](doc/input.PNG)
+
+[<img src="doc/math.PNG" width="500" /></a>](doc/comparison.PNG)
+
+Demo videos: 
+* https://vedran.ml/public/projects/datadashboard/demo.mp4
+* https://vedran.ml/public/projects/datadashboard/demo_net.mp4
 
 ## How to run
 
 There are several ways to run on both windows and linux.
 
 ### Windows
 
-* Download a portable (statically linked) precompiled version from [Releases](https://github.com/vedranMv/dataDashboard/releases); _; or_
+* Download a portable (statically linked) precompiled version from [Releases](https://github.com/vedranMv/dataDashboard/releases)_; or_
 * Download QT Creator and compile the source from this repo
 
 ### Linux
 There are several dependencies for running on linux systems, regardless of which method below you go with:
 > ``sudo apt-get install libgl1-mesa-dev libfontconfig1 libxcb-randr0-dev libxcb-xtest0-dev libxcb-xinerama0-dev libxcb-shape0-dev libxcb-xkb-dev``
 
 After that, it's possible to:
-* (Ubuntu) Download a precompiled (dynamically linked), version from [Releases](https://github.com/vedranMv/) and launch ``datadashboard.sh``; _; or_
+* (Ubuntu) Download a precompiled (dynamically linked), version from [Releases](https://github.com/vedranMv/dataDashboard/releases) and launch ``datadashboard.sh``_; or_
 * Install QT creator and compile from scratch _; or_
 * Compile the project yourself, following the guide below
 
@@ -42,10 +53,10 @@ After that, it's possible to:
 1. Download libraries and compilation tools (not available on older Ubuntu 18.04/16.04)
 > ``sudo apt-get install qt5-default qt5-qmake libqt5datavisualization5-dev libqt5serialport5-dev libqt5core5a libqt5x11extras5-dev``
 
-2. Clone this project
+2. Clone this project (master branch for latest release version)
 > ``git clone --depth=1 https://github.com/vedranMv/dataDashboard``
 
-3. Make build directory inside the cloned one
+3. Make build directory inside the cloned repo
 > ``mkdir dataDashboard/build`` <br/> 
  ``cd dataDashboard/build``
 
@@ -58,8 +69,11 @@ After that, it's possible to:
 
 ## Known issues
 * Ubuntu 16.04/18.04: Launching scatter plot crashes the program (in Ubuntu 20.04 works as expected)
+* 3D orientation plot sometimes freezes (workaround: just switch to another tab, then reopen _Dashboard_ tab)
+* High data rates unsupported (scatter plot results in biggest negative impact on performance, see video)
 
 ## Acknowledgments
 Made using:
-* QT framework
-* [CQtDeployer](https://github.com/QuasarApp/CQtDeployer) part of CI pipeline for ubuntu
+* QT framework & examples
+* [CQtDeployer](https://github.com/QuasarApp/CQtDeployer) part of CI pipeline for ubuntu
+* [QTCustomPlot](https://www.qcustomplot.com/index.php/introduction) line plot component

dataSources/dataSources.h

@@ -0,0 +1,7 @@
+#ifndef DATASOURCES_H
+#define DATASOURCES_H
+
+#include "networkAdapter/networkadapter.h"
+#include "serialAdapter/serialadapter.h"
+
+#endif // DATASOURCES_H

dataSources/networkAdapter/networkadapter.cpp

@@ -0,0 +1,133 @@
+#include "networkadapter.h"
+
+NetworkAdapter::NetworkAdapter(): _threadQuit(false), _clientSocket(nullptr),
+    _port(0)
+{
+    _tcpServer = new QTcpServer();
+    connect(_tcpServer, &QTcpServer::newConnection,
+            this, &NetworkAdapter::_onNewConnection);
+
+    _mux = DataMultiplexer::GetP();
+}
+
+NetworkAdapter::~NetworkAdapter()
+{
+    //  Pass kill signal to the thread and wait for it to terminate
+    _threadQuit = true;
+    wait();
+    StopListening();
+}
+
+/**
+ * @brief Network port setted
+ * @param port
+ */
+void NetworkAdapter::SetNetPort(uint16_t port)
+{
+    _port = port;
+}
+
+/**
+ * @brief Network port getter
+ * @return
+ */
+uint16_t NetworkAdapter::GetPort()
+{
+    return _port;
+}
+
+/**
+ * @brief Start listening on network port
+ *      Starts up TCP server on a port
+ */
+bool NetworkAdapter::StartListening()
+{
+    if (!_tcpServer->isListening())
+    {
+        //  External process use this flag to control thread, avoid
+        //  forcing its value here
+        //_threadQuit = false;
+
+        if (_port == 0)
+        {
+            return false;
+            emit logLine("Port cannot be 0");
+        }
+
+        _tcpServer->listen(QHostAddress::Any, _port);
+        _tcpServer->resumeAccepting();
+        emit logLine("Waiting for new connection on port "+QString::number(_port));
+    }
+
+    return true;
+}
+
+/**
+ * @brief Stop listening on network port
+ *      Stop TCP server and tear down a client connection if it exists
+ */
+void NetworkAdapter::StopListening()
+{
+    emit logLine("Disconnecting client");
+
+    if (_clientSocket != nullptr)
+        if (_clientSocket->isOpen())
+        {
+            disconnect(_clientSocket, SIGNAL(readyRead()), this, SLOT(onReadyRead()));
+            disconnect(_clientSocket, SIGNAL(stateChanged(QAbstractSocket::SocketState)),
+                       this, SLOT(onSocketStateChanged(QAbstractSocket::SocketState)));
+            _clientSocket->close();
+            delete _clientSocket;
+            _clientSocket = nullptr;
+        }
+
+    emit logLine("Stopping network thread");
+    if (_tcpServer->isListening())
+        _tcpServer->close();
+}
+
+/**
+ * @brief [Slot] Handler for new TCP connection
+ *      Called by TCP server whenever a new client is asking to be connected
+ */
+void NetworkAdapter::_onNewConnection()
+{
+    _clientSocket = _tcpServer->nextPendingConnection();
+    _tcpServer->pauseAccepting();
+    emit logLine("Connection established, reading data");
+    //start();
+
+    connect(_clientSocket, SIGNAL(readyRead()), this, SLOT(onReadyRead()));
+    connect(_clientSocket, SIGNAL(stateChanged(QAbstractSocket::SocketState)),
+            this, SLOT(onSocketStateChanged(QAbstractSocket::SocketState)));
+}
+
+/**
+ * @brief [Slot] Handler for state change in sockets
+ *      Used to handle a client disconnecting from the server. Functions log
+ *      disconnect, delete client object and reset the pointer. Afterwards,
+ *      the server is enabled to receive new clients.
+ * @param socketState socket state after a change
+ */
+void NetworkAdapter::onSocketStateChanged(QAbstractSocket::SocketState socketState)
+{
+    if (socketState == QAbstractSocket::UnconnectedState)
+    {
+        emit logLine("Client disconnected, waiting for new connection");
+        _clientSocket->deleteLater();
+        _clientSocket = nullptr;
+        _tcpServer->resumeAccepting();
+    }
+}
+
+/**
+ * @brief [Slot] Handler for new incoming data on the socket
+ *      Called by the client socket when there's new data available
+ */
+void NetworkAdapter::onReadyRead()
+{
+    QByteArray responseData = _clientSocket->readAll();
+    const QString response = QString::fromUtf8(responseData);
+
+    _mux->ReceiveData(response);
+}

dataSources/networkAdapter/networkadapter.h

@@ -0,0 +1,41 @@
+#ifndef NETWORKADAPTER_H
+#define NETWORKADAPTER_H
+
+#include <QTcpServer>
+#include <QTcpSocket>
+#include <QThread>
+
+#include "helperObjects/dataMultiplexer/datamultiplexer.h"
+
+
+class NetworkAdapter : public QThread
+{
+    Q_OBJECT
+public:
+    NetworkAdapter();
+    ~NetworkAdapter();
+
+    void SetNetPort(uint16_t port);
+    uint16_t GetPort();
+    bool StartListening();
+    void StopListening();
+
+signals:
+    void logLine(const QString &s);
+
+private slots:
+        void _onNewConnection();
+        void onSocketStateChanged(QAbstractSocket::SocketState socketState);
+        void onReadyRead();
+
+private:
+
+    bool _threadQuit;
+    QTcpServer *_tcpServer;
+    QTcpSocket *_clientSocket;
+
+    uint16_t _port;
+    DataMultiplexer* _mux;
+};
+
+#endif // NETWORKADAPTER_H

dataSources/serialAdapter/serialadapter.cpp

@@ -0,0 +1,107 @@
+#include "serialadapter.h"
+
+#include <QSerialPort>
+#include <QTime>
+
+SerialAdapter::SerialAdapter(QObject *parent) :
+    QThread(parent)
+{
+    _mux = DataMultiplexer::GetP();
+}
+
+SerialAdapter::~SerialAdapter()
+{
+    _threadQuit = true;
+    wait();
+}
+
+/**
+ * @brief Open serial port
+ */
+void SerialAdapter::StartListening()
+{
+    //  Check if the thread is already running, if not start it
+    if (!isRunning())
+    {
+        _threadQuit = false;
+        start();
+    }
+}
+
+/**
+ * @brief Close serial port
+ */
+void SerialAdapter::StopListening()
+{
+    _threadQuit = true;
+}
+
+/**
+ * @brief Update serial port parameters
+ * @param portName
+ * @param portBaud
+ */
+void SerialAdapter::UpdatePort(const QString &portName, const QString &portBaud)
+{
+    if ((portName == _portName) && (portBaud == _portBaud))
+        _portUpdated = false;
+    else
+    {
+        _portUpdated = true;
+        _portName = portName;
+        _portBaud = portBaud;
+    }
+}
+
+/**
+ * @brief Thread to read and publish serial data, capable of dynamically
+ *  updating port parameters
+ */
+void SerialAdapter::run()
+{
+    QSerialPort serial;
+
+    emit logLine("Serial thread started");
+
+    if (_portName.isEmpty())
+    {
+        emit logLine(tr("No port name specified"));
+        return;
+    }
+
+    _portUpdated = true;
+
+    while (!_threadQuit)
+    {
+        //  Check if port name changed while running
+        if (_portUpdated)
+        {
+            serial.close();
+            serial.setPortName(_portName);
+            serial.setBaudRate(_portBaud.toUInt());
+
+            if (!serial.open(QIODevice::ReadWrite))
+            {
+                emit logLine(tr("Can't open %1, error code %2")
+                           .arg(_portName).arg(serial.error()));
+                return;
+            }
+            _portUpdated = false;
+        }
+
+        // Read response
+        if (serial.waitForReadyRead(5))
+        {
+            QByteArray responseData = serial.readAll();
+            while (serial.waitForReadyRead(1))
+                responseData += serial.readAll();
+
+            const QString response = QString::fromUtf8(responseData);
+
+            _mux->ReceiveData(response);
+        }
+    }
+    serial.close();
+    _threadQuit = false;
+    emit logLine("Serial thread exited");
+}