devbox
羊村懒王
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

基于STM32以及modbus——RTU的从机程序（STM32作为从机）_st32 modusrtu从设备

作者：羊村懒王 | 2024-05-28 07:46:12

赞

踩

st32 modusrtu从设备

1.前言

        因项目中需要用到485电路以及多设备通讯，采用Modbus协议通讯方式，本文写的目的就是记录笔记也提供给初学者一点参考。里面的内容可能会有错误，仅供参考。

2.485电路

上图是项目中的电路，也算一个最基本的485电路，没什么好讲的，这个博主讲的不错，可以参考他的。

终于讲透了，史上最详细的RS485自动收发电路你一定要掌握-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/qq_39400113/article/details/122387133?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522171393570316800227442090%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=171393570316800227442090&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~top_positive~default-2-122387133-null-null.nonecase&utm_term=485%E7%94%B5%E8%B7%AF&spm=1018.2226.3001.4450

3.Modbus协议

学习以前参考以下博文链接：

STM32+RS485+Modbus-RTU（主机模式+从机模式）-标准库/HAL库开发_stm32modbus主机-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/qq_37281984/article/details/122739968

3.1 Modbus协议简介

Modbus协议是一种应用层报文传输协议，协议本身并没有定义物理层，所以支持多种电气接口，直接可以理解成他是软件层面的，各种的电气接口比如RS232、RS485、TCP/IP等，他们是硬件层面。他们之间互不影响。

3.2 Modbus通讯过程

Modbus是一主多从的通信协议

Modbus通信中只有一个设备可以发送请求。其他从设备接收主机发送的数据来进行响应，从机是任何外围设备，如I/O传感器，阀门，网络驱动器，或其他测量类型的设备。从站处理信息和使用Modbus将其数据发送给主站。

也就是说,不能Modbus同步进行通信,主机在同一时间内只能向一个从机发送请求，总线上每次只有一个数据进行传输,即主机发送,从机应答,主机不发送,总线上就没有数据通信。

从机不会自己发送消息给主站，只能回复从主机发送的消息请求。

3.3  Modbus功能码

Modbus协议同时规定了二十几种功能码，但是常用的只有3种，用于对存储区的读写，如下表所示：

 我们主要就是用到03h读取从机寄存器的数据，06h对从机指定寄存器写入指定数据，10h对从机多个寄存器写入数据。

3.4 Modbus协议格式

我们主要就是学习它的协议格式，主要用到3种功能码，也就对应与3种发送数据的格式。

3.4.1 03H功能码-读取数据-协议格式

比如 ：主机发送 01 03 00 01 00 01 D5 CA

主机一共发送8个字节。

0x01:表示主机要与从机地址是0x01的设备进行通讯

0x03:功能码，代表我们发送这个指令的作用是什么，03表示我们要读取从机的数据

0x00:要读取从机寄存器地址的高位

0x01:要读取从机寄存器地址的低位

0x00:要读取从机寄存器数量的高位

0x01:要读取从机寄存器数量的低位

D5:前6位数据效验的低位

CA:前6位数据效验的高位

总得来说这段代码的含义是：查询从机地址为0x01的0x0001寄存器地址的0x0001个数据。

从机收到这段协议后，应回复如下格式 01 03 02 00 03 F8 48

从机一共发送7个字节

0x01:表示主机要与从机地址是0x01的设备进行通讯

0x03:功能码，代表我们发送这个指令的作用是什么，03表示我们要读取从机的数据

0x02:返回的数据个数(要读取的寄存器个数*2)——>返回数据的字节都是寄存器的2倍

0x00:从机返回数据的高位

0x03:从机返回数据的低位

F8 48：前面几位数据的效验码

3.4.2 06H功能码-写入数据-单寄存器-协议格式

比如 ：主机发送 01 06 00 01 00 17 98 04

主机一共发送8个字节。

0x01:表示主机要与从机地址是0x01的设备进行通讯

