自己写一个Modbus从站程序，读写主站保存寄存器 、读取主站输入寄存器、读取主站输入开关量、读写主站输出线圈

最新推荐文章于 2024-06-09 23:24:00 发布
最新推荐文章于 2024-06-09 23:24:00 发布
阅读量3.7k 收藏 39
点赞数 2
分类专栏： STM32 STC 文章标签： 单片机 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yonglwin/article/details/124971452
版权
STM32 同时被 2 个专栏收录
3 篇文章 1 订阅
订阅专栏
STC
2 篇文章 0 订阅
订阅专栏

Modbus常用功能码功能

在这里插入图片描述

Modbus各个功能打包程序 Modbus.c文件

#include <Modbus.h>

#define ModbusSendMaxCount	(16*2+9)	//串口发送最大字节数,发送 16 Word（Register_Address）
#define ModbusReceMaxCount	(16*2+9)	//串口接收最大字节数,接收 16 Word（Register_Address）
unsigned char ModbusSendBuf[ModbusSendMaxCount];
unsigned char ModbusReceBuf[ModbusReceMaxCount];

unsigned char Demo;

uchar WBDO15[8];//
unsigned int  WWAO16[8];//
//===========================================================================================
//CRC校验字节值表
//===========================================================================================
//CRC校验高位字节值表
const unsigned char code auchCRCHi[] = {   
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,  
0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,  
0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,  
0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,  
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81,  
0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,  
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,  
0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,  
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,  
0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,  
0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,  
0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,  
0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,  
0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,  
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,  
0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,  
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,  
0x40 } ;   
//CRC校验低位字节值表
const unsigned char code auchCRCLo[] = {   
0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7, 0x05, 0xC5, 0xC4,  
0x04, 0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09,  
0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD,  
0x1D, 0x1C, 0xDC, 0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,  
0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32, 0x36, 0xF6, 0xF7,  
0x37, 0xF5, 0x35, 0x34, 0xF4, 0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A,  
0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA, 0xEE,  
0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,  
0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 0x61, 0xA1, 0x63, 0xA3, 0xA2,  
0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F,  
0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68, 0x78, 0xB8, 0xB9, 0x79, 0xBB,  
0x7B, 0x7A, 0xBA, 0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,  
0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0, 0x50, 0x90, 0x91,  
0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C,  
0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98, 0x88,  
0x48, 0x49, 0x89, 0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,  
0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80,  
0x40 };

unsigned short CRC16 ( unsigned char *puchMsg, unsigned short usDataLen )    
{   
 unsigned char uchCRCHi = 0xFF ;  //\* 高字节初始化值   \*/   
 unsigned char uchCRCLo = 0xFF ;  //\* 低字节初始化值   \*/   
 unsigned uIndex ;    
    
 while (usDataLen--)   
 {   
  uIndex = uchCRCLo ^ *puchMsg++ ;     
  uchCRCLo = uchCRCHi ^ auchCRCHi[uIndex] ;   
  uchCRCHi = auchCRCLo[uIndex];   
 }   
 return (uchCRCHi << 8 | uchCRCLo) ;   
}   


//===========================================================================================
//Modbus功能函数，功能码：01 02 03 04 05 06
//===========================================================================================	
void Modbus_Reduce_ReadFunction01_02_03_04_WriteFunction05_06(uchar ModbusSalveAddress,uchar ModbusFunction,uint RegisterStartAddress,uint RegisterNumberOrData)
{
	unsigned short CRC_Data;
	ModbusSendBuf[0] = ModbusSalveAddress;
	ModbusSendBuf[1] = ModbusFunction;
	ModbusSendBuf[2] = RegisterStartAddress>>8;
	ModbusSendBuf[3] = RegisterStartAddress&0x00ff;
	ModbusSendBuf[4] = RegisterNumberOrData>>8;
	ModbusSendBuf[5] = RegisterNumberOrData&0x00ff;
	CRC_Data				 = CRC16(ModbusSendBuf,6);
	ModbusSendBuf[6] = CRC_Data&0x00ff;
	ModbusSendBuf[7] = CRC_Data>>8;
	if((ModbusFunction == 0x01)||(ModbusFunction == 0x02)||(ModbusFunction == 0x03)||(ModbusFunction == 0x04)||(ModbusFunction == 0x05)||(ModbusFunction == 0x06))
	SendByte(ModbusSendBuf,8);	
}
//===========================================================================================
//打包读多路数字量输出子西数：功能码01
//===========================================================================================	
void ModbusReduce_Read_Multiple_Digital_Output (uchar ModbusSlaveAddress, uint RegisterStartAddress, uint Register_Number) 
{
	Modbus_Reduce_ReadFunction01_02_03_04_WriteFunction05_06(ModbusSlaveAddress,0x01,RegisterStartAddress,Register_Number);
}

