经过汇川AM403测试的Modbus Tcp 类的C++实现

已于 2024-06-20 14:23:31 修改
阅读量331 收藏 2
点赞数
文章标签： qt
于 2023-04-06 14:53:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zkmrobot/article/details/129989467
版权

1.头文件

#ifndef CMODBUSTCP_H
#define CMODBUSTCP_H

#include <QObject>
#include <QModbusTcpClient>

class QModbusClient;
class QModbusReply;

class CModbusTcp : public QObject
{
    Q_OBJECT

public:
    enum DATAFORMAT{
        INT_FORMAT = 0,
        FLOAT_FORMAT,
        STRING_FORMAT,
        BOOL_FORMAT,
        MAXDATA_FORMAT
    };
    Q_ENUM(DATAFORMAT)

public:
    explicit CModbusTcp(QObject *parent = nullptr);
    ~CModbusTcp();

    QString m_strReceived;
    QModbusClient *m_pmodbusDevice = nullptr;

private:
    bool bHexFormatEchoDisplay;     //flag whether the echo string is hex format, default is false
    bool bHexFormatDataSend;        //flag whether the data sent is hex format, default is true

    DATAFORMAT m_analysisDataFormat;

signals:
    void signalStateChanged(bool bConnected);

    void signalDataReceived(QString strDataReceived);

    //reserved for send original data
    void signalOriginalData(QModbusDataUnit responseData);

public slots:
    void onReadReady();
    void onModbusStateChanged(QModbusDevice::State state);

    void coilRead(int nStartAddress,uint16_t numbers,int ServerID);
    void coilWrite(int nStartAddress,QString strCoilToWrite,int ServerID);
    void discreteInputRead(int nStartAddress,uint16_t numbers,int ServerID);
    void inputRegisterRead(int nStartAddress,uint16_t numbers,int ServerID);
    void holdingRegsiterRead(int nStartAddress,uint16_t numbers,int ServerID, int nDataFormat);
    void holdingRegisterWrite(int nStartAddress,QString strHoldingRegisterToWrite,int ServerID, int nDataFormat);

    bool connect2Server(QString strIP = "127.0.0.1", QString strPort = "502");
    void disconnectFromServer();

private:
    QString getAnalysisReturnString(QModbusDataUnit responseData);

};

#endif // CMODBUSTCP_H

2.实现文件

#include "cmodbustcp.h"


#include <QThread>
#include <QDebug>

#define DELETE_AND_SET_NULL(pointer) if(pointer != nullptr) { delete pointer; pointer = nullptr;};
#define DELETE_AND_SET_NULL_ARRAY(pointer) if(pointer != nullptr) { delete[] pointer; pointer = nullptr;};

CModbusTcp::CModbusTcp(QObject *parent) :
    QObject(parent)
    ,bHexFormatEchoDisplay(false)
    ,bHexFormatDataSend(true)
{
    m_analysisDataFormat = INT_FORMAT;

    m_pmodbusDevice = new QModbusTcpClient(this);

    connect(m_pmodbusDevice, &QModbusClient::stateChanged,this, &CModbusTcp::onModbusStateChanged);
}

CModbusTcp::~CModbusTcp()
{
    DELETE_AND_SET_NULL(m_pmodbusDevice);
}

bool CModbusTcp::connect2Server(QString strIP, QString strPort)
{
    bool bRet= false;

    m_pmodbusDevice->setConnectionParameter(QModbusDevice::NetworkAddressParameter, strIP);
    m_pmodbusDevice->setConnectionParameter(QModbusDevice::NetworkPortParameter, strPort.toInt());
    m_pmodbusDevice->setTimeout(1000);
    m_pmodbusDevice->setNumberOfRetries(3);

    bRet = m_pmodbusDevice->connectDevice();
    if(bRet)
    {
        qDebug()<< "connect to PLC OK";
    } else {
        qDebug()<< "connect to PLC Fail";
    }

    return bRet;
}

void CModbusTcp::disconnectFromServer()
{
    if(m_pmodbusDevice) m_pmodbusDevice->disconnectDevice();
}

void CModbusTcp::coilRead(int nStartAddress,uint16_t numbers,int ServerID)
{
    if(m_pmodbusDevice)
    {
        QModbusDataUnit data(QModbusDataUnit::Coils, nStartAddress, numbers);
        auto reply = m_pmodbusDevice->sendReadRequest(data, ServerID);
        if(nullptr == reply)
        {
            qDebug() << "faile to send request data: " << m_pmodbusDevice->errorString();
        } else {
            if (!reply->isFinished())
            {
                connect(reply, &QModbusReply::finished, this, &CModbusTcp::onReadReady);

            }
            else
            {
                delete reply;
            }
        }
    }
}

