c++编写modbusTCP/ip协议远程读写服务器

最新推荐文章于 2024-05-06 19:36:20 发布
最新推荐文章于 2024-05-06 19:36:20 发布
阅读量824 收藏 10
点赞数 7
文章标签： c++ 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/matewang/article/details/135266326
版权

@利用c++多线程实现modbusTCP/ip协议远程读写服务器

主函数如下

#include<iostream>
#include"Modbus.h"


bool test01(ModBus &m1)
{
	    m1.ReadHolingRegisters(0, 60);
		m1.WriteHolingRegisters(0, 60);
		return 0;
}

void test02()
{
	ModBus m1("192.168.1.185", 50200);
	m1.ModBus_connect();
	//ModBus m2("192.168.1.183", 50201);
	//m2.ModBus_connect();
	//ModBus m3("192.168.1.183", 50202);
	//m3.ModBus_connect();
	while (1)
	{
		std::thread thread1([&m1]() { test01(m1); });
		//std::thread thread2([&m2]() { test01(m2); });
		//std::thread thread3([&m3]() { test01(m3); });
		
		thread1.join();
		//thread2.join();
		//thread3.join();
		std::this_thread::sleep_for(std::chrono::seconds(2));
	}
}

int main()
{
	test02();
	return 0;
}

Modbus.h 头文件

#pragma once
#include<vector>
#include <winsock.h>
#define _CRT_SECURE_NO_WARNINGS
#pragma comment(lib, "ws2_32.lib") 
#include <thread>
#include <random>
#include <cstdint>
#include <cstring>
#include <random> 
using namespace std;
class ModBus
{
public:
	ModBus(string modbus_address, unsigned modbus_port);
	bool ModBus_connect();
	BOOL  ReadHolingRegisters(USHORT start, USHORT length);
	BOOL  ReadHolingRegisters_int(USHORT start, USHORT length);
	BOOL  WriteHolingRegisters(USHORT start, USHORT length);
	BOOL  WriteHolingRegisters_int(USHORT start, USHORT length);

public:
	SOCKET clientSocket;
	string modbus_address;
	unsigned modbus_port;
};

Modbus源文件

#pragma once
#include<iostream>
using namespace std;
#include<iostream>
#include"Modbus.h"