//===========================================================================================
//打包读多路数字量输入子函数：功能码02
//===========================================================================================	
void ModbusReduce_Read_Multiple_Digital_Input 	(uchar ModbusSlaveAddress ,uint RegisterStartAddress, uint Register_Number) 
{
	Modbus_Reduce_ReadFunction01_02_03_04_WriteFunction05_06(ModbusSlaveAddress,0x02,RegisterStartAddress,Register_Number);
}
//===========================================================================================
//打包读多路模拟量输出子函数：功能码03
//===========================================================================================	
void ModbusReduce_Read_Multiple_Hold_Registers 	(uchar ModbusSlaveAddress, uint RegisterStartAddress, uint Register_Number)
{
	Modbus_Reduce_ReadFunction01_02_03_04_WriteFunction05_06(ModbusSlaveAddress,0x03,RegisterStartAddress,Register_Number);
}
//===========================================================================================
//打包读多路模拟量输入子西数：功能码04
//===========================================================================================	
void ModbusReduce_Read_Multiple_Analog_Input 	(uchar ModbusSlaveAddress, uint RegisterStartAddress, uint Register_Number)
{
	Modbus_Reduce_ReadFunction01_02_03_04_WriteFunction05_06(ModbusSlaveAddress,0x04,RegisterStartAddress,Register_Number);
}
//===========================================================================================
//打包写单路数字三输出子西数：功能码05
//===========================================================================================	
void ModbusReduce_Write_Single_Digital_Output 	(uchar ModbusSlaveAddress, uint RegisterStartAddress, uint Register_Data)
{
	Modbus_Reduce_ReadFunction01_02_03_04_WriteFunction05_06(ModbusSlaveAddress,0x05,RegisterStartAddress,Register_Data);
}
//===========================================================================================
//打包写单路模拟量输出子函数：功能码06
//===========================================================================================	
void ModbusReduce_Write_Single_Hold_Registers (uchar ModbusSlaveAddress, uint RegisterStartAddress, uint Register_Data)
{
	Modbus_Reduce_ReadFunction01_02_03_04_WriteFunction05_06(ModbusSlaveAddress,0x06,RegisterStartAddress,Register_Data);
}
//===========================================================================================
//打包写多路数字量输出子西数：功能码15
//===========================================================================================	
void ModbusReduce_Write_Multiple_Digital_Output(uchar ModbusSlaveAddress, uint RegisterStartAddress, uint Register_Number, uchar *UcharData)
{
	unsigned short CRC_Data;
	uchar Byte_Count , i;

	Byte_Count= Register_Number/8;
	if(Register_Number%8 != 0)
	Byte_Count++;

	ModbusSendBuf[0] = ModbusSlaveAddress;
	ModbusSendBuf[1] = 0x0f;
	ModbusSendBuf[2] = RegisterStartAddress>>8;
	ModbusSendBuf[3] = RegisterStartAddress&0x00ff;
	ModbusSendBuf[4] = Register_Number>>8;
	ModbusSendBuf[5] = Register_Number&0x00ff;
	ModbusSendBuf[6] = Byte_Count;
	
	for(i= 0;i<Byte_Count;i++) 
		ModbusSendBuf[i+7] = UcharData[i];
	CRC_Data = CRC16(ModbusSendBuf,Byte_Count+7);
	
	ModbusSendBuf[i+7] = CRC_Data&0x00ff;
	ModbusSendBuf[i+8] = CRC_Data>>8;
	SendByte(ModbusSendBuf,Byte_Count+9);	
}
//===========================================================================================
//打包写多路数字量输出子西数：功能码16
//===========================================================================================	
void ModbusReduce_Write_Multiple_Hold_Registers (uchar ModbusSlaveAddress, uint RegisterStartAddress, uint Register_Number, unsigned int  *UintData)
{
	unsigned short CRC_Data;
	uchar Byte_Count , i;

	Byte_Count = Register_Number*2;

	ModbusSendBuf[0] = ModbusSlaveAddress;
	ModbusSendBuf[1] = 0x10;
	ModbusSendBuf[2] = RegisterStartAddress>>8;
	ModbusSendBuf[3] = RegisterStartAddress&0x00ff;
	ModbusSendBuf[4] = Register_Number>>8;
	ModbusSendBuf[5] = Register_Number&0x00ff;
	ModbusSendBuf[6] = Byte_Count;

	for(i= 0;i<Register_Number;i++)
	{
		ModbusSendBuf[i*2+7] = UintData[i]>>8;
		ModbusSendBuf[i*2+8] = UintData[i]&0x00ff;
	}
	CRC_Data = CRC16(ModbusSendBuf,Byte_Count+7);
	
	ModbusSendBuf[Byte_Count+7] = CRC_Data&0x00ff;
	ModbusSendBuf[Byte_Count+8] = CRC_Data>>8;	
	SendByte(ModbusSendBuf,Byte_Count+9);	
}