void CModbusTcp::coilWrite(int nStartAddress,QString strCoilToWrite,int ServerID)
{
    if(m_pmodbusDevice)
    {
        int nstrLength = strCoilToWrite.length();
        if(nstrLength == 0)
        {
            qDebug() << "Warnning:Coil String to send is Null!";
            return;
        }

        QModbusDataUnit writeData(QModbusDataUnit::Coils, nStartAddress, (nstrLength >> 1) + (nstrLength & 1));

        for (uint i = 0; i < writeData.valueCount(); i++)
        {
            writeData.setValue(i, strCoilToWrite.at(2*i).unicode() - '0');
        }

        qDebug() << "data sent is: " << writeData.values();

        QModbusReply* reply = m_pmodbusDevice->sendWriteRequest(writeData, ServerID);
        if (reply)
        {
            if (!reply->isFinished())
            {
                connect(reply, &QModbusReply::finished, this, [this, reply](){
                    if (reply->error() == QModbusDevice::ProtocolError)
                    {
                        qDebug() << "data written error: " << reply->errorString();
                    }
                    else if (reply->error() != QModbusDevice::NoError)
                    {
                        qDebug() << "data written error: " << reply->errorString();
                    }
                    else
                    {
                        const QModbusDataUnit data = reply->result();

                        qDebug() << "data written: " << data.values();

                        m_strReceived = "";
                        for(auto value: data.values())
                        {
                            m_strReceived += tr("%1 ").arg(value);
                        }

                        emit signalDataReceived(m_strReceived);

                    }

                    reply->deleteLater();
                });
            }
            else
            {
                reply->deleteLater();
            }
        }
        else
        {
            qDebug() << "sendWriteRequest Error: " << reply->errorString();
        }
    }
}

void CModbusTcp::discreteInputRead(int nStartAddress,uint16_t numbers,int ServerID)
{
    if(m_pmodbusDevice)
    {
        QModbusDataUnit data(QModbusDataUnit::DiscreteInputs, nStartAddress, numbers);

        auto reply = m_pmodbusDevice->sendReadRequest(data, ServerID);
        if (nullptr == reply)
        {
            qDebug() << "fail to send data: " << m_pmodbusDevice->errorString();
        }
        else
        {
            if (!reply->isFinished())
            {
                connect(reply, &QModbusReply::finished, this, &CModbusTcp::onReadReady);
            }
            else
            {
                delete reply;
            }
        }
    }
}

void CModbusTcp::inputRegisterRead(int nStartAddress,uint16_t numbers,int ServerID)
{
    if(m_pmodbusDevice)
    {
        QModbusDataUnit data(QModbusDataUnit::InputRegisters, nStartAddress, numbers);

        QModbusReply* reply = m_pmodbusDevice->sendReadRequest(data, ServerID);
        if (nullptr == reply)
        {
            qDebug() << "failed to send data: " << m_pmodbusDevice->errorString();
        }
        else
        {
            qDebug() << "input register Read command have sent";

            if (!reply->isFinished())
            {
                qDebug() << "input register Read command is running";
                connect(reply, &QModbusReply::finished, this, &CModbusTcp::onReadReady);
            }
            else
            {
                qDebug() << "input register Read command immediately reply";
                delete reply;
            }
        }
    }
}

void CModbusTcp::holdingRegsiterRead(int nStartAddress,uint16_t numbers,int ServerID, int nDataFormat)
{
    assert((nDataFormat >=0) && (nDataFormat < MAXDATA_FORMAT));

    m_analysisDataFormat = DATAFORMAT(nDataFormat);

    if(m_pmodbusDevice)
    {
        QModbusDataUnit data(QModbusDataUnit::HoldingRegisters, nStartAddress, numbers);

        auto reply = m_pmodbusDevice->sendReadRequest(data, ServerID);
        if (nullptr == reply)
        {
            qDebug() << "failed to send request data: " << m_pmodbusDevice->errorString();
        }
        else
        {
            if (!reply->isFinished())
            {
                connect(reply, &QModbusReply::finished, this, &CModbusTcp::onReadReady);
            }
            else
            {
                delete reply;
            }
        }
    }
}

