Visual Studio 上基于libmodbus库的modbus RTU模式的通讯模拟

已于 2023-11-26 10:06:18 修改
阅读量5k 收藏 41
点赞数 8
分类专栏： libmodbus 文章标签： qt 开发语言
于 2020-09-21 14:42:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43552324/article/details/108704358
版权

Visual Studio 上基于libmodbus库的modbus RTU模式的通讯模拟

   本文主要为《Modbus 软件开发实战指南》的代码。看这本书的缘由是，我在做libmodbus+qt上位机，参考了网上的一些资料，照着来了一遍，总是编译不过，就在博客中搜索，意外中看到了这本书，下载pdf居然也要充钱收费，于是借了书，针对其中有用的部分，码字分享之，希望对各位有用。

libmodbus库的编译

libmodbus的库在VS平台上的编译，与在Msys上的编译略有不同。编译的步骤如下：

  1. 在github上下载libmodbus源代码，下载网址：https://github.com/stephane/libmodbus.
  2. 解压完成后，在src/win32文件目录下，双击configure.js，生成了config.h文件和modbus-version.h文件。
  3. 打开项目文件modbus-9.sln，在弹出的文件升级对话框中，点击确定。
  4. 将源文件夹下的modbus-version.h替换成新生成的modbus-version.h。
  5. 右键点击项目，选择属性，打开属性对话框，选择该VS版本下的SDK，并去除掉Version选项的定义。
  6. 编译通过。生成modbus.dll和modbus.lib文件。

RTU Master端的编写

新建项目工程，将之前生成的dll文件、lib文件以及libmodbus库里的头文件，复制到项目文件所在的目录下，并通过添加现有文件到项目中，至此libmodbus中的各种接口函数可以应用了。
1.TestRtuMaster.cpp

#include <stdio.h>
#ifdef _MSC_VER
#ifndef _UNISTD_H     /*unistd.h头文件的替代*/
#define _UNISTD_H
#include <io.h>
#include <process.h>
#endif                
#endif
#include <string.h>
#include<stdlib.h>
#include <errno.h>     //查看错误代码的头文件

#include "modbus.h"   //引用libmodbus数据库


#define LOOP   1           //宏定义循环次数
#define SERVER_ID   17     //从机端设备地址
#define  ADDRESS_START  0  //测试寄存器的起始地址
#define  ADDRESS_END  99   //测试寄存器的结束地址

