Как сделать вторичный поток с постоянный жизненным циклом и управлением из главного потока

#ifndef MAINWINDOW_H
#define MAINWINDOW_H
 
#include <QMainWindow>
#include "thread.h"
 
class MainWindow : public QMainWindow
{
    Q_OBJECT
 
public:
    MainWindow(QWidget *parent = 0);
    ~MainWindow();
 
public slots:
    void StartOne();
    void StartAll();
    void Stop();
 
    void DoneOne(int id, QByteArray answer);
    void DoneAll(QByteArray answer);
 
protected:
    Thread* thread;
};
 
#endif // MAINWINDOW_H

#include "mainwindow.h"
#include <QVBoxLayout>
#include <QPushButton>
#include <QMessageBox>
 
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
{
    thread = new Thread;
 
    QPushButton* btnReadOne = new QPushButton("read one");
    QPushButton* btnReadAll = new QPushButton("read all");
    QPushButton* btnStopRead = new QPushButton("stop read");
 
    QVBoxLayout* l = new QVBoxLayout();
    l->addWidget(btnReadOne);
    l->addWidget(btnReadAll);
    l->addWidget(btnStopRead);
    QWidget* w = new QWidget;
    w->setLayout(l);
    setCentralWidget(w);
 
    connect(btnReadOne, &QPushButton::clicked, this, &MainWindow::StartOne);
    connect(btnReadAll, &QPushButton::clicked, this, &MainWindow::StartAll);
    connect(btnStopRead, &QPushButton::clicked, this, &MainWindow::Stop);
 
    connect(thread, &Thread::readOneDone, this, &MainWindow::DoneOne);
    connect(thread, &Thread::readAllDone, this, &MainWindow::DoneAll);
}
 
MainWindow::~MainWindow()
{
    delete thread;
}
 
void MainWindow::StartOne()
{
    thread->readOne(2);
}
 
void MainWindow::StartAll()
{
    thread->readAll();
}
 
void MainWindow::Stop()
{
    thread->stopRead();
}
 
void MainWindow::DoneOne(int id, QByteArray answer)
{
    QMessageBox box;
    box.setWindowTitle("Done One");
    box.setText(answer);
    box.exec();
}
 
void MainWindow::DoneAll(QByteArray answer)
{
    QMessageBox box;
    box.setWindowTitle("Done All");
    box.setText(answer);
    box.exec();
}

#ifndef THREAD_H
#define THREAD_H
 
#include <QObject>
 
#include <thread>
#include <mutex>
#include <condition_variable>
 
enum ETask
{
    keTaskNone,
    keTaskReadOne,
    keTaskReadAll,
    keTaskStopRead,
    keTaskTerminate,
};
 
struct STaskState
{
    ETask next;
    int nextId;
 
    ETask current;
    int currentId;
    int doneCount;
    int maxCount;
};
 
class Thread : public QObject
{
    Q_OBJECT
 
public:
    explicit Thread(QObject *parent = 0);
    ~Thread();
 
    bool readOne(int id);
    bool readAll();
    void stopRead();
 
    STaskState getState() { std::lock_guard<std::mutex> lck(mutex); return state; }
 
signals:
    void readOneDone(int id, QByteArray answer);
    void readAllDone(QByteArray answer);
 
protected:
    void loop();
    bool waitTask();
    QByteArray execOne(int id);
 
protected:
    std::mutex mutex;
    std::thread thread;
    std::condition_variable convar;
    STaskState state;
    QByteArray answerAll;
};
 
#endif // THREAD_H

#include "thread.h"
#include <chrono>
 
Thread::Thread(QObject *parent) : QObject(parent)
{
    state.next = keTaskNone;
    state.nextId = 0;
 
    state.current = keTaskNone;
    state.currentId = 0;
    state.doneCount = 0;
    state.maxCount = 0;
 
    thread = std::thread(&Thread::loop, this);
}
 
Thread::~Thread()
{
    mutex.lock();
    state.next = keTaskTerminate;
    convar.notify_one();
    mutex.unlock();
 
    if (thread.joinable())
        thread.join();
}
 