0x03:功能码，代表我们发送这个指令的作用是什么，06表示我们要向从机写入数据

0x00:要写入从机寄存器地址的高位

0x01:要写入从机寄存器地址的低位

0x00:要写入从机数据的高位

0x17:要写入从机数据的低位

98 04:前6位数据效验码

总得来说这段代码的含义是：向从机地址为0x01的0x0001地址写入数据0x0017

从机回复格式：01 06 00 01 00 17

从机回复的内容和主机发送的一样。

3.4.3 10H功能码-写入数据-多个寄存器-协议格式

比如 ：主机发送 : 01 10 00 05 00 02 04 01 02 03 04 92 9F

主机一共发送11个字节。

0x01:表示主机要与从机地址是0x01的设备进行通讯

0x10:功能码，10表示我们要向从机多个寄存器写入数据

0x00:要写入从机寄存器地址的起始地址的高位

0x05:要写入从机寄存器地址的起始地址的低位

0x00:要写入寄存器个数的高位

0x02:要写入寄存器个数的低位

0x04:要写入的字节数

01 02：写入第一个寄存器的数据

03 04：写入第二个寄存器的数据

92 9F:前面数据效验码

从机回复：01 10 00 05 00 02 51 C9

从机返回的数据可以理解为就是主机发送的前6个字节加上自己数据的效验码。表面从机01从地址0x0005开始写入2个寄存器数据。

到这样发送数据协议格式介绍完毕。

4.STM32+485电路+Modbus协议代码

Modbus只是个协议，485电路时硬件层面，通讯还是串口通讯。

连线就是485的A B连接485转USB的A B脚，485芯片的连接如上面电路所示，连接STM32串口1。

4.1 STM32串口配置

4.1.1 串口初始化

  1. void Serial_Init(void)
  2. {
  3. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
  4. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
  5. 	
  6. 	GPIO_InitTypeDef GPIO_InitStructure;
  7. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  8. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
  9. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  10. 	GPIO_Init(GPIOA, &GPIO_InitStructure);
  11. 	
  12. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
  13. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
  14. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  15. 	GPIO_Init(GPIOA, &GPIO_InitStructure);
  16. 	
  17. 	USART_InitTypeDef USART_InitStructure;
  18. 	USART_InitStructure.USART_BaudRate = 9600;
  19. 	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
  20. 	USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;
  21. 	USART_InitStructure.USART_Parity = USART_Parity_No;
  22. 	USART_InitStructure.USART_StopBits = USART_StopBits_1;
  23. 	USART_InitStructure.USART_WordLength = USART_WordLength_8b;
  24. 	USART_Init(USART1, &USART_InitStructure);
  25. 	
  26. 	USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
  27. 	
  28. 	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
  29. 	
  30. 	NVIC_InitTypeDef NVIC_InitStructure;
  31. 	NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
  32. 	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  33. 	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
  34. 	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
  35. 	NVIC_Init(&NVIC_InitStructure);
  36. 	
  37. 	USART_Cmd(USART1, ENABLE);
  38. }

4.1.2 串口发送封装代码

我们发送数据的格式主要就是以数组的方式。

  1. void Serial_SendByte(uint8_t Byte)
  2. {
  3. 	USART_SendData(USART1, Byte);
  4. 	while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
  5. }
  6.  
  7. void Serial_SendArray(uint8_t *Array, uint16_t Length)
  8. {
  9. 	uint16_t i;
  10. 	for (i = 0; i < Length; i ++)
  11. 	{
  12. 		Serial_SendByte(Array[i]);
  13. 	}
  14. }

4.1.3 串口中断接收