void DemonstrationReduce(void)
{
	unsigned char i;
if(Demo>3)	Demo = 0;
	switch(Demo)
	{
		case 0:
		{
			ModbusReduce_Read_Multiple_Digital_Output(1,0,10);//Modbus Slave 测试通过
			Demo = 1;
			break;
		}
		case 1:
		{
			ModbusReduce_Read_Multiple_Digital_Input(1,0,10);//Modbus Slave 测试通过
			Demo = 2;
			break;
		}
		case 2:
		{
			ModbusReduce_Read_Multiple_Hold_Registers(1,0,6);//Modbus Slave 测试通过
			Demo = 3;
			break;
		}
		case 3:
		{
			ModbusReduce_Read_Multiple_Analog_Input(1,0,6);//Modbus Slave 测试通过
			Demo = 4;
			break;
		}
		case 4:
		{
			ModbusReduce_Write_Single_Digital_Output(1,9,0xff00);//Modbus Slave 测试通过,注意最高字节为0xff00才能正确置位相应位地址，地址从0开始计算
			Demo = 5;
			break;
		}
		case 5:
		{
			ModbusReduce_Write_Single_Hold_Registers(1,0,2222);//Modbus Slave 测试通过
			Demo = 6;
			break;
		}
		case 6:
		{
			WBDO15[0] = 0x0f;
			WBDO15[1] = 0x01;
			ModbusReduce_Write_Multiple_Digital_Output(1,0,10,WBDO15);//Modbus Slave 测试通过
			Demo = 7;
			break;
		}
		case 7:
		{
			for(i=0;i<6;i++)
			WWAO16[i] = i+10;
			ModbusReduce_Write_Multiple_Hold_Registers(1,0,6,WWAO16);//Modbus Slave 测试通过 保持寄存器
			Demo = 0;
			break;
		}
		default:
		{
			Demo = 0;			
		}
	}
}

uchar ReceState = 0;
uchar ReceiveDataCounter = 0;
uchar ActualDataCounter = 0;
uchar ReceCount = 0;


sbit LCD7=P3^7;    
sbit LCD6=P3^6;    
sbit LCD5=P3^5;     
sbit LCD4=P3^4;   