void CModbusTcp::holdingRegisterWrite(int nStartAddress,QString strHoldingRegisterToWrite,int ServerID, int nDataFormat)
{
    assert((nDataFormat >=0) && (nDataFormat < MAXDATA_FORMAT));

    m_analysisDataFormat = DATAFORMAT(nDataFormat);

    if(m_pmodbusDevice)
    {
        QModbusDataUnit writeData;

        if (nDataFormat == INT_FORMAT)
        {
            writeData = QModbusDataUnit(QModbusDataUnit::HoldingRegisters, nStartAddress, 1);
            writeData.setValue(0,strHoldingRegisterToWrite.toUShort());

        } else if (nDataFormat == FLOAT_FORMAT) {
            writeData = QModbusDataUnit(QModbusDataUnit::HoldingRegisters, nStartAddress, 2);
            float fData = strHoldingRegisterToWrite.toFloat();
            unsigned char* p = (unsigned char*)&fData;
            writeData.setValue(0, *p | *(p+1) << 8);
            writeData.setValue(1, *(p+2) | *(p+3) << 8);

        } else if (nDataFormat == STRING_FORMAT) {
            int nDataLength = (strHoldingRegisterToWrite.length() >> 1) + (strHoldingRegisterToWrite.length() & 1);
            writeData = QModbusDataUnit(QModbusDataUnit::HoldingRegisters, nStartAddress, nDataLength);

            for (uint i = 0; i < writeData.valueCount(); i++) {
                char tmpChar1 = strHoldingRegisterToWrite.at(2*i).toLatin1();
                char tmpChar2 = 0;
                if(2*i + 1 <= strHoldingRegisterToWrite.length() - 1 )
                {
                    tmpChar2 = strHoldingRegisterToWrite.at(2*i + 1).toLatin1();
                }
                writeData.setValue(i, tmpChar2 <<8 | tmpChar1);
            }
        } else if (nDataFormat == BOOL_FORMAT) {
            writeData = QModbusDataUnit(QModbusDataUnit::HoldingRegisters, nStartAddress, 1);
            writeData.setValue(0,strHoldingRegisterToWrite.toUInt());
        }

        QModbusReply* reply = m_pmodbusDevice->sendWriteRequest(writeData, ServerID);
        if (reply)
        {
            if (!reply->isFinished())
            {
                connect(reply, &QModbusReply::finished, this, [this, reply](){
                    if (reply->error() == QModbusDevice::ProtocolError)
                    {
                        qDebug() << "data written error: " << reply->errorString();
                    }
                    else if (reply->error() != QModbusDevice::NoError)
                    {
                        qDebug() << "data written error: " << reply->errorString();
                    }
                    else
                    {
                        const QModbusDataUnit data = reply->result();

                        //solution1: send the analysis result string
                        getAnalysisReturnString(data);
                        emit signalDataReceived(m_strReceived);

                        //soltion2: send orignal data
                        //emit signalOriginalData(data);
                    }

                    reply->deleteLater();
                });
            }
            else
            {
                reply->deleteLater();
            }
        }
        else
        {
            qDebug() << "sendWriteRequest Error: " << reply->errorString();
        }
    }
}

void CModbusTcp::onReadReady()
{
    auto reply = qobject_cast<QModbusReply*>(sender());
    if (nullptr == reply)
    {
        return;
    }

    if (reply->error() == QModbusDevice::NoError)
    {
        const QModbusDataUnit responseData = reply->result();

        //方案1：发送解析过的数据
        getAnalysisReturnString(responseData);
        emit signalDataReceived(m_strReceived);

        //方案2：发送原始数据包，由界面GUI解析
        //emit signalOriginalData(responseData);

    }
    else if (reply->error() == QModbusDevice::ProtocolError)
    {
        qDebug() << "Read response Protocol error: " << reply->errorString();
    }
    else
    {
        qDebug() << "Read response Error: " << reply->errorString();
    }

    reply->deleteLater();
}

void CModbusTcp::onModbusStateChanged(QModbusDevice::State state)
{
    bool bConnected=false;
    if(state == QModbusDevice::ConnectedState)
    {
        bConnected=true;
    }
    else
    {
        bConnected=false;
    }

    emit signalStateChanged(bConnected);
}