uint32_t swapEndianness(uint32_t value) {
	return ((value & 0xFF) << 24) | (((value >> 8) & 0xFF) << 16) | (((value >> 16) & 0xFF) << 8) | ((value >> 24) & 0xFF);
}

	ModBus::ModBus(string modbus_address, unsigned modbus_port)
	{
		this->modbus_address = modbus_address;
		this->modbus_port = modbus_port;
	}
	bool ModBus:: ModBus_connect()
	{
		WSADATA wsaData;  // 初始化WSADATA为后续调用做准备
		if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
			std::cerr << "WSAStartup 失败。" << std::endl;
			return false;
		}
		// 创建套接字 通过套接字，程序能够连接到 Modbus 服务器，发送请求，接收响应，并在不需要连接时关闭套接字释放资源。
		clientSocket = socket(AF_INET, SOCK_STREAM, 0);
		if (clientSocket == INVALID_SOCKET) {
			std::cerr << "Failed to create socket: " << WSAGetLastError() << std::endl;
			return false;
		}
		sockaddr_in serverAddr;
		serverAddr.sin_family = AF_INET;
		serverAddr.sin_addr.s_addr = inet_addr((this->modbus_address).data()); // 服务器的 IP 地址
		serverAddr.sin_port = htons(this->modbus_port);

		/*	if (bind(clientSocket, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) == SOCKET_ERROR)  服务器连接客户端
			{
				std::cerr << "Connect failed: " << WSAGetLastError() << std::endl;
				closesocket(clientSocket);
				return false;
			}*/

		if (connect(clientSocket, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) == SOCKET_ERROR) {
			std::cerr << "Connect failed: " << WSAGetLastError() << std::endl;
			closesocket(clientSocket);
			return false;
		}
		cout << "连接成功" << endl;
		cout << this->modbus_port << endl;
		return TRUE;
	}

	BOOL  ModBus::ReadHolingRegisters(USHORT start, USHORT length)
	{
		//五步走 
			//1.拼接报文
		vector <char> send_data;
		//事务协议 1个字节有8位置
		send_data.push_back(0); send_data.push_back(0); send_data.push_back(0); send_data.push_back(0);
		//长度
		send_data.push_back(0); send_data.push_back(6);
		//单元标识符
		send_data.push_back(0x01);
		//功能码
		send_data.push_back(0x03);
		//起始寄存器地址
		send_data.push_back(char(start / 256));
		send_data.push_back(char(start % 256));
		//长度
		send_data.push_back(char(length / 256));
		send_data.push_back(char(length % 256));
		//2.发送报文
		const char* charData = &send_data[0];
		int dataSizeToSend = send_data.size();
		if (send(clientSocket, charData, dataSizeToSend, 0) == SOCKET_ERROR)
		{
			std::cerr << "Send failed: " << WSAGetLastError() << std::endl;
			/*ModBus_connect();*/
			return -1;
		}
		std::cout << "Data sent successfully." << std::endl;
		//3.接收报文,接收数据
		char buffer[1024];
		int bytesRead = recv(clientSocket, buffer, sizeof(buffer), 0);
		if (bytesRead == SOCKET_ERROR) {
			std::cerr << "Receive failed: " << WSAGetLastError() << std::endl;
			/*ModBus_connect();*/
			return -1;
		}
		else {

			std::cout << "Received " << bytesRead << " bytes." << std::endl;
		}

		//4.验证报文
		if (bytesRead == 2 * length + 9)
		{
			//cout << "长度正确" << endl;
		}


		//5.解析报文 前9个字节是固定的不属于数据。
		uint32_t* data = (uint32_t*)(buffer + 9);
		for (int i = 0; i < (length / 2); i++)
		{
			data[i] = ntohl(data[i]);
		}
		cout << "当前端口为：" << this->modbus_port<< endl;
		float* new_data = (float*)data;
		for (int i = 0; i < (length / 2); i++)
		{
			cout << "data" << i + 1 << ":" << new_data[i] << " ";
		}
		cout << endl;

		// 1个float 4个字节 转换；
		//char dataBuffer[120];
		//std::memcpy(dataBuffer, buffer + 9, 120);
		//float values[30];
		//for (int i = 0; i < 30; ++i) {
		//	uint32_t rawValue;
		//	std::memcpy(&rawValue, &dataBuffer[i * 4], sizeof(uint32_t));
		//	// 根据系统字节序转换字节顺序
		//	rawValue = swapEndianness(rawValue);

		//	std::memcpy(&values[i], &rawValue, sizeof(float));
		//	
		//}
		//for (int i = 0; i < 30; ++i) {
		//	std::cout << "Value " << ": " << values[i] << "  ";
		//}
		//cout << endl;
		//小端模式
		//const float * data = (float*)(buffer + 9);
		//float a;
		//cout << "每个模块的值" << endl;
		//for (int i = 0; i < (length/2); i++)
		//{
		//	cout << (((*(data + i)))) << " ";
		//}
		//cout << endl;
		return 1;
	}

	BOOL  ModBus::WriteHolingRegisters(USHORT start, USHORT length)
	{
		//五步走 
			//1.拼接报文
		vector <char> send_data;
		//事务 1个字节有8位置
		send_data.push_back(0); send_data.push_back(0);

		//协议
		send_data.push_back(0); send_data.push_back(0);
		//长度
		send_data.push_back(0); send_data.push_back(7 + 2 * length);
		//单元标识符
		send_data.push_back(0x01);
		//功能码
		send_data.push_back(0x10);
		//起始寄存器地址
		send_data.push_back(char(start / 256));
		send_data.push_back(char(start % 256));
		//寄存器数量
		send_data.push_back(0);
		send_data.push_back( length);
		//字节计数 字节*2
		send_data.push_back( 2*length);
		//cout << send_data.size() << endl;
		//长度 一个数据占四个字节
		// 1.end     
		//       使用指针和类型转换将浮点数转换为字节数组

		std::random_device rd;
		std::mt19937 gen(rd());

		// 定义生成浮点数的范围
		float lower_bound = 0.0;
		float upper_bound = 12.0;

		// 创建均匀分布对象
		for (int i = 0; i < (length / 2); i++)
		{
			std::uniform_real_distribution<float> distribution(lower_bound, upper_bound);
			// 生成随机浮点数
			float random_float = distribution(gen);
			/*cout << "float数值：" << random_float<< endl;*/
			uint32_t uintValue;
			uintValue = *reinterpret_cast<uint32_t*>(&random_float);
			uintValue = htonl(uintValue);

			char* byteArray = (char*)(&uintValue); // 创建一个4字节的字节数组
			for (int j = 0; j < 4; ++j)
			{
				send_data.push_back(byteArray[j]);
			}
		}
		// (2)方法
		 根据系统字节序转换字节顺序
		//std::uniform_real_distribution<float> distribution(lower_bound, upper_bound);
		//float random_float = distribution(gen);
		//float floatValue = random_float; // 浮点数值
		//uint32_t new_rawValue;
		//std::memcpy(&new_rawValue, &floatValue, sizeof(uint32_t));
		//new_rawValue = swapEndianness(new_rawValue);
		//char byteArray[4]; // 创建一个4字节的字节数组
		//std::memcpy(byteArray, &new_rawValue, sizeof(floatValue));
		//for (int j = 0; j < 4; ++j)
		//{
		//	send_data.push_back(byteArray[j]);
		//}
		//2.发送报文
		const char* charData = &send_data[0];
		int dataSizeToSend = send_data.size();
		if (send(clientSocket, charData, dataSizeToSend, 0) == SOCKET_ERROR)
		{
			std::cerr << "Send failed: " << WSAGetLastError() << std::endl;
			/*ModBus_connect();*/
			return -1;
		}
		//std::cout << "Data sent successfully." << std::endl;
		//3.接收报文,接收数据
		char buffer[1024];
		int bytesRead = recv(clientSocket, buffer, sizeof(buffer), 0);
		if (bytesRead == SOCKET_ERROR) {
			std::cerr << "Receive failed: " << WSAGetLastError() << std::endl;
			/*ModBus_connect();*/
			return -1;
		}
		else {

			//std::cout << "Received " << bytesRead << " bytes." << std::endl;
		}
		//4.验证报文
		if (bytesRead == 12)
		{
			cout << "长度正确" << endl;
		}
		else
		{
			cout << bytesRead << endl;
			cout << "长度不争取报文有问题" << endl;
		}
		return 1;
	}
	BOOL  ModBus::ReadHolingRegisters_int(USHORT start, USHORT length)
	{
		//五步走 
		//1.拼接报文
		vector <char> send_data;
		//事务协议 1个字节有8位置
		send_data.push_back(0); send_data.push_back(0); send_data.push_back(0); send_data.push_back(0);
		//长度
		send_data.push_back(0); send_data.push_back(6);
		//单元标识符
		send_data.push_back(0x01);
		//功能码
		send_data.push_back(0x03);
		//起始寄存器地址
		send_data.push_back(char(start / 256));
		send_data.push_back(char(start % 256));
		//长度
		send_data.push_back(char(length / 256));
		send_data.push_back(char(length % 256));
		//2.发送报文
		const char* charData = &send_data[0];
		int dataSizeToSend = send_data.size();
		if (send(clientSocket, charData, dataSizeToSend, 0) == SOCKET_ERROR)
		{
			std::cerr << "Send failed: " << WSAGetLastError() << std::endl;
			return -1;
		}
		std::cout << "Data sent successfully." << std::endl;
		//3.接收报文,接收数据
		char buffer[1024];
		int bytesRead = recv(clientSocket, buffer, sizeof(buffer), 0);
		if (bytesRead == SOCKET_ERROR) {
			std::cerr << "Receive failed: " << WSAGetLastError() << std::endl;
			return -1;
		}
		else {

			std::cout << "Received " << bytesRead << " bytes." << std::endl;
		}

		//4.验证报文
		if (bytesRead == 2 * length + 9)
		{
			//cout << "长度正确" << endl;
		}
		//5.解析报文 前9个字节是固定的不属于数据。
		int16_t* data = (int16_t*)(buffer + 9);
		for (int i = 0; i < (length ); i++)
		{
			data[i] = ntohs(data[i]);
			cout << "data" << i + 1 << ":" << data[i] << " ";
		}
		cout << endl;
		return 1;
	}


	BOOL  ModBus::WriteHolingRegisters_int(USHORT start, USHORT length)
	{
		//五步走 
		//1.拼接报文
		vector <char> send_data;
		//事务 1个字节有8位置
		send_data.push_back(0); send_data.push_back(0);

		//协议
		send_data.push_back(0); send_data.push_back(0);
		//长度
		send_data.push_back(0); send_data.push_back(7 + 2 * length);
		//单元标识符
		send_data.push_back(0x01);
		//功能码
		send_data.push_back(0x10);
		//起始寄存器地址
		send_data.push_back(char(start / 256));
		send_data.push_back(char(start % 256));
		//寄存器数量
		send_data.push_back(0);
		send_data.push_back(length);
		//字节计数 字节*2
		send_data.push_back(2 * length);

		//长度 一个数据占四个字节


		// 定义生成浮点数的范围
		float lower_bound = 0.0;
		float upper_bound = 12.0;

		// 创建均匀分布对象
		for (int i = 0; i < (length ); i++)
		{
			std::random_device rd;
			std::mt19937 gen(rd());
			// 设置种子以确保每次运行生成不同的随机数序列
			std::srand(static_cast<unsigned int>(std::time(nullptr)));

			// 生成随机整数在 [0, 100] 范围内
			int randomNumber = std::rand() % 101; // 取模操作将结果限制在 [0, 100] 范围内

			uint16_t uintValue;
			uintValue = *reinterpret_cast<uint16_t*>(&randomNumber);
			uintValue = htons(uintValue);

			char* byteArray = (char*)(&uintValue); // 创建一个2字节的字节数组
			for (int j = 0; j < 2; j++)
			{
				send_data.push_back(byteArray[j]);
			}
		}

		//2.发送报文
		const char* charData = &send_data[0];
		int dataSizeToSend = send_data.size();
		if (send(clientSocket, charData, dataSizeToSend, 0) == SOCKET_ERROR)
		{
			std::cerr << "Send failed: " << WSAGetLastError() << std::endl;
			return -1;
		}
		//std::cout << "Data sent successfully." << std::endl;
		//3.接收报文,接收数据
		char buffer[1024];
		int bytesRead = recv(clientSocket, buffer, sizeof(buffer), 0);
		if (bytesRead == SOCKET_ERROR) {
			std::cerr << "Receive failed: " << WSAGetLastError() << std::endl;
			return -1;
		}
		else {

			//std::cout << "Received " << bytesRead << " bytes." << std::endl;
		}
		//4.验证报文
		if (bytesRead == 12)
		{
			cout << "长度正确" << endl;
		}
		else
		{
			cout << bytesRead << endl;
			cout << "长度不争取报文有问题" << endl;
		}
		return 1;
	
	}