bool Thread::readOne(int id)
{
    std::lock_guard<std::mutex> lck(mutex);
 
    // предыдущий запрос ещё не начал обрабатываться
    if (state.next != keTaskNone)
        return false;
 
    state.next = keTaskReadOne;
    state.nextId = id;
 
    convar.notify_one();
 
    return true;
}
 
bool Thread::readAll()
{
    std::lock_guard<std::mutex> lck(mutex);
 
    // предыдущий запрос ещё не начал обрабатываться
    if (state.next != keTaskNone)
        return false;
 
    state.next = keTaskReadAll;
    state.nextId = 0;
 
    convar.notify_one();
 
    return true;
}
 
void Thread::stopRead()
{
    std::lock_guard<std::mutex> lck(mutex);
 
    state.next = keTaskStopRead;
 
    convar.notify_one();
}
 
void Thread::loop()
{
    while (waitTask())
    {
        if (state.current == keTaskReadOne)
        {
            QByteArray answer = execOne(state.currentId);
 
            mutex.lock();
            state.doneCount++;
            mutex.unlock();
 
            emit readOneDone(state.currentId, answer);
        }
        else if (state.current == keTaskReadAll)
        {
            QByteArray answer = execOne(state.doneCount);
 
            if (state.doneCount > 0)
                answerAll += ",";
            answerAll.append(answer);
 
            mutex.lock();
            state.doneCount++;
            mutex.unlock();
 
            if (state.doneCount >= state.maxCount)
                emit readAllDone(answerAll);
        }
    }
}
 
bool Thread::waitTask()
{
    std::unique_lock<std::mutex> lck(mutex);
    while ((state.next == keTaskNone) && (state.doneCount == state.maxCount))
        convar.wait(lck);
 
    if (state.next == keTaskTerminate)
        return false;
 
    if (state.next == keTaskReadOne)
    {
        state.current = keTaskReadOne;
        state.currentId = state.nextId;
        state.doneCount = 0;
        state.maxCount = 1;
    }
    else if (state.next == keTaskReadAll)
    {
        answerAll.clear();
        state.current = keTaskReadAll;
        state.currentId = 0;
        state.doneCount = 0;
        state.maxCount = 200;
    }
    else if (state.next == keTaskStopRead)
    {
        state.current = keTaskStopRead;
        state.currentId = 0;
        state.doneCount = 0;
        state.maxCount = 0;
    }
    else if (state.next == keTaskNone)
    {
        if (state.current == keTaskReadAll)
        {
        }
    }
 
    state.next = keTaskNone;
 
    return true;
}
 
QByteArray Thread::execOne(int id)
{
    std::this_thread::sleep_for(std::chrono::microseconds(80));
    return QByteArray().setNum(id);
}

#ifndef IODEVICE_H
#define IODEVICE_H
#include <QtCore>
#include <modbus/modbus.h>
#include <errno.h>
 
class IODevice
{
private:
 
public:
    IODevice();
    int readData(int address_device, int addr, int nb, unsigned short int* tab_reg);
    int writeData(int address_device, int addr, int nb, unsigned short int *tab_reg);
    int readId(int address_device, int size, unsigned char* text);
};
 
#endif // IODEVICE_H

#include "iodevice.h"
 
IODevice::IODevice()
{
 
}
 