主要是将接收到的数据依次存放到对应的数组中，当modbus.reflag==1表示还有数据正在处理中，反之则进行数据存储，当开始存储第二个数据时开启定时器计时，主要目的判断接收数据是否完毕，如果超过一段时间没有数据，则表明这一次数据接收完毕

  1. void USART1_IRQHandler(void)
  2. {
  3. 	u8 st,Res;
  4.  	st = USART_GetITStatus(USART1, USART_IT_RXNE);
  5.  	if(st == SET)//接收中断
  6.  	{
  7.  		Res =USART_ReceiveData(USART1);	//读取接收到的数据
  8. 		
  9.  	 
  10.  	 if( modbus.reflag==1)  //有数据包正在处理
  11.  	  {
  12.  		   return ;
  13.  		}		
  14.  	  modbus.rcbuf[modbus.recount++] = Res;
  15. 		//USART_SendData(USART2, Res);//接受到数据之后返回给串口1
  16.  		modbus.timout = 0;
  17.  		if(modbus.recount == 1)  //已经收到了第二个字符数据
  18.  		{
  19.  		  modbus.timrun = 1;  //开启modbus定时器计时
  20.  		}
  21.  	}	
  22. }

4.2定时器2配置

4.2.1 定时器初始化

配置定时器1ms进入一次中断。这里主要说明下1ms怎么配置的。

定时时间 = [(PSC +1) *(ARR+1)]/72M

这里的PSC指定就是分频倍数，ARR是溢出数，72M是时钟频率。

  1. void Timer_Init(void)
  2. {
  3. 	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
  4. 	
  5. 	TIM_InternalClockConfig(TIM2);
  6. 	
  7. 	TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;
  8. 	TIM_TimeBaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV1;
  9. 	TIM_TimeBaseInitStructure.TIM_CounterMode = TIM_CounterMode_Up;
  10. 	TIM_TimeBaseInitStructure.TIM_Period = 1000 - 1;
  11. 	TIM_TimeBaseInitStructure.TIM_Prescaler = 72 - 1; //定时1ms
  12. 	TIM_TimeBaseInitStructure.TIM_RepetitionCounter = 0;
  13. 	TIM_TimeBaseInit(TIM2, &TIM_TimeBaseInitStructure);
  14. 	
  15. 	TIM_ClearFlag(TIM2, TIM_FLAG_Update);
  16. 	TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);
  17. 	
  18. 	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
  19. 	
  20. 	NVIC_InitTypeDef NVIC_InitStructure;
  21. 	NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;
  22. 	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  23. 	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
  24. 	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
  25. 	NVIC_Init(&NVIC_InitStructure);
  26. 	
  27. 	TIM_Cmd(TIM2, ENABLE);
  28. }

4.2.2 定时中断

定时器设置1ms进入中断1次，运行时间不为0的情况下开始计时，超过8ms则表明这一次接收数据完毕，将数据接收结束标志位置1处理（modbus.reflag = 1），当数据接收完毕，则STM32可以对接收到的数据进行数据分析和处理执行相应的操作了

  1. void TIM2_IRQHandler(void)
  2. {
  3. 	if (TIM_GetITStatus(TIM2, TIM_IT_Update) == SET)
  4. 	{
  5. 		if(modbus.timrun != 0)//运行时间！=0表明
  6.  		 {
  7.  		  modbus.timout++;
  8.  		  if(modbus.timout >=8)
  9.  		  {
  10.  		   modbus.timrun = 0;
  11.  			 modbus.reflag = 1;//接收数据完毕
  12.  		  }
  13.  			
  14.  		 }
  15. 		TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
  16. 	
  17. 	}
  18. }

4.3 Modbus协议处理代码

4.3.1 Modbus数据结构体

STM32作为从机时需要用到的数据。

  1. typedef struct 
  2.  {
  3.  	//作为从机时使用
  4.   u8  myadd;        //本设备从机地址
  5.  	u8  rcbuf[100];   //modbus接受缓冲区
  6.  	u8  timout;       //modbus数据持续时间
  7.  	u8  recount;      //modbus端口接收到的数据个数
  8.  	u8  timrun;       //modbus定时器是否计时标志
  9.  	u8  reflag;       //modbus一帧数据接受完成标志位
  10.  	u8  sendbuf[100]; //modbus接发送缓冲区
  11.  	
  12.  }MODBUS;