小王11111
关注
  • 7
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
基于C++实现Modbus TCP通信的详细指南
m0_57781768的博客
06-16 1377
Modbus协议是一种主从通信协议，最早由Modicon公司（现在是施耐德电气的一部分）在1979年开发。它被设计用于在控制器和设备之间传输数据。Modbus协议分为多种变体，其中Modbus TCP是使用最广泛的一种，它通过TCP/IP网络进行数据传输。本文详细介绍了如何在C++中实现Modbus TCP通信。从基础概念到具体实现，包括创建TCP客户端和服务器，构建和解析Modbus帧，处理并发请求和常见问题的解决方案。
ModbusTCP读写信捷PLC实例程序源代码
12-06
【亲测实用】ModbusTCP读写信捷PLC 文件类型：程序源代码 主要功能： 信捷PLC通信实例 ModbusTCP Modbus stc PLC tcp 适合人群：新手及有一定经验的开发人员
C++基于开源Modbus Tcp 通讯应用客户端（稳定高效，多线程后台状态读取，不卡顿）
u013083044的博客
11-17 4915
使用多线程后台批量刷寄存器的状态，在某种程度上保证了上层接口读取的时候，不会卡顿，整体应用效果比较友好。程序应用简单稳定高效，是一个比较不错的尝试。
c++ modbusTCP
weixin_39926429的博客
06-09 4130
/Modbus TCP是一种基于TCP/IP协议的Modbus协议，它允许Modbus协议通过以太网进行通信。//在C++中，可以使用第三方库来实现Modbus TCP通信，例如libmodbus和QModbus。// 断开Modbus连接并释放上下文。// 创建Modbus TCP上下文。// 创建Modbus TCP客户端。// 连接到Modbus从设备。// 连接到Modbus从设备。// 读取Modbus寄存器。// 读取Modbus寄存器。// 打印读取到的寄存器值。
C++和python分别用Qt实现ModbusTcp通讯
最新发布
weixin_49577420的博客
05-06 437
python代码实现，有个问题暂时未解决。
简单的Modbus/TCP客户端，包含写寄存器函数#C++
热门推荐
sheldon0227的博客
10-21 1万+
modbus-TCP 协议文档：http://wenku.baidu.com/link?url=ImagoC3DE1p0D55S7qbzXrSaQ4wbaY93gB3kEmPiHx_CnnNsrdkz1vYA93uTBtvmbzxhRrcBoPc8YNl9UqJqlRAV1r3Tm2tYoOfdTU1zcVG 简单来说就是吧modbus RTU的报文做修改后使用TCP协议传输，通常modbu
MODBUS TCP 的C++源码
09-28
MODBUS TCP 的C++源码，很珍贵的哦
ModbusTCP连接C++源码
04-26
上网找了好久的MFCModbusTCP连接代码，再VS2010中调试成功，可以自己拿过来用。里面中文注释写的也比较详细
C++编写基于TCP/IP的Modbus网络通讯工具源码
03-13
用C++编写的基于TCP/IP的Modbus网络通讯工具源码，据参考价值。
C++客户端Modbus通信（TCP主站）
qq_45220555的博客
11-30 7495
本文简单介绍Qt使用外部modbus通信C++编程流程 modbus中文手册：https://blog.csdn.net/qq_23670601/article/details/82155378 Qtmodbus较为方便，建议无特殊情况可以使用qtmodbus，为何不使用Qt自带QModbus呢？原因是我在编写modbus主站的时候需要创建一个线程监听从站的数据，创建线程的时候出现为不同线程的父线程创建子线程的报错，个人解决不了。 modbus通信编程流程 1.搭建modbus环境 在pro工程项目中添加头
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/C++基于VS开发的modbustcp源程序.rar
05-11
该资源包整合了多个C/C++的modbustcp开发源程序，为你的开发提供一定思路
modbus完整协议源码（c/c++）
01-05
Modbus 协议是应用于电子控制器上的一种通用语言。c语言写成，共五个文件，两个头文件，一个主函数，一个写，一个读。
modbus_tcp/ip源码demo
12-13
Modbus TCP/IP是一种广泛应用于工业自动化领域的通信协议，它基于标准的TCP/IP协议栈，使得各种设备能够通过网络进行数据交换。在这个“modbus_tcp/ip源码demo”中，我们很显然会涉及到如何在Microsoft Foundation ...
Java实现modbus tcp协议数据读写，项目内包含modbus slave仿真软件
09-28
本项目专注于使用Java语言实现Modbus TCP/IP协议的读写功能，提供了两种不同的实现方案：jlibmodbus和modbus4j库。这两种库都是Java社区开发的开源工具，专门用于处理Modbus通信。 首先，我们来看jlibmodbus。...
C#编成Modbus TCP连接各种PLC读取写入寄存器源码
01-08
资源名：C#编成Modbus TCP连接各种PLC读取写入寄存器源码 资源类型：程序源代码 源码说明： C#编成Modbus TCP连接PLC寄存器读取、写入，完整分享源代码，有需要的人可以下载 适合人群：新手及有一定经验的开发人员
c++ modbustcp批量读写
01-05
c modbustcp 批量读写是指通过使用 Modbus TCP 协议，可以在网络上对多个 Modbus TCP 从站设备进行批量读写操作。 在 c modbustcp 批量读写中，通常会先建立与 Modbus TCP 从站设备的连接，然后使用 Modbus TCP 协议的读写功能码对从站设备的寄存器进行读写操作。在进行批量读写时，可以一次性读取或写入多个从站设备的寄存器，提高了读写的效率。 在进行 c modbustcp 批量读写时，需要指定每个从站设备的地址以及要读写的寄存器类型和数量。同时还需要设置好 Modbus TCP 通信的参数，如 IP 地址、端口号等。进行读操作时，可以一次性读取多个从站设备的数据并将结果返回；进行写操作时，可以一次性写入多个从站设备的数据。 c modbustcp 批量读写广泛应用于工业自动化系统中，可以实现对多个设备的同时监控和控制。例如，在能源监控系统中，可以通过 c modbustcp 批量读取多个电表的数据，实现对整个用电状态的实时监测；在智能楼宇系统中，可以通过 c modbustcp 批量写入多个空调设备的控制命令，实现对整栋楼的空调系统的集中控制。 总之，c modbustcp 批量读写通过高效的 Modbus TCP 协议，实现了对多个 Modbus TCP 从站设备的快速读写操作，为工业自动化系统的监控和控制提供了便利。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值