C++基于开源Modbus Tcp 通讯应用客户端（稳定高效，多线程后台状态读取，不卡顿）

最新推荐文章于 2024-08-09 16:46:42 发布
最新推荐文章于 2024-08-09 16:46:42 发布
阅读量5.1k 收藏 30
点赞数 4
分类专栏： C++ Qt 文章标签： c++ tcp/ip 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013083044/article/details/127912703
版权
Qt 同时被 2 个专栏收录
75 篇文章 34 订阅
订阅专栏
C++
25 篇文章 6 订阅
订阅专栏

C++基于开源Modbus Tcp 通讯应用客户端

前言

使用多线程后台批量刷寄存器的状态，在某种程度上保证了上层接口读取的时候，不会卡顿，
整体应用效果比较友好。程序应用简单稳定高效，是一个比较不错的尝试。

一、演示效果

请添加图片描述

二、关键程序

1.头文件

代码如下：

#pragma once
#include "modbustcpclient_global.h"
#include <QObject>
#include <QThread>
#include <QHash>
#include <QMutexLocker>
#include <QMutex>

namespace YModbus {
	class Master;
};

class MODBUSTCPCLIENT_EXPORT cModbusItem : public QThread
{
	Q_OBJECT

public:
	cModbusItem(QObject *parent = 0);
	~cModbusItem();
public:
	bool connect(QString strIp, int nPort);
	bool isConnected();
	void setServerId(int nId);
	int getServerId();

	void release();

	bool getBit(uint16_t uAddr, uint16_t uBit);
	bool readRegister16(uint16_t uAddr, uint16_t &uValue);
	bool readRegister32(uint16_t uAddr, uint32_t &uValue);
	bool readCoil(uint16_t uAddr);

	bool setBit(uint16_t uAddr, uint16_t uBit, bool bState);
	bool writeRegister16(uint16_t uAddr, uint16_t uValue);
	bool writeRegister32(uint16_t uAddr, uint32_t uValue);
	bool writeCoil(uint16_t uAddr, bool bState);

private:
	void addValueCoilsHash(uint16_t uAddr);
	void addValueHoldingRegistersHash(uint16_t uAddr);

private:
	bool ctxReadRegister(uint16_t nStartAddress, int nNum);
	bool ctxReadCoil(uint16_t nStartAddress, int nNum);

	bool ctxWriteRegister(uint16_t nStartAddress, uint16_t uValue);
	bool ctxWriteCoil(uint16_t nStartAddress, bool bState);

protected:
	void run() override;

private:

	bool m_bConnected;
	bool m_bAppClose;
	bool m_bWriteRequestState;
	bool m_bReadRequestState;
	bool m_bReadNext;
	int m_nServerID;

	QString m_strIp;
	int m_nPort;
	QMutex m_mutex;
	YModbus::Master *m_pMaster;

private:
	QHash<uint16_t, uint16_t> m_readValueHoldingRegistersHash;
	QHash<uint16_t, uint16_> m_readAddrHoldingRegistersHash;

	QHash<uint16_t, uint16_t> m_readValueCoilsHash;
	QHash<uint16_t, uint16_t> m_readAddrCoilsHash;
};

2.源文件

代码如下：

#include "ModbusItem.h"
#include "ymblog.h"
#include "Ymod/ymbutils.h"
#include "Ymod/ymbtask.h"
#include "Ymod/ymbdefs.h"
#include "Ymod/Master/ymbmaster.h"
#include "Ymod/Master/ymaster.h"

#include <QVariant>
#include <QDebug>
#include <QTime>
#include <QVector>
#include <QTimer>
#define  COILS_READ_COUNT			       100
#define  HOLDING_REGISTERS_READ_COUNT	   100

struct sModbusTimer
{
	QTime time;
	uint32_t interval;

	void start(uint32_t t)
	{
		interval = t;
		time.restart();
	};

	bool isTimeOut()
	{
		return time.elapsed() > interval;
	};
};