int main(void)
{
	modbus_t *ctx;   //modbus_t结构体指针变量
	int rc;
	int nb_fail;   //表示什么
	int nb_loop;
	int addr;
	int nb;      //寄存器的个数
	uint8_t *tab_rq_bits;
	uint8_t *tab_rp_bits;
	uint16_t *tab_rq_registers;
	uint16_t *tab_rw_rq_registers;
	uint16_t *tab_rp_registers;

	/*RTU*/
	ctx = modbus_new_rtu("COM3", 19200, 'N', 8, 1); //生成并初始化一个modbus结构体在串行线路中使用RTU模式通讯，N表示无奇偶位校验
	modbus_set_slave(ctx, SERVER_ID);  //设置从机端地址

	modbus_set_debug(ctx, TRUE); //启动调试模式，标志位设置为TRUE，表示会在stdout和stderr（标准输出设备）上显示很多冗长的信息，用于显示modbus消息的字节

	if (modbus_connect(ctx) == -1)  //建立modbus连接，若连接成功，该函数返回0，否则，返回-1，并将errno设置为底层系统调用的定义值
	{
		fprintf(stderr, "Connection failed :%s\n", modbus_strerror(errno));  //通过调用errno，捕获程序失败的原因
		modbus_free(ctx);  //释放已分配的modbus结构体
		return -1;
	}

	nb = ADDRESS_END - ADDRESS_START;  //计算需测试的寄存器个数

	//申请内存，用于保存发送以及接收的数据
	tab_rq_bits = (uint8_t *)malloc(nb * sizeof(uint8_t));
	memset(tab_rq_bits, 0, nb * sizeof(uint8_t));

	tab_rp_bits = (uint8_t *)malloc(nb * sizeof(uint8_t));
	memset(tab_rp_bits, 0, nb * sizeof(uint8_t));

	tab_rq_registers = (uint16_t *)malloc(nb * sizeof(uint16_t));
	memset(tab_rq_registers, 0, nb * sizeof(uint16_t));

	tab_rp_registers = (uint16_t *)malloc(nb * sizeof(uint16_t));
	memset(tab_rp_registers, 0, nb * sizeof(uint16_t));

	tab_rw_rq_registers = (uint16_t *)malloc(nb * sizeof(uint16_t));
	memset(tab_rw_rq_registers, 0, nb * sizeof(uint16_t));

	nb_loop = nb_fail = 0;
	while (nb_loop++ < LOOP)
	{
		//从起始地址开始顺序测试
		for (addr = ADDRESS_START; addr < ADDRESS_END; addr++)
		{
			int i;
			//生成随机数
			for (i = 0; i < nb; i++)
			{
				tab_rq_registers[i] = (uint16_t)(65535.0 * rand() / (RAND_MAX + 1.0));
				tab_rw_rq_registers[i] = ~tab_rq_registers[i];
				tab_rq_bits[i] = tab_rq_registers[i] % 2;

			}
			nb = ADDRESS_END - addr;

			rc = modbus_write_bit(ctx, addr, tab_rq_bits[0]);  //这个函数的第三个参数是status值，不对应，我有点不太理解 
			if (rc != 1)
			{
				printf("ERROR modbus _write_bit(%d)\n", rc);
				printf("Address = %d, value = %d\n", addr, tab_rq_bits[0]);
				nb_fail++;   //nb_fail==nb_loop
			}
			else
			{
				//写入之后，读取并进行比较
				rc = modbus_read_bits(ctx, addr, 1, tab_rp_bits);
				if (rc != 1 || tab_rq_bits[0] != tab_rp_bits[0])
				{
					printf("ERROR modbus_read_bits single(%d)\n", rc);
					printf("address =%d\n", addr);
					nb_fail++;
				}

			}
			/*测试线圈寄存器的批量读写*/
			rc = modbus_write_bits(ctx, addr, nb, tab_rq_bits);  //对应0x0F功能
			if (rc != nb)
			{
				printf("ERROR modbus_write_bits(%d)\n", rc);
				printf("Address=%d,nb=%d\n", addr, nb);
				nb_fail++;
			}
			else
			{
				//写入之后，再读取并比较
				rc = modbus_read_bits(ctx, addr, nb, tab_rp_bits);  //对应0x01功能
				if (rc != nb)
				{
					printf("ERROR modbus_read_bits\n");
					printf("Address=%d,nb=%d\n", addr, nb);
					nb_fail++;
				}
				else
				{
					//进行比较
					for (i = 0; i < nb; i++)
					{
						if (tab_rp_bits[i] != tab_rq_bits[i])
						{
							printf("ERROR modbus_read_bits\n");
							printf("Addr=%d,Val=%d(0x%X)!=%d(0x%X)\n", addr, tab_rq_bits[i], tab_rq_bits[i], tab_rp_bits[i], tab_rp_bits[i]);
							nb_fail++;
						}
					}
				}
			}

			/*测试保持寄存器的单个读写*/
			rc = modbus_write_register(ctx, addr, tab_rq_registers[0]);  //写单个寄存器，对应功能0x06
			if (rc != 1)
			{
				printf("ERROR modbus_write_register(%d)\n", rc);
				printf("Address=%d,Val=%d(0x%X)\n", addr, tab_rq_registers[0], tab_rq_registers[0]);
				nb_fail++;
			}
			else
			{
				//写入后再进行读取
				rc = modbus_read_registers(ctx, addr, 1, tab_rp_registers); //读取保持寄存器，对应功能0x03
				if (rc != 1)
				{
					printf("ERROR modbus_read_registers(%d)\n", rc);
					printf("Address = %d\n", addr);
					nb_fail++;
				}
				else
				{
					//读取后进行比较
					if (tab_rq_registers[0] != tab_rp_registers[0])
					{
						printf("ERROR modbus_read_registers\n");
						printf("Address=%d,Val=%d(0x%X)!=%d(0x%X)\n", addr, tab_rq_registers[0], tab_rq_registers[0], tab_rp_registers[0], tab_rp_registers[0]);
						nb_fail++;
					}
				}

			}

			/*测试多个寄存器的批量读写*/
			rc = modbus_write_registers(ctx, addr, nb, tab_rq_registers);  //写多个寄存器，对应功能0x16
			if (rc != nb)
			{
				printf("ERROR modbus_write_registers(%d)\n", rc);
				printf("Address=%d,nb=%d\n", addr, nb);
				nb_fail++;
			}
			else
			{
				rc = modbus_read_registers(ctx, addr, nb, tab_rp_registers); //读取保持寄存器，对应功能0x03
				if (rc != nb)
				{
					printf("ERROR modbus_read_registers(%d)\n", rc);
					printf("Address=%d\n", addr, nb);
					nb_fail++;
				}
				else
				{
					for (i = 0; i < nb; i++)
					{
						//进行比较
						if (tab_rq_registers[i] != tab_rp_registers[i])
						{
							printf("ERROR modbus_read_registers\n");
							printf("Address=%d,value%d(0x%X)!=%d(0x%X)\n,addr,tab_rq_registers[i],tab_rq_registers[i],tab_rp_registers[i],tab_rp_registers[i]");
							nb_fail++;
						}
					}
				}

				/*读写多个寄存器的测试*/
				rc = modbus_write_and_read_registers(ctx, addr, nb, tab_rw_rq_registers, addr, nb, tab_rp_registers);//读写多个寄存器，对应功能ox17
				if (rc != nb)
				{
					printf("ERROR modbus_read_and_write_registers(%d)\n", rc);
					printf("Address=%d,nb=%d\n", addr, nb);
					nb_fail++;
				}
				else
				{
					//读取并比较
					for (i = 0; i < nb; i++)
					{
						if (tab_rp_registers[i] != tab_rw_rq_registers[i])
						{
							printf("ERROR modbus_read_and_write_registers READ\n");
							printf("Address=%d,value%d(0x%X)!=%d(0x%X)\n", addr, tab_rp_registers[i], tab_rq_registers[i], tab_rp_registers[i], tab_rw_rq_registers[i]);
							nb_fail++;
						}
					}

					rc = modbus_read_registers(ctx, addr, nb, tab_rp_registers);
					if (rc != nb)
					{
						printf("ERROR modbus_read_registers(%d)\n", rc);
						printf("Address=%d,nb=%d\n", addr, nb);
						nb_fail++;
					}
					else
					{
						for (i = 0; i < nb; i++)
						{
							if (tab_rw_rq_registers[i] != tab_rp_registers[i])
							{
								printf("ERROR modbus_read_and_write_registers\n");
								printf("Address=%d,Val %d(0x%X)!=%d(0x%X)\n", addr, tab_rw_rq_registers[i], tab_rw_rq_registers[i], tab_rp_registers[i], tab_rp_registers[i]);
								nb_fail++;
							}
						}
					}
				}
			}
			printf("Test:");
			if (nb_fail)
				printf("%d FAIL\n", nb_fail);
			else
				printf("SUCCESS\n");
		}

		/*释放内存空间*/
		free(tab_rq_bits);
		free(tab_rp_bits);
		free(tab_rq_registers);
		free(tab_rp_registers);
		free(tab_rw_rq_registers);

		/*关闭连接*/
		modbus_close(ctx);
		modbus_free(ctx);

		return 0;
	}
}

