BatteryMonitor/modbusrtu.cpp

#include "modbusrtu.h"
#include <QTimer>
#include <QEvent>
#include <QDebug>
#include "modbus-private.h"
#include <QMessageBox>
ModbusRTU::ModbusRTU(QObject *parent) : QThread(parent)
{
    init();
    // start();

}

ModbusRTU::~ModbusRTU()
{
    modbus_close(m_ModbusRTUDevice);
    modbus_free(m_ModbusRTUDevice);
}

void ModbusRTU::init()
{

}

void ModbusRTU::run()
{
    qDebug() << "进入线程：" << QThread::currentThread();
    // QMetaObject::invokeMethod(QThread::currentThread(), "read_regs_slot", Qt::QueuedConnection);
    // QMetaObject::invokeMethod(QThread::currentThread(), "write_regs_slot", Qt::QueuedConnection);
    while(true)
    {
        // qDebug() << "11111111111111111111111111111111";
        QThread::msleep(500);
        uint16_t base1_45[45];
        uint16_t base57_78[22];
        uint16_t base83_106[24];
        uint16_t base47[1];
        uint16_t base49[1];
        uint16_t base51[1];
        uint16_t base53[1];
        uint16_t base55[1];
        QList<int> base_list_47_49_51_53_55;
        uint16_t sgl_vol[16];    // Buffer to store the registers
        uint16_t sgl_tempt[16];
        uint16_t fault[8];
        // uint16_t alarm[];

    label:    int ret_base1_45 = modbus_read_input_registers(m_ModbusRTUDevice, 1, 45, base1_45);
        if(MODBUS_ERR == ret_base1_45)
        {
            // qDebug() << "modbus no message";
            goto label;
        }
        else
        {
            // qDebug() << "2222222222222222222222222222222";
            QByteArray sendArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->sendMsg), m_ModbusRTUDevice->sendMsgLen);
            emit sig_showModbusData_base_info1_45(sendArray, TypeSendData, base1_45);
            free(m_ModbusRTUDevice->sendMsg);
            QByteArray recvArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->recvMsg), m_ModbusRTUDevice->recvMsgLen);
            emit sig_showModbusData_base_info1_45(recvArray, TypeRecvData, base1_45);
            free(m_ModbusRTUDevice->recvMsg);
            // qDebug() << "in modbus:" << base1_45;
        }

        int ret_base47 = modbus_read_input_registers(m_ModbusRTUDevice, 47, 1, base47);
        int ret_base49 = modbus_read_input_registers(m_ModbusRTUDevice, 49, 1, base49);
        int ret_base51 = modbus_read_input_registers(m_ModbusRTUDevice, 51, 1, base51);
        int ret_base53 = modbus_read_input_registers(m_ModbusRTUDevice, 53, 1, base53);
        int ret_base55 = modbus_read_input_registers(m_ModbusRTUDevice, 55, 1, base55);
        if (ret_base47 == -1 | ret_base49 == -1 | ret_base51 == -1 | ret_base53 == -1 | ret_base55 == -1)
        {
            return;
        }
        else
        {
            QByteArray sendArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->sendMsg), m_ModbusRTUDevice->sendMsgLen);
            emit sig_showModbusData_base_info47_49_51_53_55(sendArray, TypeSendData);
            free(m_ModbusRTUDevice->sendMsg);
            // QByteArray recvArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->recvMsg), m_ModbusRTUDevice->recvMsgLen);
            QByteArray recvArray;
            recvArray.append(reinterpret_cast<char*>(&base47), sizeof(base47));
            recvArray.append(reinterpret_cast<char*>(&base49), sizeof(base49));
            recvArray.append(reinterpret_cast<char*>(&base51), sizeof(base51));
            recvArray.append(reinterpret_cast<char*>(&base53), sizeof(base53));
            recvArray.append(reinterpret_cast<char*>(&base55), sizeof(base55));

            for (int i = 0; i < recvArray.size(); i += 2) {
                uint16_t value;
                memcpy(&value, recvArray.data() + i, 2);
                base_list_47_49_51_53_55.append(value);
                // base47_49_51_53_55[i] = value;
                // qDebug() << "Value: " << value;
            }

            emit sig_showModbusData_base_info_list_47_49_51_53_55(base_list_47_49_51_53_55, TypeRecvData);
            // emit sig_showModbusData_base_info47_49_51_53_55(sendArray, TypeSendData);
            free(m_ModbusRTUDevice->recvMsg);
        }

        int ret_base57_78 = modbus_read_input_registers(m_ModbusRTUDevice, 57, 22, base57_78);
        if(MODBUS_ERR == ret_base57_78)
        {
            // qDebug() << "modbus no message";
            goto label;
        }
        else
        {
            // qDebug() << "4444444444444444444444444444";
            QByteArray sendArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->sendMsg), m_ModbusRTUDevice->sendMsgLen);
            emit sig_showModbusData_base_info57_78(sendArray, TypeSendData, base57_78);
            free(m_ModbusRTUDevice->sendMsg);
            QByteArray recvArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->recvMsg), m_ModbusRTUDevice->recvMsgLen);
            emit sig_showModbusData_base_info57_78(recvArray, TypeRecvData, base57_78);
            free(m_ModbusRTUDevice->recvMsg);
        }

        int ret_fault = modbus_read_input_registers(m_ModbusRTUDevice, 66, 8, fault);
        if(MODBUS_ERR == ret_fault)
        {
            // qDebug() << "modbus no message";
            goto label;
        }
        else
        {
            // qDebug() << "4444444444444444444444444444";
            QByteArray sendArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->sendMsg), m_ModbusRTUDevice->sendMsgLen);
            emit sig_showFault(sendArray, TypeSendData, fault);
            free(m_ModbusRTUDevice->sendMsg);
            QByteArray recvArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->recvMsg), m_ModbusRTUDevice->recvMsgLen);
            emit sig_showFault(recvArray, TypeRecvData,fault);
            free(m_ModbusRTUDevice->recvMsg);
        }

        int ret_base83_106 = modbus_read_input_registers(m_ModbusRTUDevice, 83, 24, base83_106);
        // qDebug() << "#######" << base83_106[0] << base83_106[1] << base83_106[2] << base83_106[3];
        // qDebug() << "#######" << sgl_vol[0] << sgl_vol[1] << sgl_vol[2] << sgl_vol[3] << sgl_vol[4] << sgl_vol[5] << sgl_vol[6] << sgl_vol[7]
        //          << sgl_vol[8] << sgl_vol[9] << sgl_vol[10] << sgl_vol[11] << sgl_vol[12] << sgl_vol[13] << sgl_vol[14] << sgl_vol[15];
        if(MODBUS_ERR == ret_base83_106)
        {
            // qDebug() << "modbus no message";
            goto label;
        }
        else
        {
            // qDebug() << "5555555555555555555555555555";
            QByteArray sendArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->sendMsg), m_ModbusRTUDevice->sendMsgLen);
            emit sig_showModbusData_base_info83_106(sendArray, TypeSendData, base83_106);
            free(m_ModbusRTUDevice->sendMsg);
            QByteArray recvArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->recvMsg), m_ModbusRTUDevice->recvMsgLen);
            emit sig_showModbusData_base_info83_106(recvArray, TypeRecvData, base83_106);
            free(m_ModbusRTUDevice->recvMsg);
        }

        // qDebug() << "the current of the BMU is :" << BMUIndex;
        int volAddress = (1001 + BMUIndex * 16);
        int tempAddress = (1601 + BMUIndex * 16);
        // qDebug() << "volAddress: " << volAddress;
        // qDebug() << "tempAddress: " << tempAddress;
        // QElapsedTimer time;
        // time.start();
        // qDebug() << "#######" << sgl_vol[0] << sgl_vol[1] << sgl_vol[2] << sgl_vol[3] << sgl_vol[4] << sgl_vol[5] << sgl_vol[6] << sgl_vol[7]
        //          << sgl_vol[8] << sgl_vol[9] << sgl_vol[10] << sgl_vol[11] << sgl_vol[12] << sgl_vol[13] << sgl_vol[14] << sgl_vol[15];
        // int milsec = time.elapsed();
        // qDebug() <<"0.12311231" << milsec;

        int ret_vol = modbus_read_input_registers(m_ModbusRTUDevice, volAddress, 16, sgl_vol);
        if(MODBUS_ERR == ret_vol)
        {
            // qDebug() << "modbus no message";
            goto label;

        }
        else
        {
            QByteArray sendArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->sendMsg), m_ModbusRTUDevice->sendMsgLen);
            emit sig_showModbusData(sendArray, TypeSendData, sgl_vol);
            free(m_ModbusRTUDevice->sendMsg);
            QByteArray recvArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->recvMsg), m_ModbusRTUDevice->recvMsgLen);
            emit sig_showModbusData(recvArray, TypeRecvData, sgl_vol);
            free(m_ModbusRTUDevice->recvMsg);
        }
        // QThread::msleep(500);
        int ret_tempt = modbus_read_input_registers(m_ModbusRTUDevice, tempAddress, 16, sgl_tempt);
        if(MODBUS_ERR == ret_tempt)
        {
            // qDebug() << "modbus no message";
            goto label;
        }
        else
        {
            QByteArray sendArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->sendMsg), m_ModbusRTUDevice->sendMsgLen);
            emit sig_showModbusData_sgl_tempt(sendArray, TypeSendData, sgl_tempt);
            free(m_ModbusRTUDevice->sendMsg);
            QByteArray recvArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->recvMsg), m_ModbusRTUDevice->recvMsgLen);
            emit sig_showModbusData_sgl_tempt(recvArray, TypeRecvData, sgl_tempt);
            free(m_ModbusRTUDevice->recvMsg);
        }


    }
}