4.3.2 功能码03H处理函数

  1. void Modbus_Func3(void)
  2.  {
  3.  	uint16_t Regadd,Reglen;
  4.  	uint8_t i,j;	
  5.  	//得到要读取寄存器的首地址
  6.  	Regadd = modbus.rcbuf[2]*256+modbus.rcbuf[3];//读取的首地址
  7.  	//得到要读取寄存器的数据长度
  8.  	Reglen = modbus.rcbuf[4]*256+modbus.rcbuf[5];//读取的寄存器个数
  9.  	//发送回应数据包
  10.  	i = 0;
  11.  	modbus.sendbuf[i++] = modbus.myadd;      //ID号：发送本机设备地址
  12.  	modbus.sendbuf[i++] = 0x03;              //发送功能码
  13. 	modbus.sendbuf[i++] = ((Reglen*2)%256);   //返回字节个数
  14.  	for(j=0;j<Reglen;j++)                    //返回数据
  15.  	{
  16.  		//reg是提前定义好的16位数组（模仿寄存器）
  17. 		modbus.sendbuf[i++] = Reg[Regadd+j]/256;//高位数据
  18.  		modbus.sendbuf[i++] = Reg[Regadd+j]%256;//低位数据
  19.  	}
  20.  	Modbus_CRC16(modbus.sendbuf,i);    //计算要返回数据的CRC
  21. 	modbus.sendbuf[i++] = Modbus_RCR[0];
  22. 	modbus.sendbuf[i++] = Modbus_RCR[1];
  23.  	//数据包打包完成
  24.  	// 开始返回Modbus数据
  25.  	
  26. 	Serial_SendArray(modbus.sendbuf,i);//发送从机数据
  27.  }
 4.3.2.1 实验过程1

串口助手发送： 01 03 00 03 00 01 串口助手会自动计算前面的效验值，一起发送给STM32从机。查询寄存器地址为0x0003的1个数据 。

 

从机返回的是 ：2个字节，指定地址的数据为0x0004。数据返回没问题

现在查询2个数据，发送 01 03 00 03 00 02 

从机返回的是 ：4个字节，指定地址的数据为0x0004和0x0005，数据返回没问题

4.3.3 功能码06H处理函数

  1. void Modbus_Func6(void)
  2. {
  3. 	u16 Regadd;//地址16位
  4.  	u16 val;//值
  5.  	u16 i;
  6.  	i=0;
  7. 	Regadd=modbus.rcbuf[2]*256+modbus.rcbuf[3];  //得到要修改的地址 
  8.  	val=modbus.rcbuf[4]*256+modbus.rcbuf[5];     //修改后的值（要写入的数据）
  9.  	Reg[Regadd]=val;  //修改本设备相应的寄存器
  10.  	
  11.  	//以下为回应主机
  12.  	modbus.sendbuf[i++]=modbus.myadd;//本设备地址
  13. 	modbus.sendbuf[i++]=0x06;        //功能码 
  14. 	modbus.sendbuf[i++]=Regadd/256;//写入的地址
  15.  	modbus.sendbuf[i++]=Regadd%256;
  16.  	modbus.sendbuf[i++]=val/256;//写入的数值
  17.  	modbus.sendbuf[i++]=val%256;
  18.  	Modbus_CRC16(modbus.sendbuf,i);//获取crc校验位
  19.    //crc校验位加入包中
  20. 	modbus.sendbuf[i++] = Modbus_RCR[0];
  21. 	modbus.sendbuf[i++] = Modbus_RCR[1];
  22.  
  23.  	//数据发送包打包完毕
  24.  
  25. 	Serial_SendArray(modbus.sendbuf,i);//发送从机数据
  26. }
 4.3.3.1 实验过程2

发送前我们先查询0x0001的本来的数据为多少，再进行写入，写入后再查询是否写入成功。

串口助手首先发送：01 03 00 01 00 01 

串口助手再发送：01 06 00 01 00 06 