cModbusItem::cModbusItem(QObject *parent)
	: QThread(parent)
	, m_bConnected(false)
	, m_bAppClose(false)
	, m_bWriteRequestState(false)
	, m_bReadRequestState(false)
	, m_bReadNext(true)
	, m_nServerID(1)
	, m_strIp("")
	, m_nPort(-1)
	, m_pMaster(nullptr)
{
	this->start();
}

cModbusItem::~cModbusItem()
{
	m_bAppClose = true;

	QThread::msleep(100);
}

void cModbusItem::run()
{
	static sModbusTimer timeout;
	static int nMainStep = 0;
	while (true)
	{
		if (m_bAppClose)
			return;

		switch (nMainStep)
		{
		case 0:
		{
			if (m_bConnected)
				nMainStep = 1;
			else
				QThread::msleep(500);

		}break;

		case 1:
		{
			if (true)
			{
				static int nIndex = 0;
				QHash<uint16_t, uint16_t> readAddrHoldingRegistersHashTemp;
				readAddrHoldingRegistersHashTemp = m_readAddrHoldingRegistersHash;
				auto keys = readAddrHoldingRegistersHashTemp.keys();

				if (keys.size() > 0)
				{
					nIndex = nIndex < keys.size() ? nIndex : 0;
					uint16_t uAddr = keys[nIndex];
					int nRead = uAddr - (HOLDING_REGISTERS_READ_COUNT / 2);

					// 从中间覆盖读取
					ctxReadRegister(nRead < 0 ? 0 : nRead, readAddrHoldingRegistersHashTemp[uAddr]);
					nIndex++;
				}

			}

			if (true)
			{
				static int nIndex = 0;
				QHash<uint16_t, uint16_t> readAddrCoilsHashTemp;
				readAddrCoilsHashTemp = m_readAddrCoilsHash;
				auto keys = readAddrCoilsHashTemp.keys();

				if (keys.size() > 0)
				{
					nIndex = nIndex < keys.size() ? nIndex : 0;
					uint16_t uAddr = keys[nIndex];

					// 从中间覆盖读取
					int nRead = uAddr - COILS_READ_COUNT / 2;
					ctxReadCoil(nRead < 0 ? 0 : nRead, readAddrCoilsHashTemp[uAddr]);
					nIndex++;
				}

			}

		}break;

		default:
			break;
		}
	}
}

// 连接
bool cModbusItem::connect(QString strIp, int nPort)
{
	if (m_bConnected)
		return true;

	char *chIp;
	QByteArray ba = strIp.toLatin1();
	chIp = ba.data();

	m_pMaster = new YModbus::Master(chIp, nPort, YModbus::TCP, YModbus::POLL);

	if (!m_pMaster->CheckConnect())
	{
		m_bConnected = false;
		delete m_pMaster;
		m_pMaster = nullptr;
	}
	else
	{
		m_bConnected = true;
	}

	m_strIp = strIp;
	m_nPort = nPort;

	return m_bConnected;
}

// 是否连接
bool cModbusItem::isConnected()
{
	return m_bConnected;
}

void cModbusItem::setServerId(int nId)
{
	m_nServerID = nId;
}

int cModbusItem::getServerId()
{ 
	return m_nServerID; 
}

void cModbusItem::release()
{
	m_bAppClose = true;

	QThread::msleep(30);

}