void ModbusRTU::write_regs_slot(int addr,const uint16_t data)
{
    // qDebug() << "write:进入线程：" << QThread::currentThread();
    int rc = write_single_register(addr, data);
    if(MODBUS_ERR == rc) {
        qDebug() << "######modbus no message";
        return;
    }
}

void ModbusRTU::read_regs_slot(int addr, int nb, uint16_t *data, int row)
{
    // qDebug() << "read:进入线程：" << QThread::currentThread();
    int rc = read_holding_register(addr, nb, data);
    if(MODBUS_ERR == rc) {
        // qDebug() << "modbus no message";
        return;
    }
    else {
        QByteArray recvArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->recvMsg), m_ModbusRTUDevice->recvMsgLen);
        emit sig_showReadHoldingRegs(recvArray, TypeRecvData, row, nb);
        free(m_ModbusRTUDevice->recvMsg);
    }
}

void ModbusRTU::change_BMUIndex_slot(int index)
{
    BMUIndex = index;
}


bool ModbusRTU::modbusRTUConnect(const char *comPort, int baudRate, char parity, int dataBit, int stopBit)
{
    qDebug() << "comPort:" << comPort << "baudRate:" << baudRate << "parity:" << parity << "dataBit" << dataBit << "stopBit:" << stopBit;
    m_ModbusRTUDevice = modbus_new_rtu(comPort, baudRate, parity, dataBit, stopBit);
    if(m_ModbusRTUDevice == NULL) {
        qDebug() << "create modbus device failed";
        return false;
    }
    else {
        qDebug() << "create modbus device success";
    }

    if (MODBUS_ERR == modbus_set_slave(m_ModbusRTUDevice, 1)
        || MODBUS_ERR == modbus_connect(m_ModbusRTUDevice)) {
        modbus_free(m_ModbusRTUDevice);
        qDebug() << "modbus disconnect";
        return false;
    }
    else {
        qDebug() << "modbus connect";
        modbus_set_debug(m_ModbusRTUDevice, false);
        return true;
    }
}