串口助手最后发送：01 03 00 01 00 01 

 首先回复是0x0001寄存器的数据为 0x0002

其次修改0x0001寄存器数据为0x0006

最后查询0x0001寄存器的数据就是为0x0006，表明数据写入成功。

4.3.4 功能码10H处理函数

  1. //这是往多个寄存器器中写入数据
  2.  //功能码0x10指令即十进制16
  3. void Modbus_Func16(void)
  4. {
  5. 	uint16_t Regadd;//地址16位
  6. 	uint16_t Reglen;
  7. 	uint16_t i;
  8. 	Regadd=	modbus.rcbuf[2]*256+modbus.rcbuf[3];  //要修改内容的起始地址
  9.  	Reglen = modbus.rcbuf[4]*256+modbus.rcbuf[5];//读取的寄存器个数
  10. 	
  11. 	for(i=0;i<Reglen;i++)//向指定地址写数据
  12. 	{
  13. 		//接收数据的第7位开始是数据接收位
  14. 		Reg[Regadd+i] = modbus.rcbuf[7+i*2]*256 + modbus.rcbuf[8+i*2];
  15. 	}
  16. 	//数据写入完成，下面进行打包回复数据
  17. 	
  18. 	//回应主机的内容
  19. 		modbus.sendbuf[0]=modbus.rcbuf[0];//本设备地址
  20.  		modbus.sendbuf[1]=modbus.rcbuf[1];  //功能码 
  21.  		modbus.sendbuf[2]=modbus.rcbuf[2];//写入的高位地址
  22.  		modbus.sendbuf[3]=modbus.rcbuf[3];//写入的低位地址
  23.  		modbus.sendbuf[4]=modbus.rcbuf[4]; //寄存器个数高位
  24.  		modbus.sendbuf[5]=modbus.rcbuf[5];//寄存器个数低位
  25.  		Modbus_CRC16(modbus.sendbuf,6);//获取crc校验位
  26. 		modbus.sendbuf[6]=Modbus_RCR[0];  //crc校验位加入包中
  27. 		modbus.sendbuf[7]=Modbus_RCR[1];  //crc校验位加入包中
  28.  
  29.  		//数据发送包打包完毕
  30. 	
  31. 		//发送数据包
  32. 		Serial_SendArray(modbus.sendbuf,8);
  33. }
 4.3.4.1 实验过程3

发送前我们先查询0x0001寄存器地址的2个数据为多少，再进行写入，写入后再查询是否写入成功。

串口助手首先发送：01 03 00 01 00 02 

串口助手再发送：01 10 00 01 00 02 04  00 08 00 90 

串口助手最后发送：01 03 00 01 00 02 

 首先回复是0x0001起始寄存器的数据为 0x0002， 0x0003

其次修改0x0001起始寄存器数据为0x0008，0x0009

最后查询0x0001起始寄存器的数据就是为0x0008，0x0009，表明数据写入成功。

4.3.5 效验函数

随便百度的一个。

  1. unsigned int Modbus_CRC16(unsigned char *data, unsigned int len)
  2. {
  3.     unsigned int i, j, tmp, CRC16;
  4.  
  5.     CRC16 = 0xFFFF;             //CRC寄存器初始值
  6.     for (i = 0; i < len; i++)
  7.     {
  8.         CRC16 ^= data[i];
  9.         for (j = 0; j < 8; j++)
  10.         {
  11.             tmp = (unsigned int)(CRC16 & 0x0001);
  12.             CRC16 >>= 1;
  13.             if (tmp == 1)
  14.             {
  15.                 CRC16 ^= 0xA001;    //异或多项式
  16.             }
  17.         }
  18.     }
  19. 	//低位在前
  20. 		Modbus_RCR[0] = (unsigned char) (CRC16 & 0x00FF);
  21. 		Modbus_RCR[1] = (unsigned char) ((CRC16 & 0xFF00)>>8);
  22.     return CRC16;
  23. }