// 读取16位值
bool cModbusItem::readRegister16(uint16_t uAddr, uint16_t &uValue)
{
	if (!m_bConnected)
		return false;
	
	// 如果值读取哈希链表没有找到，需要插入到地址哈希链表，让它在后台读取
	auto itFind = m_readValueHoldingRegistersHash.find(uAddr);
	if (itFind == m_readValueHoldingRegistersHash.end())
	{
		m_readAddrHoldingRegistersHash[uAddr] = HOLDING_REGISTERS_READ_COUNT;

		if (true)
		{
			// 如果没有就先读取一次
			QHash<uint16_t, uint16_t> readAddrHoldingRegistersHashTemp;
			readAddrHoldingRegistersHashTemp = m_readAddrHoldingRegistersHash;
			int nRead = uAddr - (HOLDING_REGISTERS_READ_COUNT / 2);
			ctxReadRegister(nRead < 0 ? 0 : nRead, readAddrHoldingRegistersHashTemp[uAddr]);

			auto itFindItem = m_readValueHoldingRegistersHash.find(uAddr);
			if (itFindItem == m_readValueHoldingRegistersHash.end())
				return false;
			else
				uValue = m_readValueHoldingRegistersHash[uAddr];
		}
	}
	else
	{
		// 找到值，直接返回
		uValue = m_readValueHoldingRegistersHash[uAddr];
	}

	return true;
}

// 读取32位值
bool cModbusItem::readRegister32(uint16_t uAddr, uint32_t &uValue)
{
	if (!m_bConnected)
		return false;

	bool bRet = false;
	uint16_t uData16[2] = { 0 };
	bRet = readRegister16(uAddr, uData16[0]);
	bRet = readRegister16(uAddr + 1, uData16[1]);

	uValue = uData16[0]  | (uData16[1] << 16);

	return bRet;
}

// 获取位值
bool cModbusItem::getBit(uint16_t uAddr, uint16_t uBit)
{
	if (!m_bConnected)
		return false;

	uint16_t uValue = 0;
	readRegister16(uAddr, uValue);

	return uValue & (1 << (uBit % 16));
}

// 读取线圈值
bool cModbusItem::readCoil(uint16_t uAddr)
{
	bool bResult = false;
	uint16_t uValue = 0;

	auto itFind = m_readValueCoilsHash.find(uAddr);
	if (itFind == m_readValueCoilsHash.end())
	{
		m_readAddrCoilsHash[uAddr] = COILS_READ_COUNT;

		if (true)
		{
			QHash<uint16_t, uint16_t> readAddrCoilsHashTemp;
			readAddrCoilsHashTemp = m_readAddrCoilsHash;

			// 从中间覆盖读取
			int nRead = uAddr - COILS_READ_COUNT / 2;
			ctxReadCoil(nRead < 0 ? 0 : nRead, readAddrCoilsHashTemp[uAddr]);

			auto itFindItem = m_readValueCoilsHash.find(uAddr);
			if (itFindItem == m_readValueCoilsHash.end())
				bResult = false;
			else
				uValue = m_readValueCoilsHash[uAddr];

		}

		bResult = false;
	}
	else
		uValue = m_readValueCoilsHash[uAddr];

	if (true)
	{
		int nAddrSize = m_readAddrCoilsHash.size();
		int nValueSize = m_readValueCoilsHash.size();
	}

	uValue == 1 ? bResult = true : bResult = false;
	
	return bResult;
}

// 设置位值
bool cModbusItem::setBit(uint16_t uAddr, uint16_t uBit, bool bState)
{
	bool bRet = false;

	uint16_t uValue = 0;
	bRet = readRegister16(uAddr, uValue);

	if (bRet)
	{
		if (bState)
			uValue |= (1 << (uBit % 16));	 // 把某位置1
		else
			uValue &= ~(1 << (uBit % 16));	 // 把某位置0

		writeRegister16(uAddr, uValue);
	}

	return bRet;
}

// 写入16位值
bool cModbusItem::writeRegister16(uint16_t uAddr, uint16_t uValue)
{
	bool bRet = true;
	ctxWriteRegister(uAddr, uValue);
	return bRet;
}

// 写入32位值
bool cModbusItem::writeRegister32(uint16_t uAddr, uint32_t uValue)
{
	bool bRet = false;

	uint16_t uData16[2] = {0};
	uData16[0] = uValue & 0Xffff;
	uData16[1] = (uValue >> 16) & 0Xffff;

	bRet = writeRegister16(uAddr, uData16[0]);
	bRet = writeRegister16(uAddr+1, uData16[1]);

	return bRet;
}