其中有几个需要补充的说明和几个函数用法介绍如下：

  • unistd.h头文件无法使用，采用了它的替换方式；
  • include <errno.h>：是查看错误代码的头文件；
  • modbus_new_rtu()：用来生成并初始化一个modbus_t结构体，在串行线路中使用RTU模式通讯，N表示无奇偶位校验；
  • modbus_set_slave()：设置从机端的ID；
  • modbus_set_debug()：启动调试模式，标志位设置为TRUE，表示会在stdout和stderr（标准输出设备）上显示很多冗长的信息，用于显示modbus消息的字节;
  • modbus_connect()：建立modbus连接，若连接成功，该函数返回0，否则，返回-1，并将errno设置为底层系统调用的定义值；
  • modbus_strerror()：通过调用errno，可捕获程序失败的原因；
  • modbus_free()：释放已分配的modbus_t结构体；
  • modbus_write_bit()：线圈的单个写操作
    int modbus_write_bit(modbus_t *ctx,int addr,int status),其中status为True或false，对应Modbus功能码0x05；
  • modbus_read_bits()：线圈的读操作
    int modbus_read_bits(modbus_t *ctx,int addr,int nb,uint8_t *dest)，表示将nb位（线圈）的状态读取到地址为addr的设备上，并存储到dest数组中去，设置为TRUE或FALSE的无符号字节。对应Modbus功能码0x01;
  • modbus_write_bits()： 多个线圈的批量写操作
    int modbus_write_bits(modbus_t *ctx,int addr,int nb,const uint8_t *src),表示从设备地址addr处的src数组写入nb位（线圈）的状态，其中src的数组要包含设置有TRUE或FALSE的字节，对应Modbus功能码0x0F；
  • modbus_write_register(): 单个保持寄存器的写操作
    int modbus_write_register(modbus_t *ctx,int addr,int value),用于将保持寄存器的值写在地址为addr的设备上,对应Modbus功能码为0x06;
  • modbus_write_registers()：多个保持寄存器的写操作
    int modbus_write_registers(modbus_t *ctx,int addr,int nb,const uint16_t *src);表示将src数组中的内容写到地址为addr的nb个寄存器中，对应Modbus功能码为0x16；
  • modbus_read_registers()：读取保持寄存器
    int modbus_read_registers(modbus_t *ctx,int addr, int nb, uint16_t *dest),表示读取地址设备在addr处开始的nb位（保持寄存器）的状态，读取结果以uint16位的形式存储在dest数组中，对应Modbus功能码0x03；
  • modbus_write_and_read_registers：多个寄存器的读和写
    int modbus_write_and_read_registers(modbus_t *ctx, int write_addr, int write_nb, const uint16_t *src, int read_addr, int read_nb, const uint16_t *dest)，表示将src数组中的内容写到远程设备write_addr地址处的一组write_nb个寄存器，然后读取read_addr处的一组read_nb个寄存器内容并保存到dest数组，对应Modbus功能码0x17。