void ModbusRTU::modbusRTUDisconnect()
{
    modbus_close(m_ModbusRTUDevice);
}

int ModbusRTU::read_coil_status(int addr, int nb, uint8_t *dest)
{
    return modbus_read_bits(m_ModbusRTUDevice, addr, nb, dest);
}

int ModbusRTU::read_input_status(int addr, int nb, uint8_t *dest)
{
    return modbus_read_input_bits(m_ModbusRTUDevice, addr, nb, dest);
}

int ModbusRTU::read_holding_register(int addr, int nb, uint16_t *dest)
{
    return modbus_read_registers(m_ModbusRTUDevice, addr, nb, dest);
}

int ModbusRTU::read_input_register(int addr, int nb, uint16_t *dest)
{
    return modbus_read_input_registers(m_ModbusRTUDevice, addr, nb, dest);
}

int ModbusRTU::write_single_coil(int coil_addr, int status)
{
    return modbus_write_bit(m_ModbusRTUDevice, coil_addr, status);
}

int ModbusRTU::write_single_register(int reg_addr, const uint16_t value)
{
    return modbus_write_register(m_ModbusRTUDevice, reg_addr, value);
}

int ModbusRTU::write_multiple_coil(int addr, int nb, const uint8_t *data)
{
    return modbus_write_bits(m_ModbusRTUDevice, addr, nb, data);
}

int ModbusRTU::write_multiple_registers(int addr, int nb, const uint16_t *data)
{
    return modbus_write_registers(m_ModbusRTUDevice, addr, nb, data);
}