void DemonstrationUnpark(unsigned char ReceiveData) 
{
//	 unsigned short CRCData;
	switch (ReceState)
	{
		case 0:
			if(ReceiveData == ModbusSendBuf[0] )//从站地址
			{
				
				ReceiveDataCounter = 0;
				ModbusReceBuf[ReceiveDataCounter] = ReceiveData;
				ReceState 	= 1;	
			}
			else
				ReceState = 0;	
			break;
		case 1:
			if(ReceiveData == ModbusSendBuf[1])//Modbus功能码
			{
				ReceiveDataCounter++;
				ModbusReceBuf[ReceiveDataCounter] = ReceiveData;			
				ReceState = 2;
			}
			else
				ReceState = 0;	
			break;
		case 2:																//接收字节数量
			if((ModbusSendBuf[1] == 0x01)||(ModbusSendBuf[1] == 0x02)||(ModbusSendBuf[1] == 0x03)||(ModbusSendBuf[1] == 0x04))//Modbus功能码
			{
				ReceiveDataCounter++;	
				ModbusReceBuf[ReceiveDataCounter] = ReceiveData;	
				ActualDataCounter = ReceiveData;								//接收字节数量						
				ReceState = 3;
				
			}	
			else
				ReceState = 0;	
			break;
		case 3:			
			if(ReceCount<ActualDataCounter)//开始接收数据
			{
				ReceiveDataCounter++;	
				ModbusReceBuf[ReceiveDataCounter] = ReceiveData;							
//				ucharDataBuff[ReceCount]=ReceiveData;
				P0 = ~ModbusReceBuf[3];
				P2 = ~ModbusReceBuf[4];
				ReceCount++;
				
			}
			else//接收完成
			{
//				CRCData = CRC16(ModbusReceBuf,ActualDataCounter+5);	
//				if((ModbusReceBuf[ActualDataCounter+5-2] == (CRCData>>8))&&(ModbusReceBuf[ActualDataCounter+5-1] == (CRCData&0x00ff)))
				{
//					P0 = ~ModbusReceBuf[3];
//					P2 = ~ModbusReceBuf[4];
				}
				//数据CRC校验判断数据完整性
				ReceiveDataCounter = 0;
				ReceCount = 0;
				ReceState = 0;							
			}
//			if(ReceCount == ActualDataCounter)
//			{
//				ReceiveDataCounter = 0;
//				ReceCount = 0;
//				ReceState = 0;							
//			}	
			break;
		default:				 
			ReceState=0;
			break;
	}
}

Modbus.h文件

#ifndef __Modbus_H__
#define __Modbus_H__

#include <STC12C5A_Uart2.H>

typedef unsigned char uchar;
typedef unsigned int uint;

extern unsigned char ModbusSendBuf[];
extern unsigned char ModbusReceBuf[];


/*
//解包读多路数字量输出子函数：功能码01
extern void ModbusUnpark_Read_Multiple_Digtal_Output(void);

//解包读多路数字量输出子函数：功能码02
extern void ModbusUnpark_Read_Multiple_Digtal_Input(void);

//解包读多路数字量输出子函数：功能码03
extern void ModbusUnpark_Read_Multiple_Analog_Output(void);

//解包读多路数字量输出子函数：功能码04
extern void ModbusUnpark_Read_Multiple_Analog_Input(void);

//解包读单路数字量输出子函数：功能码05
extern void ModbusUnpark_Write_Single_Analog_Input(void);

//解包写单路数字量输出子函数：功能码06
extern void ModbusUnpark_Write_Singlee_Analog_Output(void);

//解包写多路数字量输出子函数：功能码15
extern void ModbusUnpark_Write_Multiple_Digtal_Output(void);

//解包写多路数字量输出子函数：功能码16
extern void ModbusUnpark_Write_Multiple_Analog_Output(void);*/