int IODevice::readData(int address_device, int addr, int nb, unsigned short *tab_reg)
{
    int rc = 0;
    unsigned char counter = 0;
    // 'E' - event work mode, 8 - data bits, 1 - stop bit - serial port configuration
    modbus_t* my_modbus = modbus_new_rtu("/dev/ttyAPP1", 4800, 'E', 8, 1);
    uint32_t old_response_to_sec;
    uint32_t old_response_to_usec;
    modbus_get_response_timeout(my_modbus, &old_response_to_sec, &old_response_to_usec);
    modbus_set_response_timeout(my_modbus, 0, 30000);
 
    if(modbus_connect(my_modbus)  == 0){
 
    modbus_set_slave(my_modbus, address_device);
 
    while(1)
    {
    rc = modbus_read_input_registers(my_modbus, addr, nb,tab_reg);
    if(rc != -1)
    {
    break;
    }
    counter ++;
    if(counter == 3){
    modbus_close(my_modbus);
    modbus_free(my_modbus);
    return (-1);
    break;
    }
    }
 
    }
    modbus_close(my_modbus);
    modbus_free(my_modbus);
    return(rc);
}
 
 
int IODevice::writeData(int address_device, int addr, int nb, unsigned short *tab_reg)
{
    int rc = 0;
    unsigned char counter = 0;
    // 'E' - event work mode, 8 - data bits, 1 - stop bit - serial port configuration
    modbus_t* my_modbus = modbus_new_rtu("/dev/ttyAPP1", 4800, 'E', 8, 1);
    uint32_t old_response_to_sec;
    uint32_t old_response_to_usec;
    modbus_get_response_timeout(my_modbus, &old_response_to_sec, &old_response_to_usec);
    modbus_set_response_timeout(my_modbus, 0, 30000);
 
    if(modbus_connect(my_modbus)  == 0){
 
    modbus_set_slave(my_modbus, address_device);
 
    while(1)
    {
    rc = modbus_write_registers(my_modbus, addr, nb,tab_reg);
    if(rc != -1)
    {
    break;
    }
    counter ++;
    if(counter == 3){
    modbus_close(my_modbus);
    modbus_free(my_modbus);
    return (-1);
    break;
    }
    }
 
    }
    modbus_close(my_modbus);
    modbus_free(my_modbus);
    return(1);
}
 
 
int IODevice::readId(int address_device, int size, unsigned char* text)
{
    int rc = 0;
    unsigned char counter = 0;
    // 'E' - event work mode, 8 - data bits, 1 - stop bit - serial port configuration
    modbus_t* my_modbus = modbus_new_rtu("/dev/ttyAPP1", 4800, 'E', 8, 1);
    uint32_t old_response_to_sec;
    uint32_t old_response_to_usec;
    modbus_get_response_timeout(my_modbus, &old_response_to_sec, &old_response_to_usec);
    modbus_set_response_timeout(my_modbus, 0, 30000);
 
    if(modbus_connect(my_modbus)  == 0){
 
    modbus_set_slave(my_modbus, address_device);
 
    while(1)
    {
    rc = modbus_report_slave_id(my_modbus, size,text);
    if(rc != -1)
    {
    break;
    }
    counter ++;
    if(counter == 3){
    modbus_close(my_modbus);
    modbus_free(my_modbus);
    return (-1);
    break;
    }
    }
 
    }
    modbus_close(my_modbus);
    modbus_free(my_modbus);
    return(1);
}

#ifndef SENSORMANAGER_H
#define SENSORMANAGER_H
 
#include <QObject>
#include <sensorinfo.h>
 
class SensorManager : public QObject
{
    Q_OBJECT
private:
   bool m_runFlag;
   QByteArray deviceInfo;
 
public:
    explicit SensorManager(const QByteArray& deviceInfo, QObject *parent = 0);
 
signals:
    void signalReadStep(quint32 step);
    void signalReadStop();
 
public slots:
    void slotAutoModeBalancer();
    void slotStopBalancer();
};
 
#endif // SENSORMANAGER_H

#ifndef SENSORMANAGER_H
#define SENSORMANAGER_H
 
#include <QObject>
#include <sensorinfo.h>
 
class SensorManager : public QObject
{
    Q_OBJECT
private:
   bool m_runFlag;
   QByteArray deviceInfo;
   int numberBalancer;
 
public:
    explicit SensorManager(const QByteArray& deviceInfo, QObject *parent = 0);
 
    void readOneBalancer(int addressDevice);
 
signals:
    void signalInfoOne(quint32 *buf);
    void signalStartOne(quint32 size);
    void signalStopOne();
 
    void signalInfoAuto(quint32 *buf);
    void signalStartAuto(quint32 size);
    void signalStepAuto(quint32 step);
    void signalStopAuto();
public slots:
    void slotAutoModeBalancer();
    void slotStopBalancer();
};
 
#endif // SENSORMANAGER_H

