fixed sleep; added channels in data

server/inputbusiness.cpp

 {
 }
 
-QList<QVariant> InputBusiness::readAndSend(quint64 timestamp)
+QList<QPair<QVariant, QVariant>> InputBusiness::readAndSend(quint64 timestamp)
 {
-    QList<QVariant> values;
+    QList<QPair<QVariant, QVariant>> values;
     foreach (auto channel, m_channels)
-        values.append(m_input->read(channel));
+        values.append(QPair<QVariant, QVariant>(channel, m_input->read(channel)));
     m_server->sendData(values, timestamp);
     return values;
 }

server/inputbusiness.h

     virtual ~InputBusiness();
 
 public slots:
-    QList<QVariant> readAndSend(quint64 timestamp);
+    QList<QPair<QVariant, QVariant> > readAndSend(quint64 timestamp);
 
 private:
     InputManager* m_input;

server/mainclass.cpp

 #include <QVariant>
 #include <iostream>
 #include <sysexits.h>
-#include <sys/time.h>
 #include <unistd.h>
 #include "qcommandlineparser.h"
 #include "mainclass.h"
 
 void MainClass::maySend()
 {
-    struct timeval time;
-    gettimeofday(&time, NULL);
-    if (time.tv_usec - m_lastTime < 100)
-        usleep(100 - (time.tv_usec - m_lastTime));
-    gettimeofday(&time, NULL);
-    m_lastTime = time.tv_usec;
-    auto values = m_input->readAndSend(time.tv_usec);
+    auto time = getTime();
+    if (time - m_lastTime < 100)
+        usleep(100 - (time - m_lastTime));
+    m_lastTime = getTime();
+    auto values = m_input->readAndSend(time);
     if (m_verbose)
     {
-        std::cout << time.tv_usec << ":";
+        std::cout << time << ":";
         foreach (auto value, values) {
-            std::cout << " " << value.toInt();
+            std::cout << " " << value .first.toInt() << ":" << value.second.toInt();
         }
         std::cout << std::endl;
     }

server/mainclass.h

 #define MAINCLASS_H
 
 #include <QObject>
+#include <sys/time.h>
 #include "inputbusiness.h"
 
 class MainClass : public QObject
 
     void maySend();
 
+    inline __suseconds_t getTime() const;
+
 private:
     InputBusiness* m_input;
 
     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/servermanager.cpp

     return m_server->listen(addr, port);
 }
 
-void ServerManager::sendData(const QList<QVariant> &values, const qint64 &timestamp)
+void ServerManager::sendData(const QList<QPair<QVariant, QVariant>> &values, const qint64 &timestamp)
 {
     auto clients = m_server->getClients();
     if (!clients.count())
 
     stream << timestamp << values.count();
     foreach (auto value, values)
-        stream << value;
+        stream << value.first << value.second;
     foreach (auto client, clients)
         client->send(1, data);
 }

server/servermanager.h

 #define SERVERMANAGER_H
 
 #include <QObject>
+#include <QPair>
 #include <ptsocket/ptserver.h>
 
 class ServerManager : public QObject
 public slots:
     bool init(const QHostAddress& addr, const int& port);
 
-    void sendData(const QList<QVariant> &values, const qint64& timestamp);
+    void sendData(const QList<QPair<QVariant, QVariant> > &values, const qint64& timestamp);
 
 private:
     PTServer* m_server;