thread for reading input

server/inputbusiness.cpp

 #include <time.h>
 #include "inputbusiness.h"
 
-InputBusiness::InputBusiness(InputManager *input, const QList<QVariant> &channels, ServerManager *server)
-    : m_input(input)
-    , m_channels(channels)
-    , m_server(server)
+InputBusiness::InputBusiness(InputManager *input, const QList<QVariant> &channels, quint64 interval, ServerManager *server)
+    : m_server(server)
+    , m_thread(new ReadThread(input, channels, interval, this))
 {
+    connect(m_thread, SIGNAL(newValues(InputValues,quint64)), this, SLOT(m_newValues(InputValues,quint64)));
 }
 
 InputBusiness::~InputBusiness()
 {
 }
 
-QList<QPair<QVariant, QVariant>> InputBusiness::readAndSend(quint64 timestamp)
+void InputBusiness::m_newValues(InputValues values, quint64 timestamp)
 {
-    QList<QPair<QVariant, QVariant>> values;
-    foreach (auto channel, m_channels)
-        values.append(QPair<QVariant, QVariant>(channel, m_input->read(channel)));
     m_server->sendData(values, timestamp);
-    return values;
+    emit newValues(values, timestamp);
 }
 
+void InputBusiness::start()
+{
+    m_thread->start();
+}

server/inputbusiness.h

 #include <QObject>
 #include "inputmanager.h"
 #include "servermanager.h"
+#include "readthread.h"
 
 class InputBusiness : public QObject
 {
     Q_OBJECT
 public:
-    InputBusiness(InputManager* input, const QList<QVariant>& channels, ServerManager* server);
+    InputBusiness(InputManager* input, const QList<QVariant>& channels, quint64 interval, ServerManager* server);
+
     virtual ~InputBusiness();
 
-public slots:
-    QList<QPair<QVariant, QVariant> > readAndSend(quint64 timestamp);
+signals:
+    void newValues(InputValues values, quint64 timestamp);
 
-private:
-    InputManager* m_input;
+public slots:
+    void start();
 
-    QList<QVariant> m_channels;
+private slots:
+    void m_newValues(InputValues values, quint64 timestamp);
 
+private:
     ServerManager* m_server;
+
+    ReadThread* m_thread;
 };
 
 #endif // INPUTBUSINESS_H

server/mainclass.cpp

 #include <QVariant>
 #include <iostream>
 #include <sysexits.h>
-#include <unistd.h>
 #include "qcommandlineparser.h"
 #include "mainclass.h"
 #include "gpiomanager.h"
         return;
     }
 
-    m_input = new InputBusiness(input, m_channels, server);
-    m_timer = new QTimer(this);
-    m_timer->setSingleShot(false);
-    m_timer->setInterval(m_interval / 1000);
-    connect(m_timer, SIGNAL(timeout()), this, SLOT(maySend()));
-    m_timer->start();
+    m_input = new InputBusiness(input, m_channels, m_interval, server);
+    if (m_verbose)
+        connect(m_input, SIGNAL(newValues(InputValues,quint64)), this, SLOT(newValues(InputValues,quint64)));
+    m_input->start();
 }
 
-void MainClass::maySend()
+void MainClass::newValues(InputValues values, quint64 timestamp)
 {
-    auto time = getTime();
-    if (time - m_lastTime < m_interval)
-        usleep(m_interval - (time - m_lastTime));
-    m_lastTime = getTime();
-    auto values = m_input->readAndSend(time);
-    if (m_verbose)
-    {
-        std::cout << time << ":";
-        foreach (auto value, values) {
-            std::cout << " " << value .first.toLongLong() << ":" << value.second.toInt();
-        }
-        std::cout << std::endl;
+    std::cout << timestamp << ":";
+    foreach (auto value, values) {
+        std::cout << " " << value .first.toLongLong() << ":" << value.second.toInt();
     }
+    std::cout << "\n";
 }
 
 void MainClass::getOpts()

server/mainclass.h

 #define MAINCLASS_H
 
 #include <QObject>
-#include <sys/time.h>
 #include "inputbusiness.h"
 
 class MainClass : public QObject
 public slots:
     void main();
 
-    void maySend();
-
-    inline __suseconds_t getTime() const;
+private slots:
+    void newValues(InputValues values, quint64 timestamp);
 
 private:
     InputBusiness* m_input;
 
-    QTimer* m_timer;
-
     DeviceType m_device;
 
     QHostAddress m_address;
     void getOpts();
 };
 
-__suseconds_t MainClass::getTime() const
-{
-    struct timeval time;
-    gettimeofday(&time, NULL);
-    return 1000000 * time.tv_sec + time.tv_usec;
-}
-
 #endif // MAINCLASS_H

server/readthread.cpp

+#include "readthread.h"
+
+ReadThread::ReadThread(InputManager* input, const QList<QVariant> &channels, quint64 interval, QObject *parent)
+    : QThread(parent)
+    , m_input(input)
+    , m_channels(channels)
+    , m_interval(interval)
+{
+    qRegisterMetaType<InputValues>("InputValues");
+}
+
+void ReadThread::run()
+{
+    while (true)
+    {
+        InputValues values;
+        foreach (auto channel, m_channels)
+            values.append(QPair<QVariant, QVariant>(channel, m_input->read(channel)));
+        emit newValues(values, getTime());
+        usleep(m_interval);
+    }
+}

server/readthread.h

+#ifndef READTHREAD_H
+#define READTHREAD_H
+
+#include <QThread>
+#include <sys/time.h>
+#include "inputmanager.h"
+
+typedef QList<QPair<QVariant, QVariant>> InputValues;
+
+class ReadThread : public QThread
+{
+    Q_OBJECT
+public:
+    explicit ReadThread(InputManager* input, const QList<QVariant> &channels, quint64 interval, QObject *parent = 0);
+
+    inline __suseconds_t getTime() const;
+
+protected:
+    void run();
+
+signals:
+    void newValues(InputValues values, quint64 timestamp);
+
+private:
+    InputManager* m_input;
+
+    QList<QVariant> m_channels;
+
+    quint64 m_interval;
+};
+
+__suseconds_t ReadThread::getTime() const
+{
+    struct timeval time;
+    gettimeofday(&time, NULL);
+    return 1000000 * time.tv_sec + time.tv_usec;
+}
+
+Q_DECLARE_METATYPE(InputValues)
+
+#endif // READTHREAD_H

server/server.pro

     inputbusiness.cpp \
     randommanager.cpp \
     qcommandlineoption.cpp \
-    qcommandlineparser.cpp
+    qcommandlineparser.cpp \
+    readthread.cpp
 
 HEADERS += \
     mainclass.h \
     inputbusiness.h \
     randommanager.h \
     qcommandlineoption.h \
-    qcommandlineparser.h
+    qcommandlineparser.h \
+    readthread.h