// 写入线圈值
bool cModbusItem::writeCoil(uint16_t uAddr, bool bState)
{
	ctxWriteCoil(uAddr, bState);
	
	return true;
}

// 添加线圈数据列表
void cModbusItem::addValueCoilsHash(uint16_t uAddr)
{
	int nAddrStart = uAddr - (COILS_READ_COUNT / 2);
	if (nAddrStart < 0)
		nAddrStart = 0;

	//	提前添加数据列表，避免重复查询
	for (size_t i = 0; i < COILS_READ_COUNT; i++)
	{
		m_readValueCoilsHash[nAddrStart + i] = 0;
	}
}

// 添加保持寄存器数据列表
void cModbusItem::addValueHoldingRegistersHash(uint16_t uAddr)
{
	int nAddrStart = uAddr - (HOLDING_REGISTERS_READ_COUNT / 2);
	if (nAddrStart < 0)
		nAddrStart = 0;

	//	提前添加数据列表，避免重复查询
	for (size_t i = 0; i < HOLDING_REGISTERS_READ_COUNT; i++)
	{
		m_readValueHoldingRegistersHash[nAddrStart + i] = 0;
	}
}

//	读取寄存器
bool cModbusItem::ctxReadRegister(uint16_t nStartAddress, int nNum)
{
	if (!m_bConnected || m_pMaster == nullptr)
		return false;

	m_mutex.lock();
	static uint8_t buf[BUFSIZ] = { 0 };
	memset(buf, 0, sizeof(buf));
	int nLen;

	nLen = m_pMaster->ReadHoldingRegisters(m_nServerID, nStartAddress, nNum, buf, sizeof(buf));
	if (nLen == (nNum*2) && nLen != 0)
	{
		QList<uint16_t> uReadDataList;
		for (int i = 0; i < nLen; i++)
		{
			if ((i %2) ==0 )
			{
				uint16_t uValue = (buf[i] << 8) | buf[i+1];
				uReadDataList << uValue;
			}

		}
		//	写入数据哈希表
		for (size_t i = 0; i < uReadDataList.size(); i++)
		{

			m_readValueHoldingRegistersHash[nStartAddress + i] = uReadDataList[i];
		}
	}
	
	m_mutex.unlock();
	return true;
}

//	读取线圈
bool cModbusItem::ctxReadCoil(uint16_t nStartAddress, int nNum)
{
	if (!m_bConnected || m_pMaster == nullptr)
		return false;

	m_mutex.lock();
	static uint8_t buf[BUFSIZ] = { 0 };
	memset(buf, 0, sizeof(buf));
	int nLen;

	nLen = m_pMaster->ReadCoils(m_nServerID, nStartAddress, nNum, buf, sizeof(buf));
	if (nLen > 0)
	{
		QList<uint16_t> uReadDataList;
		for (int i = 0; i < nLen; i++)
		{
			uint16_t uValue = buf[i];
			uReadDataList << uValue;
		}
		//	写入数据哈希表
		for (size_t i = 0; i < nNum; i++)
		{
			int nIndex = i / 8;
			if (nIndex >= 0 && nIndex < uReadDataList.size())
			{
				int nBit = i - (8)*nIndex;
				if (nBit >= 0 && nBit < 8)
				{
					uint16_t uValue = (uReadDataList[nIndex] & (1 << nBit)) > 0 ? 1 : 0;
					m_readValueCoilsHash[nStartAddress + i] = uValue;
				}
			}
		}
	}

	m_mutex.unlock();
	return true;
}

bool cModbusItem::ctxWriteRegister(uint16_t nStartAddress, uint16_t uValue)
{
	m_mutex.lock();
	int nLen = m_pMaster->WriteSingleRegister(m_nServerID, nStartAddress, uValue);
	m_mutex.unlock();
	return true;
}

bool cModbusItem::ctxWriteCoil(uint16_t nStartAddress, bool bState)
{
	m_mutex.lock();
	int nLen = m_pMaster->WriteSingleCoil(m_nServerID, nStartAddress, bState);
	m_mutex.unlock();
	return true;
}