RTU-Master的代码流程小结

1.初始化并生成modbus_t 结构体；
2.设置从机端的ID；
3.启动调试模式；
4.建立modbus连接；
5.申请内存；
6.寄存器/线圈的赋值;
7.线圈寄存器的单个读写/批量读写/保持寄存器的单个读写/批量读写/读取多个寄存器；
8.释放内存；
9.关闭modbus连接；
10.释放modbus结构体

RTU-Slave端的编写

同上
1.TestRtuSlave.cpp：

#include <stdio.h>
#ifndef _MSC_VER
#endif
#include <stdlib.h>
#include <errno.h>
#include "modbus.h"
#define SERVER_ID 17

int main(void)
{
	modbus_t *ctx;
	modbus_mapping_t *mb_mapping;

	/*RTU*/
	ctx = modbus_new_rtu("COM2", 19200, 'N', 8, 1);  //创建一个RTU的容器
	modbus_set_slave(ctx, SERVER_ID);
	modbus_set_debug(ctx, TRUE);
	if (modbus_connect(ctx) == -1)
	{
		fprintf(stderr, "Connection failed:%s\n", modbus_strerror(errno));
		modbus_free(ctx);
		return -1;
	}

	

	mb_mapping = modbus_mapping_new(500, 500, 500, 500);
	if (mb_mapping == NULL)
	{
		fprintf(stderr, "Error mapping: %s\n", modbus_strerror(errno));
		modbus_free(ctx);
		return -1;
	}

	for (;;)
	{
		uint8_t query[MODBUS_TCP_MAX_ADU_LENGTH];
		int rc;

		rc = modbus_receive(ctx, query);
		if (rc > 0)
		{
			modbus_reply(ctx, query, rc, mb_mapping);
		}
		else
		{
			printf("Connection Closed\n");
		}
	}
	printf("Quit the loop :%s\n", modbus_strerror(errno));

	modbus_mapping_free(mb_mapping);
	modbus_close(ctx);
	modbus_free(ctx);
	return 0;
}

补充函数说明

  • modbus_mapping_new()：
    modbus_mapping_t modbus_mapping_new(int nb_bits,int nb_input_bits,int nb_registers,int nb_registers);
    modbus_mapping_new()函数需要分配4个数组来存储位、输入位、寄存器和输入寄存器。若不需要为特定类型的数据分配数组，可在参数中传递0值，关联指针则为NULL。
    该函数返回一个modbus_mapping_t指针。
  • modbus_receive()：
    int modbus_receive(modbus_t *ctx,uint8_t *req);
    modbus_receive()函数是Modbus从机端/服务器使用此功能接收和分析主机端/客户机发送的指示请求。
  • modbus_reply()：
    *int modbus_reply(modbus_t *ctx,const uint8_t *req,int req_length,modbus_mapping_t *mb_mapping);
    modbus_reply()函数是对接收到的请求发送响应，先是分析参数中请求req，然后利用ctx来构建和发送响应。此功能是为Modbus 服务器设计的。
  • modbus_mapping_free()：
    void modbus_mapping_free(modbus_mapping_t *mb_mapping);
    modbus_mapping_free()函数将释放mb_mapping_t结构中的四个数组，并最终释放mb_mapping所引用的mb_mapping_t。