#ifndef MAINWINDOW_H
#define MAINWINDOW_H
 
#include <QMainWindow>
#include <QLabel>
#include <QThread>
#include "thread.h"
 
class MainWindow : public QMainWindow
{
    Q_OBJECT
 
public:
    MainWindow(QWidget *parent = 0);
    ~MainWindow();
 
signals:
    void signalStartOne(int id);
 
public slots:
    void StartOne();
 
    void DoneOne(int id, QByteArray answer);
    void DoneAll(QByteArray answer);
 
protected:
    void timerEvent(QTimerEvent *event) override;
 
protected:
    QLabel* label;
    Thread* thread;
    QThread qthread;
};
 
#endif // MAINWINDOW_H

#include "mainwindow.h"
#include <QVBoxLayout>
#include <QPushButton>
#include <QMessageBox>
 
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
{
    thread = new Thread;
    thread->moveToThread(&qthread);
    qthread.start();
 
    QPushButton* btnReadOne = new QPushButton("read one");
    QPushButton* btnReadAll = new QPushButton("read all");
    QPushButton* btnStopRead = new QPushButton("stop read");
    label = new QLabel;
 
    QVBoxLayout* l = new QVBoxLayout();
    l->addWidget(btnReadOne);
    l->addWidget(btnReadAll);
    l->addWidget(btnStopRead);
    l->addWidget(label);
    QWidget* w = new QWidget;
    w->setLayout(l);
    setCentralWidget(w);
 
    connect(btnReadOne, SIGNAL(clicked()), this, SLOT(StartOne()));
    connect(this, SIGNAL(signalStartOne(int)), thread, SLOT(readOne(int)));
    connect(btnReadAll, SIGNAL(clicked()), thread, SLOT(readAll()));
    connect(btnStopRead, SIGNAL(clicked()), thread, SLOT(stopRead()));
 
    connect(thread, SIGNAL(readOneDone(int,QByteArray)), this, SLOT(DoneOne(int,QByteArray)));
    connect(thread, SIGNAL(readAllDone(QByteArray)), this, SLOT(DoneAll(QByteArray)));
 
    startTimer(100);
}
 
MainWindow::~MainWindow()
{
    delete thread;
}
 
void MainWindow::StartOne()
{
    // напрямую нельзя, не предусмотрено в реализации
    //thread->readOne(2);
 
    // только через очередь сообщений
    emit signalStartOne(2);
}
 
void MainWindow::DoneOne(int id, QByteArray answer)
{
    QMessageBox box;
    box.setWindowTitle("Done One");
    box.setText(answer);
    box.exec();
}
 
void MainWindow::DoneAll(QByteArray answer)
{
    QMessageBox box;
    box.setWindowTitle("Done All");
    box.setText(answer);
    box.exec();
}
 
void MainWindow::timerEvent(QTimerEvent *event)
{
    STaskState state = thread->getState();
 
    QString str = "Unknown";
 
    switch (state.current)
    {
    case keTaskNone:
        str= "None";
        break;
 
    case keTaskReadOne:
        str= "ReadOne";
        break;
 
    case keTaskReadAll:
        str= "ReadAll";
        break;
 
    case keTaskStopRead:
        str= "StopRead";
        break;
 
    case keTaskTerminate:
        str= "Terminate";
        break;
    }
 
    str += QString(" (%0/%1)").arg(state.doneCount).arg(state.maxCount);
 
    label->setText(str);
}

#ifndef THREAD_H
#define THREAD_H
 
#include <QObject>
#include <QMutex>
 
// команды/режимы
enum ETask
{
    keTaskNone,         // ничего не делать
    keTaskReadOne,      // прочесть один датчик
    keTaskReadAll,      // прочесть все датчики
    keTaskStopRead,     // прервать чтение
    keTaskTerminate,    // завершить работу потока
};
 
// состояние
struct STaskState
{
    ETask current;  // текущий режим
    int currentId;  // id опрашиваемого датчика
    int doneCount;  // количество опрошенных датчиков
    int maxCount;   // общее количество датчиков, которые нужно опросить
};
 
