Modbus Master RTU in thread

[Damian7546]

Hi,

Does anyone see any problem in the following modbus master rtu communication code?

#include "modbusmastera.h"
#include <QVariant>
#include <QThread>
#include <QDebug>
#include <QtSerialPort/QSerialPort>

ModbusMasterA::ModbusMasterA(QObject *parent)
    : QObject(parent)
    , m_timer(new QTimer(this))
    , m_modbus(new QModbusRtuSerialMaster(this))
    , m_output0(false)
    , m_output1(false)
    , m_output2(false)
    , m_output3(false)
    , m_output4(false)
    , m_output5(false)
    , m_output6(false)
    , m_output7(false)
{
    m_modbus->setConnectionParameter(QModbusDevice::SerialPortNameParameter, "/dev/ttyS2");
    m_modbus->setConnectionParameter(QModbusDevice::SerialBaudRateParameter, QSerialPort::Baud9600);
    m_modbus->setConnectionParameter(QModbusDevice::SerialParityParameter, QSerialPort::NoParity);
    m_modbus->setConnectionParameter(QModbusDevice::SerialDataBitsParameter, QSerialPort::Data8);
    m_modbus->setConnectionParameter(QModbusDevice::SerialStopBitsParameter, QSerialPort::OneStop);
    m_modbus->setTimeout(500);
    m_modbus->setNumberOfRetries(1);

    if (!m_modbus->connectDevice())
    {
        qDebug() << "connectDevice: " << m_modbus->errorString();
    }

    m_timer->setInterval(100);
    connect(m_timer, SIGNAL(timeout()), this, SLOT(run()));
    m_timer->start();

    connect(&m_pulseOutput0WidthTimer, &QTimer::timeout, this, [&](){output0(false); m_pulseOutput0WidthTimer.stop();} );
    connect(&m_pulseOutput1WidthTimer, &QTimer::timeout, this, [&](){output1(false); m_pulseOutput1WidthTimer.stop();} );


}

ModbusMasterA::~ModbusMasterA()
{
    m_modbus->disconnectDevice();
    delete m_modbus;
    delete m_timer;
}

void ModbusMasterA::run()
{
    // Write Outputs
    QModbusDataUnit write(QModbusDataUnit::Coils,16,8);
    write.setValue(0, m_output0);
    write.setValue(1, m_output1);
    write.setValue(2, m_output2);
    write.setValue(3, m_output3);
    write.setValue(4, m_output4);
    write.setValue(5, m_output5);
    write.setValue(6, m_output6);
    write.setValue(7, m_output7);

    if (auto *reply = m_modbus->sendWriteRequest(write, 1))
    {
        if (!reply->isFinished())
        {
            connect(reply, SIGNAL(finished()), this, SLOT(processWrite()));
        }
        else
        {
            delete reply;
        }
    }

    // Read Inputs
    QModbusDataUnit read(QModbusDataUnit::DiscreteInputs, 0, 8);
    if (auto* reply = m_modbus->sendReadRequest(read, 1))
    {
        if (!reply->isFinished())
        {
            connect(reply, SIGNAL(finished()), this, SLOT(processRead()));
        }
        else
        {
            delete reply;
        }
    }
}

void ModbusMasterA::processRead()
{
    auto reply = qobject_cast<QModbusReply*>(sender());


    if (reply->error() != QModbusDevice::NoError)
    {
        qDebug() << "sendReadRequest: " << reply->errorString();

    }
    else
    {
        auto result = reply->result();
       setInput0(result.value(0));
       setInput1(result.value(1));
       setInput2(result.value(2));
       setInput3(result.value(3));
       setInput4(result.value(4));
       //setInput5(result.value(5));
       //setInput6(result.value(6));
       //setInput7(result.value(7));
    }

    delete reply;
}

void ModbusMasterA::processWrite()
{
    auto reply = qobject_cast<QModbusReply*>(sender());
    if (reply->error() != QModbusDevice::NoError)
    {
        qDebug() << "sendWriteRequest: " << reply->errorString();
    }
    delete reply;
}

void ModbusMasterA::output0(bool value)
{
    m_output0 = value;
}

void ModbusMasterA::output1(bool value)
{
    m_output1 = value;
}

void ModbusMasterA::output2(bool value)
{
    m_output2 = value;
}

void ModbusMasterA::output3(bool value)
{
    m_output3 = value;
}
void ModbusMasterA::output4(bool value)
{
    m_output4 = value;
}
void ModbusMasterA::output5(bool value)
{
    m_output5 = value;
}
void ModbusMasterA::output6(bool value)
{
    m_output6 = value;
}
void ModbusMasterA::output7(bool value)
{
    m_output7 = value;
}

void ModbusMasterA::openGate()
{
    output0(true);
    m_pulseOutput0WidthTimer.start(1000);
}

void ModbusMasterA::closeGate()
{
    output1(true);
    m_pulseOutput1WidthTimer.start(1000);
}

bool ModbusMasterA::input0() const
{
    return m_input0;
}

After a few hours of work my application slows down a lot...The processor and memory on pc is ok.. How can a find problem ?