4.3.6 事件处理函数

只有到数据接收完成才能进行数据处理

  1. 首先判断自主计算的CRC校验位和接收到数据的校验位是否一致
  2. 其次判断从机地址是不是自己的地址
  3. 数据传输正确且从机地址正确的情况下再根据不同的功能码去执行对应的函数操作
  1. void Modbus_Event(void)
  2.  {
  3.  	//uint16_t crc,rccrc;//crc和接收到的crc
  4.  	//没有收到数据包
  5.    if(modbus.reflag == 0)  //如果接收未完成则返回空
  6.  	{
  7. 			
  8.  	   return;
  9.  	}
  10.  	//收到数据包(接收完成)
  11.  	//通过读到的数据帧计算CRC
  12.  	//参数1是数组首地址，参数2是要计算的长度（除了CRC校验位其余全算）
  13.  	Modbus_CRC16(modbus.rcbuf,modbus.recount-2); //获取CRC校验位
  14.  	// 读取数据帧的CRC
  15. 	//printf("%x","%x",(crc & 0x00FF),((crc & 0xFF00)>>8));
  16.  
  17.  	//rccrc = modbus.rcbuf[modbus.recount-2]*256+modbus.rcbuf[modbus.recount-1];//计算读取的CRC校验位
  18. 	
  19.  	//等价于下面这条语句
  20.  	//rccrc=modbus.rcbuf[modbus.recount-1]|(((u16)modbus.rcbuf[modbus.recount-2])<<8);//获取接收到的CRC
  21.  	if(Modbus_RCR[0] == modbus.rcbuf[modbus.recount-2] && Modbus_RCR[1] == modbus.rcbuf[modbus.recount-1]) //CRC检验成功 开始分析包
  22.  	{	
  23.  	   if(modbus.rcbuf[0] == modbus.myadd)  // 检查地址是否时自己的地址
  24.  		 {
  25.  		   switch(modbus.rcbuf[1])   //分析modbus功能码
  26.  			 {
  27.  			   case 0:             break;
  28.  				 case 1:             break;
  29.  				 case 2:             break;
  30.  				 case 3:      Modbus_Func3();      break;//这是读取寄存器的数据
  31.  				 case 4:             break;
  32.  				 case 5:             break;
  33. 				case 6:      Modbus_Func6();      break;//这是写入单个寄存器数据
  34.  				 case 7:             break;
  35.  				 case 8:             break;
  36.  				 case 9:             break;
  37.  				 case 16:     Modbus_Func16(); 			break;//写入多个寄存器数据
  38.  			 }
  39.  		 }
  40.  		 else if(modbus.rcbuf[0] == 0) //广播地址不予回应
  41.  		 {
  42.  		    
  43.  		 }	 
  44.  	}	
  45. 		modbus.recount = 0;//接收计数清零
  46. 		modbus.reflag = 0; //接收标志清零
  47.  }

 4.3.7 Modbus初始化

定义一个Reg数组，来模拟STM32作为从机寄存器的数据。

将STM32作为从机的地址为0x01

  1. uint16_t  Reg[] =
  2. {
  3. 	0x0001,
  4. 	0x0002,
  5. 	0x0003,
  6. 	0x0004,
  7. 	0x0005,
  8. }; 
  9. void Modbus_Init(void)
  10.  {
  11. 	modbus.myadd = 0x01; //从机设备地址为
  12. 	modbus.timrun = 0;    //modbus定时器停止计算
  13.  }

4.4 main函数

  1. int main(void)
  2. {
  3. 	
  4. 	Serial_Init();
  5. 	Timer_Init();
  6. 	Modbus_Init();
  7. 	
  8. 	while (1)
  9. 	{
  10. 		Modbus_Event();
  11. 	}
  12. }

5.总结

到此，STM32作为从机的代码写完了，也验证成功。下一部分将记录STM32作为主机给另外的一个STM32作为从机进行通讯。以上内容仅供参考。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/636337
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号