// класс опроса датчиков в отдельном потоке
class Thread : public QObject
{
    Q_OBJECT
 
public:
    explicit Thread(QObject *parent = 0);
    ~Thread();
 
    STaskState getState() { QMutexLocker lck(&mutex); return state; } // текущее состояние потока: режим и рогресс
 
public slots:
    void readOne(int id); // начать одиночный опрос датчика
    void readAll(); // начать последовательный опрос всех имеющихся датчиков
    void stopRead(); // прервать опрос
 
signals:
    void readOneDone(int id, QByteArray answer); // испускается при завершении одиночного опроса датчика
    void readAllDone(QByteArray answer); // испускается при завершении последовательного опроса всех датчиков
 
    void signalUpdate(); // испускается изнутри для помещения в очередь команды на выполнение опроса
 
protected slots:
    void update(); // один шаг опроса
 
protected:
    QByteArray execOne(int id); // синхронно опросить датчик
 
protected:
    QMutex mutex;
    STaskState state;
    QByteArray answerAll;
};
 
#endif // THREAD_H

#include "thread.h"
#include <chrono>
#include <thread>
 
Thread::Thread(QObject *parent) : QObject(parent)
{
    // начальное состояние
    state.current = keTaskNone;
    state.currentId = 0;
    state.doneCount = 0;
    state.maxCount = 0;
 
    // соединяем сигнал и слот через очередь сообщений
    connect(this, SIGNAL(signalUpdate()), this, SLOT(update()), Qt::QueuedConnection);
}
 
Thread::~Thread()
{
}
 
void Thread::readOne(int id)
{
    // блокируем доступ к состоянию
    QMutexLocker lck(&mutex);
 
    // запоминаем команду: одиночный опрос датчика <id>
    state.current = keTaskReadOne;
    state.currentId = id;
    state.doneCount = 0;
    state.maxCount = 1;
 
    // помещаем в очередь команду на обновление
    emit signalUpdate();
}
 
void Thread::readAll()
{
    // блокируем доступ к состоянию
    QMutexLocker lck(&mutex);
 
    // запоминаем команду: последовательный опрос всех датчиков
    state.current = keTaskReadAll;
    state.doneCount = 0;
    state.maxCount = 200;
 
    // помещаем в очередь команду на обновление
    emit signalUpdate();
}
 
void Thread::stopRead()
{
    // блокируем доступ к состоянию
    QMutexLocker lck(&mutex);
 
    // запоминаем команду: прервать опрос
    state.current = keTaskStopRead;
}
 
void Thread::update()
{
    // одиночный опрос датчика
    if (state.current == keTaskReadOne)
    {
        if (state.doneCount < state.maxCount)
        {
            // синхронный опрос датчика
            QByteArray answer = execOne(state.currentId);
 
            // обнавляем статус
            mutex.lock();
            state.doneCount++;
            mutex.unlock();
 
            // испускаем сигнал о завершении
            emit readOneDone(state.currentId, answer);
        }
    }
    // последовательный опрос всех датчиков
    else if (state.current == keTaskReadAll)
    {
        if (state.doneCount < state.maxCount)
        {
            // синхронный опрос датчика
            QByteArray answer = execOne(state.doneCount);
 
            // запоминаем результат
            if (state.doneCount > 0)
                answerAll += "," + answer;
            else
                answerAll = answer;
 
            // обнавляем статус (переходим к следующему датчику)
            mutex.lock();
            state.doneCount++;
            mutex.unlock();
 
            // если все датчики опрошены
            if (state.doneCount >= state.maxCount)
            {
                // испускаем сигнал о завершении
                emit readAllDone(answerAll);
 
                // промежуточные результаты больше не нужны
                answerAll.clear();
            }
            else
            {
                // помещаем в очередь команду на повторное обновление
                emit signalUpdate();
            }
        }
    }
}
 
QByteArray Thread::execOne(int id)
{
    // эмулируем задержку при запросе к датчику
    std::this_thread::sleep_for(std::chrono::milliseconds(40));
 
    // в качестве ответа возвращаем id датчика в текстовом виде
    return QByteArray().setNum(id);
}