三、下载链接

https://download.csdn.net/download/u013083044/87062401

请添加图片描述

进击的大海贼
关注
专栏目录
ModbusTCP连接C++源码
04-26
上网找了好久的MFCModbusTCP连接代码，再VS2010中调试成功，可以自己拿过来用。里面中文注释写的也比较详细
MODBUS TCP 的C++源码
09-28
MODBUS TCP 的C++源码，很珍贵的哦
C++ Modbus Tcp 通讯程序
11-17
1、多线程后台批量寄存器状态读取，避免接口获取卡顿问题 2、高效稳定，使用方便。 3、程序开源，具有较好的学习内容。
c++ modbusTCP
weixin_39926429的博客
06-09 4383
/Modbus TCP是一种基于TCP/IP协议的Modbus协议，它允许Modbus协议通过以太网进行通信。//在C++中，可以使用第三方库来实现Modbus TCP通信，例如libmodbus和QModbus。// 断开Modbus连接并释放上下文。// 创建Modbus TCP上下文。// 创建Modbus TCP客户端。// 连接到Modbus从设备。// 连接到Modbus从设备。// 读取Modbus寄存器。// 读取Modbus寄存器。// 打印读取到的寄存器值。
C++配置和使用modbus库时常见问题解决方法
最新发布
m0_52939006的博客
08-09 253
介绍了配置modbus库时遇到的一些问题以及解决方法
ModBus协议原理、Modbus Slave以及基于C++和Qt的代码实现
认真努力，做一只会飞的毛毛虫。
07-23 1999
包含有：0x01 读继电器/线圈、0x05 写继电器/线圈、0x0F 写多个继电器/线圈、0x02 读离散量输入、0x04 读输入寄存器、0x03 读保持寄存器数据、0x06 写单个保持寄存器、0x10 写多个保持寄存器。事务处理标识+协议标识符+长度+设备地址+功能码+两个字节的起始地址+两个字节的读取个数。事务处理标识+协议标识符+长度+设备地址+功能码+两个字节的地址+两个字节的读取个数。事务处理标识+协议标识符+长度+设备地址+功能码+两个字节的地址+两个字节的读取个数。读取保持寄存器的帧结构，
Qt/C++编写物联网组件/支持modbus/rtu/tcp/udp/websocket/mqtt/多线程采集
Qt/C++视频监控/推流/物联网/大屏系统/自定义控件/UI定制/输入法
10-16 2542
1. 支持多种协议，包括Modbus_Rtu_Com/Modbus_Rtu_Tcp/Modbus_Rtu_Udp/Modbus_Rtu_Web/Modbus_Tcp/Modbus_Udp/Modbus_Web等，其中web指websocket。 2. 支持多种采集通讯方式，包括串口和网络等，可自由拓展其他方式。 3. 自定义采集间隔（精确到毫秒）和超时次数，超时后自动将离线的文件从轮询队列中移除，加快轮询速度。 4. 自定义整体轮询间隔，将离线的设备重新探测一次，保证设备恢复正常后能够重新加入轮询队列。
c++编写modbusTCP/ip协议远程读写服务器
matewang的博客
12-28 921
自己根据网络编程知识模拟客户端多线程远程读写modbus slave
简单的Modbus/TCP客户端，包含写寄存器函数#C++
热门推荐
sheldon0227的博客
10-21 1万+
modbus-TCP 协议文档：http://wenku.baidu.com/link?url=ImagoC3DE1p0D55S7qbzXrSaQ4wbaY93gB3kEmPiHx_CnnNsrdkz1vYA93uTBtvmbzxhRrcBoPc8YNl9UqJqlRAV1r3Tm2tYoOfdTU1zcVG 简单来说就是吧modbus RTU的报文做修改后使用TCP协议传输，通常modbu
C++ ModBUS TCP客户端
闲人的专栏
07-05 1万+
https://sourceforge.net/projects/qmodmaster/   用Qt写的一个客户端。非常小巧，非常好用。平台通用。内部有一个文件夹libmodbus，可以借来用用。 在github上找了一下都没找到这么好的东西。      ...
C++客户端Modbus通信（TCP主站）
qq_45220555的博客
11-30 7598
本文简单介绍Qt使用外部modbus通信C++编程流程 modbus中文手册：https://blog.csdn.net/qq_23670601/article/details/82155378 Qtmodbus较为方便，建议无特殊情况可以使用qtmodbus，为何不使用Qt自带QModbus呢？原因是我在编写modbus主站的时候需要创建一个线程监听从站的数据，创建线程的时候出现为不同线程的父线程创建子线程的报错，个人解决不了。 modbus通信编程流程 1.搭建modbus环境 在pro工程项目中添加头
C++编写基于TCP/IP的Modbus网络通讯工具源码
03-13
用C++编写的基于TCP/IP的Modbus网络通讯工具源码，据参考价值。
modbuspp：用于Modbus TCP协议的C ++库
01-30
modbuspp：用于Modbus TCP协议的C ++库
ModbusTCP 客户端
09-27
找ModbusTCP好久，一点也不全，现传一个client端包含报头和协议部分,免费随便下。
c++ tcp\ip,Modbus tcp\ip通讯，源码
12-21
tcp\ip网络通讯(发送和接收)， Modbus tcp\ip(int ,short,float数据寄存器读写)，客户端。 使用Demo，源码...
modbus 客户端（主站）C++源代码
08-07
因为项目需要，自己参考网上的代码加上自己写的modbus客户端C++源码，实现了0x03和0x06的读写功能。可以拿来直接用！！！！
modbus tcp/rtu客户端服务端通讯程序合集（C#、c++、mfc）
10-17
最近在学modbus通讯，整理了大批资源代码，肯定让你满意，包含c#、c++、mfc、c的各类基本、有难度的代码，modbus tcp/rtu和tcp等，也有modbus的类库及仿真软件，过段时间，我会再整理内容写篇博客，并且把整理好注释...
Qt creator MODBUS TCP客户端读取数据应用软件（附带详细说明）
10-19
**Qt Creator MODBUS TCP客户端读取数据应用软件详解** MODBUS TCP是一种广泛应用于工业自动化领域的通信协议，它基于TCP/IP网络协议，使得设备能够通过网络交换数据。在本项目中，我们将探讨如何使用Qt Creator...
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))
qt/c++ tcp多线程客户端(
04-30
Qt/C++是一种开发语言和框架，可以用于创建跨平台的应用程序。其中，Qt提供了很多库和工具，可以方便地创建网络应用程序，例如TCP多线程客户端。 TCP多线程客户端是一种网络应用程序，可以向TCP服务器发送数据，并接收服务器返回的数据。多线程则意味着可以同时发送和接收多个数据流，提高了应用程序的效率和响应速度。 使用Qt/C++实现TCP多线程客户端需要以下步骤： 1. 创建QTcpSocket对象，该对象用于建立TCP连接、发送数据和接收数据。 2. 创建QThread对象，将其作为QTcpSocket对象的父对象，并将QTcpSocket对象移动到该线程中。 3. 在QThread对象中实现数据发送和接收的函数，该函数运行在子线程中，可以异步地发送和接收数据。 4. 在主线程中创建QTcpSocket对象和QThread对象的实例，并将它们连接起来。 5. 启动QThread对象，开始发送和接收数据。 在实现过程中，需要注意线程安全问题，例如需要将QTcpSocket对象的信号连接到主线程中的槽函数。此外，还需要考虑异常处理，例如连接失败时需要发送错误消息。 总之，使用Qt/C++实现TCP多线程客户端是一项有挑战的任务，但通过良好的设计和实践，可以创建高效和可靠的网络应用程序。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

进击的大海贼

联系博主，为您提供有价值的资源

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值