QString CModbusTcp::getAnalysisReturnString(QModbusDataUnit responseData)
{
    quint16 highword;
    quint16 lowword;
    char tmpCharArrays[4];
    float *pFloat;
    float ftemp;

    m_strReceived = "";

    switch (m_analysisDataFormat) {
    case INT_FORMAT:
        m_strReceived += tr("%1 ").arg(responseData.values()[0]);
        break;
    case FLOAT_FORMAT:
        highword = responseData.values()[0];
        lowword = responseData.values()[1];

        tmpCharArrays[0] = highword & 0xff;
        tmpCharArrays[1] = (highword >>8) & 0xff;
        tmpCharArrays[2] = lowword & 0xff;
        tmpCharArrays[3] = (lowword >>8) & 0xff;

        pFloat = (float*)&tmpCharArrays[0];

        ftemp = *pFloat;

        m_strReceived += tr("%1 ").arg(ftemp);

        break;

    case STRING_FORMAT:
        char chTmp1;
        char chTmp2;
        for(auto value: responseData.values())
        {
            chTmp1 = value & 0xff;
            chTmp2 = (value >> 8) & 0xff;
            m_strReceived += tr("%1%2").arg(chTmp1).arg(chTmp2);
        }

        break;
    case BOOL_FORMAT:
        m_strReceived += tr("%1 ").arg(responseData.values()[0]);
        break;

    default:
        qDebug() << "NOT SUPPORTED DATA FORMAT!!!";
        break;
    }

    return m_strReceived;

}