//打包读多路数字量输出子西数：功能码01
extern void ModbusReduce_Read_Multiple_Digital_Output (uchar ModbusSlaveAddress, uint RegisterStartAddress, uint Register_Number) ;
//打包读多路数字量输入子函数：功能码o2
extern void ModbusReduce_Read_Multiple_Digital_Input 	(uchar ModbusSlaveAddress ,uint RegisterStartAddress, uint Register_Number) ;
//打包读多路模拟量输出子函数：功能码03
extern void ModbusReduce_Read_Multiple_Hold_Registers (uchar ModbusSlaveAddress, uint RegisterStartAddress, uint Register_Number);
//打包读多路模拟量输入子西数：功能码04
extern void ModbusReduce_Read_Multiple_Analog_Input 	(uchar ModbusSlaveAddress, uint RegisterStartAddress, uint Register_Number);
//打包写单路数字三输出子西数：功能码g5
extern void ModbusReduce_Write_Single_Digital_Output 	(uchar ModbusSlaveAddress, uint RegisterStartAddress, uint Register_Data);
//打包写单路模拟量输出子函数：功能码06
extern void ModbusReduce_Write_Single_Hold_Registers 	(uchar ModbusSlaveAddress, uint RegisterStartAddress, uint Register_Data);
//打包写多路数字量输出子西数：功能码15
extern void ModbusReduce_Write_Multiple_Digital_Output(uchar ModbusSlaveAddress, uint RegisterStartAddress, uint Register_Number, uchar *UcharData);
//打包写多路数字量输出子西数：功能码16
extern void ModbusReduce_Write_Multiple_Hold_Registers(uchar ModbusSlaveAddress, uint RegisterStartAddress, uint Register_Number, uint *UintData);


extern void DemonstrationReduce(void);//在主程序里调用，发送指定的功能码
extern void DemonstrationUnpark(unsigned char ReceiveData) ;//解包程序在串口中断程序中调用，按字节接收


#endif

发送指定的功能码

DemonstrationReduce();

接收返回数据进行解包程序在串口中断程序中调用