RTU-Slave的代码流程小结：

1.初始化并生成modbus_t 结构体；
2.设置从机端的ID;
3.起点调试模式;
4.建立modbus连接;
5.modbus_mapping_new()初始化寄存器，返回一个modbus_mapping_t 指针；
6.调用modbus_receive()函数判断串口的接收数据，负责接收和分析；
7.调用modbus_reply()函数，对接收到的请求指示发送响应（回复）；
8.释放modbus_mapping_t 结构体；
9.关闭modbus连接；
10.释放modbus_t 结构体。

创建虚拟串口

下载Configure Virtual Serial Port Driver，新建虚拟端口COM2和COM3，可在设备管理器中查询是否建立。
新建虚拟串口
设备管理器中查询
分别启动两个项目，则可完成modbus RTU模式的通讯。
modbus RTU通讯执行命令窗口
至此，Modbus RTU模式的通讯测试完成，希望对你有用，谢谢~
参考1：libmodbus手册翻译
参考2：《Modbus 软件开发实战指南》
参考3：modbus之libmodbus

稀里糊涂的赢
关注
专栏目录
vs 2019 编译 libmodbus
07-28
Modbus 协议 Modbus簇主要有三种协议：Modbus-RTU、Modbus-ASCII、Modbus-TCP libmodbus库函数非常简洁，读写操作函数对于RTU和TCP完全通用，RTU和TCP切换只需要修改一行代码就可以实现无缝切换。 odbus_t *mb; int ret; //创建一个modbus-rtu对象，指定串口号，波特率，校验位，数据位，停止位 //成功返回指针，否则返回NULL, 会调用malloc申请内存 mb = modbus_new_rtu("/dev/ttySP1", 115200, 'N', 8, 1); //linux mb = modbus_new_rtu("COM1", 115200, 'N', 8, 1); //windows //创建modbus-tcp对象，指定IP地址和端口号 mb = modbus_new_tcp("127.0.0.1", 502); //TCP/IP //设置从机地址，成功返回0, 否则返回-1 ret = modbus_set_slave(mb, slave);
Modbus RTU 模拟软件
11-15
1)可模拟地址为(1-247)的MODBUS RTU子站； 2)支持0x01,0x02,0x03,0x04,0x05,0x06,0x10,0x15功能码； 3)各种模拟数据及通讯信息表用户均可自定义！ 4)支持用户自定义功能码，可选择的电能量自动递加及遥信变位动作； 5)支持MODBUS RTU主站轮询功能，下发数据用户可自定义； 6)支持串口数据通讯报文监视功能。
极简版modbus RTU数据格式
最新发布
weixin_43663580的博客
09-20 725
16个uint16_t的寄存器，共32Bytes内容用于读回灵巧手的版本信息，每个Byte都以ASCII码展现，例如"Paxini_Hand_V1.4 Left_Hand Sep 5 2024 14:10:05"掌心侧摆电机的电流软件保护阈值。掌心侧摆电机的温度以及错误码。无名指电机的电流软件保护阈值。掌心侧摆电机的弱电流持续时间。食指电机的电流软件保护阈值。中指电机的电流软件保护阈值。小指电机的电流软件保护阈值。拇指电机的电流软件保护阈值。无名指电机的弱电流持续时间。掌心侧摆电机的弱维持电流。
【嵌入式】Libmodbus之RTU模式Master端程序示例
C/C++软件工程师、嵌入式软件工程师、物联网研发工程师、C/C++讲师、物联网讲师、嵌入式讲师---欢迎大家一起交流(私信添加博主微信)
05-14 2757
00. 目录 文章目录00. 目录01. 软件开发流程02. 获取版本信息03. 读写单个线圈程序示例04. 读写多个线圈程序示例05. 读写单个保持寄存器程序示例06. 读写多个保持寄存器程序示例07. 读写多个寄存器测试(功能码0X17)08. 附录 01. 软件开发流程 Modbus结合libmodbus开发库可以自由开发主设备端或从设备端的应用程序，而且支持RTU和TCP两种常用的模式。 开发主设备端(Master或者Client)程序的基本流程如下图所示： 开发从设备端(Slave或者Serve
Windows中libmodbus库在Visual Studio中的使用
m0_48387335的博客
07-19 890
Windows中libmodbus库在Visual Studio中的使用
【嵌入式】Libmodbus之RTU模式Slave端程序示例
C/C++软件工程师、嵌入式软件工程师、物联网研发工程师、C/C++讲师、物联网讲师、嵌入式讲师---欢迎大家一起交流(私信添加博主微信)
05-14 2569
00. 目录 文章目录00. 目录01. 开发RTU Slave端程序流程02. RTU Slave端程序示例03. RTU Slave端程序说明04. 预留05. 附录 01. 开发RTU Slave端程序流程 02. RTU Slave端程序示例 程序示例 #include <stdio.h> #ifndef _MSC_VER #include <unistd.h> #endif #include <stdlib.h> #include <errno.h&
C#含有ModbusRtu通讯库，通讯示例 硬件设备测试例程
06-02
**项目结构**：根据提供的压缩包文件名，`.vs`通常包含Visual Studio的工作区信息，`CHH.Modbus.Pro.sln`是解决方案文件，`CHH.Modbus.Pro`可能是项目的源代码文件夹，而`CHH.Modbus`可能包含了实际的Modbus通信库的...
VS2013开发的MFC下的Modbus RTU
09-24
在本文中，我们将深入探讨如何使用Visual Studio 2013（VS2013）进行MFC（Microsoft Foundation Classes）应用程序开发，并结合Modbus RTU协议实现一个基础的通信功能。Modbus RTU是一种广泛使用的工业通信协议，...
Qt+vs2017下简单应用libModbus库
12-19
在本文中，我们将深入探讨如何在Qt 5.9.4和Visual Studio 2017环境下使用libModbus库创建一个简单的应用。libModbus是一个开源库，它提供了与Modbus协议交互的能力，该协议广泛用于工业自动化系统中进行通信。我们将...
C#语言编写Modbus RTU通讯程序
01-20
综上，掌握C#编写Modbus RTU通信程序的关键在于理解Modbus协议的工作原理，正确配置串口通信参数，并有效利用NModbus库提供的功能。通过实践和调试，开发者可以创建出稳定可靠的Modbus通信程序。在"ModbusOK"这个...
IEC104RTU模拟工具
05-07
IEC104RTU模拟工具，是一款操作简单，好使用的模拟工具
MODBUS TCP/RTU调试工具，附主子站模拟器
11-13
MODBUS TCP/RTU调试工具，附主子站模拟器。两个工具其中一个modscan，另外一个是modbus rtu/tcp 主子站模拟器，开发必备。
Modbus+RTU协议单片机例程
05-15
51单片机上运行的modbus协议的实现样例，单片机演示卡原理图.pdf，WQ_C51_3 modbus.c。
win7+vs2015下编译成功的modbus上位机(应用libmodbus)包括所用调试工具和资料
11-21
在win7下采用vs2015编程的modbus上位机程序,c++程序，下载后可直接运行，对使用libmodbus入门有很大帮助，在此基础上可参考libmodbus例程及其它资料实现modbus tcp编程。含libmodbus的使用方法、虚拟串口工具及一本modbus入门书籍。
Modbus通信例子源代码
02-23
Modbus通信的两个例子，源代码都可以在VC6.0下顺利编译成功。内附有实现文档。Modbus TCP 源代码-编程举例源码，一个TCP/IP 主机是Modbus/TCP 读取寄存器的源代码，只需修改TCP/IP 的接口，部分就可以在以下环境下使用： 　　1. 命令行的JAVA 应用程序 　　2. UNIX 下基于命令行的C 应用程序 　　3. Win32 下基于命令行的C 应用程序
MFC 简单Modbus RTU.zip_MFC Modbus_MFC modbus RTU_MFCmodbus_mfc vs2
07-14
在这个"MFC简单Modbus RTU"项目中，开发者使用Visual Studio 2013中的MFC库创建了一个简单的应用，实现了Modbus RTU协议的功能，主要用于控制继电器的开和关操作。这是一个基础的单命令控制Demo，可以帮助初学者理解...
libmodbus RTU从站实现
qq_43168163的博客
04-24 969
libmodbus + QT RTU从站的实现，能够实现不断的断开重连，同时是对上一篇libmodbus modbus tcp的补充。
libmodbus之rtu方式通讯
一叶知秋的博客
06-05 8189
1. 打开 char chDevCom[10] = “COM1”; // 串口号 int nBaudRate = 9600; // 波特率 char chParity = 'O'; // 校验码 int nDataBits = 8; // 数据位 int nStopBits = 1; // 停止位 modbus_t * pCtx = modbus_new_rtu(devCom,...
评论 22
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值