CoderIsArt
关注
汇川PLC AM600、AC800系列Modbus TCP通讯案例（PLC和C++源码）
汪蛋的博客
01-03 2万+
汇川PLC AM600、AC800系列Modbus TCP通讯案例（PLC和C++源码）
基于C++实现Modbus TCP通信的详细指南
m0_57781768的博客
06-16 1905
Modbus协议是一种主从通信协议，最早由Modicon公司（现在是施耐德电气的一部分）在1979年开发。它被设计用于在控制器和设备之间传输数据。Modbus协议分为多种变体，其中Modbus TCP是使用最广泛的一种，它通过TCP/IP网络进行数据传输。本文详细介绍了如何在C++中实现Modbus TCP通信。从基础概念到具体实现，包括创建TCP客户端和服务器，构建和解析Modbus帧，处理并发请求和常见问题的解决方案。
汇川PLC与C++上位机高效通信解决方案：AM600/AC800系列Modbus TCP通讯源码推荐
最新发布
gitblog_09780的博客
09-07 566
汇川PLC与C++上位机高效通信解决方案：AM600/AC800系列Modbus TCP通讯源码推荐 项目地址:https://gitcode.com/open-source-toolkit/478ce 项目介绍 在工业自动化领域，汇川技术的AM600系列和AC800系列PLC因其高性能和可靠性而备受青睐。然而，如何高效地实现这些PLC与上位机之间的通信，一直是开发者面临的挑战。为了解决这一问题，...
c++ modbusTCP
weixin_39926429的博客
06-09 4533
/Modbus TCP是一种基于TCP/IP协议的Modbus协议，它允许Modbus协议通过以太网进行通信。//在C++中，可以使用第三方库来实现Modbus TCP通信，例如libmodbus和QModbus。// 断开Modbus连接并释放上下文。// 创建Modbus TCP上下文。// 创建Modbus TCP客户端。// 连接到Modbus从设备。// 连接到Modbus从设备。// 读取Modbus寄存器。// 读取Modbus寄存器。// 打印读取到的寄存器值。
MODBUS TCP 的C++源码
09-28
MODBUS TCP 的C++源码，很珍贵的哦
ModbusTCP连接C++源码
04-26
上网找了好久的MFCModbusTCP连接代码，再VS2010中调试成功，可以自己拿过来用。里面中文注释写的也比较详细
c++编写modbusTCP/ip协议远程读写服务器
matewang的博客
12-28 978
自己根据网络编程知识模拟客户端多线程远程读写modbus slave
AM600系列、AC800系列 Modbus TCP通讯成功程序源码.zip
01-03
AM600系列和AC800系列是汇川技术推出的两种中型PLC产品，它们支持Modbus TCP通信协议，使得这些设备能够与各种上位机或控制系统进行高效的数据交换。Modbus TCP是一种广泛应用于工业自动化领域的网络通信协议，它...
php modbus tcp实例,汇川PLC AM600、AC800系列Modbus TCP通讯案例（PLC和C++源码）
weixin_35182991的博客
04-08 3332
网址分享：汇川官方论坛，有问题可以来这里提问：http://bbs.inovance.com/forum.php?gid=36汇川官网视频教程，很详细：http://www.inovance.cn/support/share_issue.html汇川官方资料下载地址：http://www.inovance.cn/support/download.html推荐汇川相关博客，内容很丰富：http://...
ModbusTCP与上位机通讯源码
11-07
本主题主要探讨的是如何使用Modbus TCP协议在C#和C++语言中实现与上位机的通讯，并且特别提到了支持汇川品牌的PLC。 1. **Modbus协议概述** Modbus协议最初由Modicon公司（现Schneider Electric的一部分）开发，是...
C#编成Modbus TCP连接各种PLC读取写入寄存器源码
01-08
资源名：C#编成Modbus TCP连接各种PLC读取写入寄存器源码 资源类型：程序源代码 源码说明： C#编成Modbus TCP连接PLC寄存器读取、写入，完整分享源代码，有需要的人可以下载 适合人群：新手及有一定经验的开发人员
C++编写基于TCP/IP的Modbus网络通讯工具源码
03-13
用C++编写的基于TCP/IP的Modbus网络通讯工具源码，据参考价值。
modbuspp：用于Modbus TCP协议的C ++库
01-30
modbuspp：用于Modbus TCP协议的C ++库
c++ tcp\ip,Modbus tcp\ip通讯，源码
12-21
tcp\ip网络通讯(发送和接收)， Modbus tcp\ip(int ,short,float数据寄存器读写)，客户端。 使用Demo，源码...
Windows和Linux下的C++ Modbus tcp资源大全
05-14
包含如下内容： 中文版Modbus通信协议说明 C++开发的Windows开发实例 C++开发的Linux开发实例 有多种实现方式 都能通过编译
C++ Modbus Tcp 通讯程序
11-17
1、多线程后台批量寄存器状态读取，避免接口获取卡顿问题 2、高效稳定，使用方便。 3、程序开源，具有较好的学习内容。
C++ ModBUS TCP客户端
闲人的专栏
07-05 1万+
https://sourceforge.net/projects/qmodmaster/   用Qt写的一个客户端。非常小巧，非常好用。平台通用。内部有一个文件夹libmodbus，可以借来用用。 在github上找了一下都没找到这么好的东西。      ...
ModbusTCP协议通信 C++实现源码举例
热门推荐
Basic的个人博客
03-03 1万+
因项目需求研究了一下Modbus协议，用C++实现了简单的Modbus协议报文组织 Modbus协议允许在TCP连接下实现通信，使用ws2_32这个socket支持库，写法是普遍的网络编程TCP客户端连接写法 在Windows环境下，C++的TCP连接发起部分代码：作为主机（客户端），主动连接从机（服务端） WORD version = MAKEWORD(2, 2); WSADATA data; if (SOCKET_ERROR == WSAStartup(version, &data))
C++客户端Modbus通信（TCP主站）
qq_45220555的博客
11-30 7634
本文简单介绍Qt使用外部modbus通信C++编程流程 modbus中文手册：https://blog.csdn.net/qq_23670601/article/details/82155378 Qtmodbus较为方便，建议无特殊情况可以使用qtmodbus，为何不使用Qt自带QModbus呢？原因是我在编写modbus主站的时候需要创建一个线程监听从站的数据，创建线程的时候出现为不同线程的父线程创建子线程的报错，个人解决不了。 modbus通信编程流程 1.搭建modbus环境 在pro工程项目中添加头
汇川am403plc作为modbustcp主站通讯实例
09-06
汇川AM403PLC是一种常用的工业自动化控制设备，具备Modbus TCP通讯协议的主站功能。作为主站，AM403PLC可以与其他支持Modbus TCP协议的设备建立通讯链路，实现数据的读取和写入。 在建立通讯链路之前，首先需要配置和设置AM403PLC的网络参数，包括IP地址、子网掩码和网关等。确保与其他设备在同一个网络中。然后，在AM403PLC的编程软件中，编写相应的程序来实现Modbus TCP通讯。 具体的通讯步骤如下： 1. 创建通讯对象：在编程软件中创建一个Modbus TCP通讯对象，设置好通讯协议、IP地址和通讯端口等参数。 2. 建立连接：通过调用相应的函数或指令，将通讯对象与目标设备建立连接。这一步骤会自动进行TCP握手等通讯协议的处理，确保连接的可靠性。 3. 数据读取和写入：通过调用相应的函数或指令，实现数据的读取和写入操作。可以根据需要，读取其他设备的数据，或者将数据写入其他设备。 4. 关闭连接：通讯完成后，需要通过调用相应的函数或指令，关闭与目标设备的连接。这样可以释放资源，并确保通讯的正常结束。 需要注意的是，对于Modbus TCP通讯，需严格遵守通讯协议的规定，包括数据传输格式、寄存器地址的定义等。同时，在编写程序时，需要考虑到通讯的可靠性和实时性，以及异常情况的处理等。 总之，汇川AM403PLC作为Modbus TCP主站通讯实例，可以通过配置网络参数、建立连接、数据读写等步骤来实现与其他设备的通讯。这为工业自动化控制系统的设计和实现提供了一种可靠的通讯方式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值