DemonstrationUnpark(unsigned char ReceiveData)；
yonglwin
关注
  • 2
    点赞
  • 踩
  • 39
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ESP32 modbus RTU程序。用arduino IDE开发的ESP32 modbus RTU slave程序
BxbHArtoJr的博客
11-12 1017
首先，我们需要将 ESP32 开发板和模拟器进行串口通信连接，然后使用 Modbus 主站发送读或写命令，查看从站是否能够正确地接收和响应命令。本文详细介绍了如何使用 Arduino IDE 开发 ESP32 Modbus RTU 从站程序，并介绍了该程序在多个项目中的应用。通过本文的学习，你将掌握如何使用 ESP32 Modbus RTU 从站程序，为你的物联网应用提供更强大的通信能力。在开发 ESP32 Modbus RTU 从站程序时，我们采用了直接用子程序编写的方式，而不是使用库文件。
modbus通讯协议编程实例_西门子S7200Ssmart 的modbus通信详细介绍与实例编程
weixin_39948824的博客
12-05 4093
这篇文章介绍的是西门子 smart200PLC从站通信的详细说明以及案例分析。西门子smart200PLC的详细结构图一.西门子S7-200 SMART作为modbus从站检查Micro/WIN SMART Modbus RTU从站指令库(图1)，库中应当包括MBUS_INIT和MBUS_SLAVE两个子程序。西门子smart200的modbus从站库文件图1. 指令树中的库指令2.编...
基于STM32以及modbus——RTU的从机程序（STM32作为从机）
weixin_45739317的博客
04-24 3626
Modbus协议是一种应用层报文传输协议，协议本身并没有定义物理层，所以支持多种电气接口，直接可以理解成他是软件层面的，各种的电气接口比如RS232、RS485、TCP/IP等，他们是硬件层面。他们之间互不影响。3.2 Modbus通讯过程Modbus是一主多从的通信协议Modbus通信中只有一个设备可以发送请求。其他从设备接收主机发送的数据来进行响应，从机是任何外围设备，如I/O传感器，阀门，网络驱动器，或其他测量类型的设备。从站处理信息和使用Modbus将其数据发送给主站。
用c语言写一个modbus RTU 从站的程序
SYUSYORIN的博客
03-15 858
/ 简单的模拟数据。// 定义Modbus RTU响应结构。// 定义Modbus RTU帧结构。// 处理Modbus RTU请求。// 添加其他功能码的处理...
stm32编写Modbus步骤
最新发布
robin__su的博客
06-09 1657
539 //Modbus功能码16处理程序 /////////////////////////////////////////////////////////////////////////////////////////////////已验证程序OK。488 //Modbus功能码03处理程序///////////////////////////////////////////////////////////////////////////////////////已验证程序OK。
mbserver：Golang Modbus服务器（从站）
02-05
Golang Modbus服务器（从站） Golang Modbus服务器（从站）响应以下Modbus功能请求： 位访问： 读取离散输入 读线圈 写单线圈 写多个线圈 16位访问 读取输入寄存器 读取多个保持寄存器 写单个持有寄存器 写多个保持寄存器 支持TCP和串行RTU访问。 服务器在内部为65536个线圈，65536个离散输入，653356个保持寄存器和65536个输入寄存器分配内存。 开始时，所有值都初始化为零。 Modbus请求将按照接收顺序进行处理，并且不会相互重叠/相互干扰。 golang 。 示例Modbus TCP服务器 创建一个Modbus TCP服务器（从站）：
基于OpenHarmony 系统通过Modbus协议读取设备数据
hmxm6的博客
07-02 1013
是一种串行，是Modicon公司（现在的Schneider Electric）于1979年为使用（PLC）通信而发表。Modbus已经成为工业领域通信协议的业界标准（De facto），并且现在是工业之间常用的连接方式。（Remote Terminal Unit 远程终端单元）：这种方式常采用RS-485做为物理层，一般利用芯片的串口实现数据报文的收发，报文数据采用二进制数据进行通信。：这是一种 Modbus 变体版本，使用 TCP/IP 网络进行通信，通过 502 端口进行连接。
基于单片机的modbus从机程序
qq_42989787的博客
08-15 5386
基于新唐M031的modbus从机程序 一 、开发思路 我这里开发的平台是新唐M031，它是Cortex-M0的内核、32位单片机。因为要和上位机进行RS485通讯，所以选用了Modbus-RTU来作为通讯协议。我这是用串口接收中断+定时器中断来接收一帧数据，然后modbus从机程序自己手撸。 二、 Modbus介绍 modbus没什么好介绍的，熟悉下功能码就ok了。上链接 https://www.cnblogs.com/endv/p/8650491.html 三、 串口初始化及...
单片机开发之modbus协议从机篇(最新重构版)
scl8295的博客
04-25 1808
rsp_ok = 0x0 , // 不支持的功能码 rsp_err_cmd = 0x1 , // 寄存器地址错误 rsp_err_reg_addr = 0x2 , // 数据值域错误 rsp_err_value = 0x3 , // 写入失败 rsp_err_write = 0x4 , } slave_rsp_code;/*** @brief 读线圈状态* @brief 读输入状态* @brief 读保持寄存器* @brief 读输入寄存器* @brief 写一个线圈。
IMC100机器人Modbus从站地址表
12-07
Modbus协议定义了数据如何在主站和从站之间传输，其中从站是响应主站请求的设备，而IMC100机器人作为一个Modbus从站，它遵循这一协议进行通信。该协议的对象类型包括离散量输入（Discrete Inputs）、线圈（Coils）、...
STM32_MODBUS_RTU_UART1_12DO_12DI.rar
01-25
功能码01用于读取线圈状态，02用于读取离散输入状态，05用于写单个线圈，06用于写单个寄存器，而15和16则用于批量读写。 4. **详细注释**：代码有详尽的注释，这有助于理解每个部分的功能，对于初学者和调试都非常...
C# 实现与汇川H5U PLC Modbus-TCP通讯示例
07-05
- **线圈读写**：线圈是Modbus中的布尔量，用于控制设备的开关状态。你可以使用`WriteSingleCoil`方法写入一个线圈，`ReadCoils`方法读取一组线圈的状态。 - **寄存器读写**：寄存器是16位的数据存储单元，可用于...
Modbus功能码一览表(最全版)_Modbus功能码一览表_
10-01
2. 功能码0x02（读离散输入状态）：与读线圈状态类似，但用于查询离散输入的状态，这些输入可以是开关、传感器等。 3. 功能码0x03（读保持寄存器）：用于读取远程设备的保持寄存器值。保持寄存器存储数据，即使电源...
C# ModbusRtu 和 ModbusTcp测试源码
02-29
* 1x 是一个只读的触点设备类型（类似于PLC的IO区输入输出开关量）。读状态时的功能码为02H。 * 3x 是一个只读的模拟量设备类型（类似于PLC的AI模拟量）。读取数据的功能码04H。 * 4x是一个可读可写的数据寄存器...
STM32F407 Mobbus RTU从站程序
10-20
STM32F407 Mobbus RTU从站程序是一个专为STM32F407微控制器设计的应用，主要用于实现Modbus RTU通信协议的从站功能。这个程序是针对正点原子STM32F407探索者开发板进行优化的，允许设备与其他Modbus主站设备进行数据...
MODBUS协议中文版
09-30
例如，命令`11 01 00 13 00 25 xx xx`表示要从17号从站读取从地址19开始的37个开关量。从站响应时，会包含返回的字节个数以及实际的开关量数据，每个字节代表8个开关的状态。 2. **读只可读数字量寄存器（输入状态...
Modbus编程实践
XiaoYiDeXiaoYi的博客
12-26 1300
今天我们来做modbus相关的实验
Modbus协议栈应用实例之一：Modbus RTU主站应用
木南创智
07-05 4810
自从开源了我们自己开发的Modbus协议栈之后，有很多朋友建议我针对性的做几个示例。所以我们就基于平时我们的应用整理了几个简单但可以说明基本的应用方法的示例，在这一篇中我们先来使用协议栈实现Modbus RTU主站的示例。 1、何为RTU主站 Modbus协议是一个主从协议，那肯定就有主站和从站之分。所谓主站说的简单一点就是能够主动发起通讯的对象，所以主站就是发起通讯的一方。 对于RTU主站来说，自己并不会产生数据，而是要从从站获取数据。在Modbus RTU协议中从站不会主动向外发送数据，所以需要主
MSP430中MODBUS-RTU的程序编写方式
weixin_43405473的博客
03-01 1566
MSP430中MODBUS-RTU程序的编写方法
modbus rtu主站读取寄存器数据
07-27
对于Modbus RTU主站读取寄存器数据，你需要使用串口通信与设备进行通信，并按照Modbus协议进行数据的读取操作。以下是一个示例代码，仅供参考： ```python import serial import struct # 打开串口 ser = serial.Serial('/dev/ttyUSB0', 9600, timeout=0.5) # Modbus函数码 READ_HOLDING_REGISTERS = 0x03 # 设备地址 device_address = 0x01 # 寄存器起始地址 register_address = 0x0000 # 寄存器数量 register_count = 10 # 构造Modbus RTU请求帧 request_frame = struct.pack('>BBHH', device_address, READ_HOLDING_REGISTERS, register_address, register_count) # 发送请求帧 ser.write(request_frame) # 读取响应帧 response_frame = ser.read(5 + 2 * register_count) # 解析响应帧 response_data = struct.unpack('>BB' + 'H' * register_count, response_frame) # 提取寄存器数据 register_data = response_data[2:] print("读取到的寄存器数据：", register_data) # 关闭串口 ser.close() ``` 请注意，上述代码中的串口号`/dev/ttyUSB0`和波特率`9600`需要根据你的实际情况进行修改。另外，如果你使用的是Windows系统，串口号可能是类似`COM1`的格式。 此外，你还需要安装pySerial库来进行串口通信。你可以使用以下命令进行安装： ``` pip install pyserial ``` 希望以上信息对你有所帮助！如有任何问题，请随时提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值