485 Modbus协议程序实例（串口中断接收/发送）

已于 2022-03-26 11:05:37 修改
阅读量6.2k 收藏 27
点赞数 4
分类专栏： 通讯 文章标签： stm32
于 2022-02-11 18:09:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/thornbird_echo/article/details/122886197
版权

基于串口接收中断与发送中断完成的485通讯实例

优点：逻辑简单，响应快速。

缺点：容易受到单片机本身资源占用以及运行环境干扰的影响出现丢包情况。

对应程序初始化后在主循环运行Uart1_Communicate即可。

使用联合union来将字分解成组成这个对象的各个字节或位。

    typedef 
	union{
		struct {
			u8	b0:1;//定义位域长为1
			u8	b1:1;
			u8	b2:1;
			u8	b3:1;
			u8	b4:1;
			u8	b5:1;
			u8	b6:1;
			u8	b7:1;
			u8	b8:1;
			u8	b9:1;
			u8	b10:1;
			u8	b11:1;
			u8	b12:1;
			u8	b13:1;
			u8	b14:1;
			u8	b15:1;
		} bit;
		struct{
			u8	low;	/* low	8 bit */
			u8	high;	/* high 8 bit */
		}byte;
		u16 	word;
	}word_def;

    #define TX_MODE			(GPIOB->ODR |= GPIO_Pin_8)
	#define RX_MODE			(GPIOB->ODR &= ~GPIO_Pin_8)
	
	word_def UartStateAdr;
	#define ReceiveVerifyFlag						UartStateAdr.bit.b3//接收数据需求校验标志位
	#define NeedReplyFlag						UartStateAdr.bit.b2//接收处理完毕需求回复标志
	#define ReceiveCompletedFlag				UartStateAdr.bit.b1//接收完毕标志
	#define ReceiveHeaderFlag					UartStateAdr.bit.b0//数据帧头接收标志

	typedef struct     //对应存放寄存器数据的数组坐标的结构体
	{
	  u8 A;
	  u8 B;
	} ModbusRegs_Coordinate;  

	ModbusRegs_Coordinate  G_Coordinate;//数组坐标结构体变量（全局）
	
	u8 RXmodeFlag;//大循环中持续置位GPIO，避免在其他实践中遇到在中断直接操作GOIO运行后却未置位的情况
	u8 IDcode=0x02;//Modbus协议从机ID
	u8 Functioncode;//接收的功能码
	u8 G_SendByteTable_8u[256];//发送区数组
	u8 G_BufferReceive_8u[256];//接收缓冲区
	u8 G_ReceiveByteTable[256];//校验后实际接收数据
	u8 ReceiveDataTemp;//接收传递变量
	
	
	u16 G_ModbusRegs_16u[6][128];  //定义700个寄存器
    u16 Read_RegAddress;//读取寄存器起始地址
	u16 Read_ProcessRegAddress;//读取寄存器过程中地址
	u16 Read_RegNum;//读取寄存器的个数
	u16 Write_RegAddress;//写寄存器地址 或 写多个寄存器起始地址
	u16 Write_ProcessRegAddress;//写寄存器地址 或 写多个寄存器末尾地址
	u16 Write_RegNum;//写寄存器的个数
	u16 ReceivePacketState;//接收数据位（无效数据、接收校验完毕清零，接收中按数据长度自增）
	u16 ReceiveLength=8;//接收数据长度初始化为8
	u16 SendPacketState;//发送数据位
	u16 SendLength;//发送数据长度
	u16 CRC_Check;//根据前面数据计算获得的校验值（与接收到的校验比较验证）
	u16 SendCRC_Check;//发送数据CRC校验码
/*v将寄存器地址至数组行列坐标转化v*/
	ModbusRegs_Coordinate RegCoordinateCalcuate(u16 Address)
	{
		ModbusRegs_Coordinate  Coordinate;
		Coordinate.A=(Address>>7);//第A+1行
		Coordinate.B=(Address%128);//第B+1列
		return (Coordinate);
	}
/*^将寄存器地址至数组行列坐标转化^*/

	
/*vCRC校验计算v*/
	u16 Crc_cal_value(u8 *data_value,u8 data_length)
	{
		u16  crc_value=0xFFFF;
		u8	i,j;
		for (j=0; j<data_length; j++)
		{
			crc_value = crc_value ^ *data_value;
			data_value++;
			for (i=0; i<8; i++)
			{
				if(crc_value & 0x0001)
				{
					crc_value = crc_value >> 1;
					crc_value = crc_value ^ 0xa001;
				}
				else
				{
					crc_value = crc_value >> 1;
				}
			}
		}
		return(crc_value);
	}	
/*^CRC校验计算^*/
	
	void Uart1_IO_Init(void)
	{
		GPIO_InitTypeDef GPIO_InitStruct;
		RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);
		RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOC, ENABLE);
		
		GPIO_InitStruct.GPIO_Pin  = GPIO_Pin_8;					//485使能端口
		GPIO_InitStruct.GPIO_Mode = GPIO_Mode_OUT;
		GPIO_InitStruct.GPIO_Speed = GPIO_Speed_Level_3;
		GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
		GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;
		GPIO_Init(GPIOB,&GPIO_InitStruct);
		
		GPIO_InitStruct.GPIO_Pin  = GPIO_Pin_13;				//LED
		GPIO_InitStruct.GPIO_Mode = GPIO_Mode_OUT;
		GPIO_InitStruct.GPIO_Speed = GPIO_Speed_Level_3;
		GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
		GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
		GPIO_Init(GPIOC,&GPIO_InitStruct);
		//设置复用功能的类型
		GPIO_PinAFConfig(GPIOB,GPIO_Pin_6,GPIO_AF_0);
		GPIO_PinAFConfig(GPIOB,GPIO_Pin_7,GPIO_AF_0);
		//复用开漏输出
		GPIO_InitStruct.GPIO_Pin   = GPIO_Pin_6;
		GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_AF;
		GPIO_InitStruct.GPIO_Speed = GPIO_Speed_Level_3;
		GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
		GPIO_InitStruct.GPIO_PuPd  = GPIO_PuPd_NOPULL;
		GPIO_Init(GPIOB,&GPIO_InitStruct);
		//复用输入上拉
		GPIO_InitStruct.GPIO_Pin = GPIO_Pin_7;
		GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;
		GPIO_InitStruct.GPIO_Speed = GPIO_Speed_Level_3;
		GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
		GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
		GPIO_Init(GPIOB,&GPIO_InitStruct);
		RX_MODE;
	}

	void Uart1_Init(void)
	{
		NVIC_InitTypeDef NVIC_InitStructure;
		//启动外围时钟
		RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
		//8倍过采样模式
		USART1->CR1 = (1<<15);
		//关闭溢出检测
		USART1->CR3 = (1<<12);
		//波特率的计算
		// BORD = Fpclk/(8*(2 - OVER8)*DIV)
		//目标波特率 9600 DIV = 625
		//2400 DIV = 2500

		USART1->BRR = (52<<4);

		//使能串口,清空TC标志
		USART1->CR1 |=(1<<0);						// 使能串口
		USART1->CR1 |=(1<<3)+(1<<2);				// 允许接收和发送
		USART1->ICR |=(1<<6);						// 清除发送完成标志
		/* Enable the USARTx Interrupt */
		NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
		NVIC_InitStructure.NVIC_IRQChannelPriority = 0x03;
		NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
		NVIC_Init(&NVIC_InitStructure);
		USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
		USART_ITConfig(USART1, USART_IT_TC, ENABLE);
	}
	
    
	void Uart1_Communicate(void)
	{
		u8 Cycle;//缓冲区传送确认区的过程变量
		u8 a,b;//a用于写寄存器的过程变量，b用于读寄存器的过程变量
		u8 timecnt;//RX_Mode转TX_Mode的延时（必须有延时，否则当485芯片高阻态建立较慢时通讯数据会紊乱）
		
		/*v485状态再置位v*/
		if(RXmodeFlag)RX_MODE;//避免在中断中运行GPIOB->ODR &= ~GPIO_Pin_8后不置位的情况
		/*v485状态再置位v*/	
		/*v数据校验v*/
		if(ReceiveVerifyFlag)
		{
			CRC_Check=Crc_cal_value(G_BufferReceive_8u,ReceiveLength-2);
			if( CRC_Check == (G_BufferReceive_8u[ReceiveLength-2]+G_BufferReceive_8u[ReceiveLength-1]*256) )//校验正确
			{
				for(Cycle = 0; Cycle < ReceiveLength; Cycle++)
							{
								G_ReceiveByteTable[Cycle] = G_BufferReceive_8u[Cycle];
							}
				ReceiveCompletedFlag=1;
			}
			ReceivePacketState=0;
			ReceiveVerifyFlag=0;
		}
		/*^数据校验^*/
		/*v接收数据处理v*/
		if(ReceiveCompletedFlag)
		{
			switch(Functioncode)
			{
				case 0x03://读
				{
					Read_RegAddress=G_BufferReceive_8u[2]*256+G_BufferReceive_8u[3];
					Read_RegNum=G_BufferReceive_8u[4]*256+G_BufferReceive_8u[5];
					//读数据赋值发送缓存数组在发送处理中
					break;
				}
				case 0x04://读
				{
					Read_RegAddress=G_BufferReceive_8u[2]*256+G_BufferReceive_8u[3];
					Read_RegNum=G_BufferReceive_8u[4]*256+G_BufferReceive_8u[5];
					//读数据赋值发送缓存数组在发送处理中
					break;
				}
				case 0x06://写单个
				{
					Write_RegAddress=G_BufferReceive_8u[2]*256+G_BufferReceive_8u[3];
					Write_RegNum=1;
					G_Coordinate = RegCoordinateCalcuate(Write_RegAddress);
					G_ModbusRegs_16u[G_Coordinate.A][G_Coordinate.B]=G_BufferReceive_8u[4]*256+G_BufferReceive_8u[5] ;
					break;
				}
				case 0x10://写n个(起始地址与寄存器数量在中断中已经计算)
				{
					Write_ProcessRegAddress=Write_RegAddress;
					for(a=0;a<Write_RegNum;a++)
					{
						G_Coordinate = RegCoordinateCalcuate(Write_ProcessRegAddress);
						G_ModbusRegs_16u[G_Coordinate.A][G_Coordinate.B]=G_BufferReceive_8u[a*2+7]*256+G_BufferReceive_8u[a*2+8] ;
						Write_ProcessRegAddress++;
					}				
					break;
				}
				default :
				{
					break;
				}
			}
			NeedReplyFlag=1;
			ReceiveCompletedFlag=0;
		}
		/*^接收数据处理^*/
		/*v发送处理v*/
		if(NeedReplyFlag)
		{
			RXmodeFlag=0;
			switch(Functioncode)
			{
				case 0x03://读的回复
				{
					SendLength=Read_RegNum*2+5;
					SendPacketState=1;
					Read_ProcessRegAddress = Read_RegAddress;
					G_SendByteTable_8u[0]=IDcode;
					G_SendByteTable_8u[1]=0x03;
					G_SendByteTable_8u[2]=(u8)(Read_RegNum*2);
					for(b=0;b<Read_RegNum;b++)
					{
						G_Coordinate = RegCoordinateCalcuate(Read_ProcessRegAddress);
						G_SendByteTable_8u[b*2+3]=(u8)(G_ModbusRegs_16u[G_Coordinate.A][G_Coordinate.B]>>8);
						G_SendByteTable_8u[b*2+4]=(u8)G_ModbusRegs_16u[G_Coordinate.A][G_Coordinate.B];
						Read_ProcessRegAddress++;
					}	
					SendCRC_Check = Crc_cal_value(G_SendByteTable_8u,SendLength-2);
					G_SendByteTable_8u[SendLength-2]=(u8)(SendCRC_Check);//RCR校验计算出来的高字节与低字节的左右位置与实际数据相反，因此SendCRC_Check的低位放在协议RCR校验高字节位
					G_SendByteTable_8u[SendLength-1]=(u8)(SendCRC_Check>>8);
					/*-------------------------------------------------------------------------------*/
					TX_MODE;
					for(timecnt=0;timecnt<60;timecnt++);//模式转换延时
					/*-------------------------------------------------------------------------------*/
					USART1->TDR = (G_SendByteTable_8u[0] & (uint16_t)0x00FF);
					break;
				}
				case 0x04://读的回复
				{
					SendLength=Read_RegNum*2+5;
					SendPacketState=1;
					Read_ProcessRegAddress = Read_RegAddress;
					G_SendByteTable_8u[0]=IDcode;
					G_SendByteTable_8u[1]=0x04;
					G_SendByteTable_8u[2]=(u8)(Read_RegNum*2);
					for(b=0;b<Read_RegNum;b++)
					{
						G_Coordinate = RegCoordinateCalcuate(Read_ProcessRegAddress);
						G_SendByteTable_8u[b*2+3]=(u8)(G_ModbusRegs_16u[G_Coordinate.A][G_Coordinate.B]>>8);
						G_SendByteTable_8u[b*2+4]=(u8)G_ModbusRegs_16u[G_Coordinate.A][G_Coordinate.B];
						Read_ProcessRegAddress++;
					}	
					SendCRC_Check = Crc_cal_value(G_SendByteTable_8u,SendLength-2);
					G_SendByteTable_8u[SendLength-2]=(u8)(SendCRC_Check);//RCR校验计算出来的高字节与低字节的左右位置与实际数据相反，因此SendCRC_Check的低位放在协议RCR校验高字节位
					G_SendByteTable_8u[SendLength-1]=(u8)(SendCRC_Check>>8);
					/*-------------------------------------------------------------------------------*/
					TX_MODE;
					for(timecnt=0;timecnt<60;timecnt++);//模式转换延时
					/*-------------------------------------------------------------------------------*/
					USART1->TDR = (G_SendByteTable_8u[0] & (uint16_t)0x00FF);
					break;
				}
				case 0x06://写单个的回复
				{
					SendLength=8;
					SendPacketState=1;
					for(b=0;b<SendLength;b++)G_SendByteTable_8u[b] = G_ReceiveByteTable[b];//06的回复数据与接收数据相同
					/*-------------------------------------------------------------------------------*/
					TX_MODE;
					for(timecnt=0;timecnt<60;timecnt++);//模式转换延时
					/*-------------------------------------------------------------------------------*/
					USART1->TDR = (G_SendByteTable_8u[0] & (uint16_t)0x00FF);
					break;
				}
				case 0x10://写n个(起始地址与寄存器数量在中断中已经计算)的回复
				{
					SendLength=8;
					SendPacketState=1;
					for(b=0;b<6;b++)G_SendByteTable_8u[b] = G_ReceiveByteTable[b];//06的回复数据与接收数据相同
					SendCRC_Check = Crc_cal_value(G_SendByteTable_8u,6);
					G_SendByteTable_8u[6]=(u8)(SendCRC_Check);//RCR校验计算出来的高字节与低字节的左右位置与实际数据相反，因此SendCRC_Check的低位放在协议RCR校验高字节位
					G_SendByteTable_8u[7]=(u8)(SendCRC_Check>>8);
					/*-------------------------------------------------------------------------------*/
					TX_MODE;
					for(timecnt=0;timecnt<60;timecnt++);//模式转换延时
					/*-------------------------------------------------------------------------------*/
					USART1->TDR = (G_SendByteTable_8u[0] & (uint16_t)0x00FF);
					break;
				}
				default :
				{
					break;
				}
			}
			NeedReplyFlag=0;
		}
		/*^发送处理^*/
	}
	
	void USART1_IRQHandler(void)
	{
		/*v发送v*/
	   if((USART1->ISR & USART_ISR_TC) == USART_ISR_TC)
		{
			USART1->ICR = USART_ISR_TC;
			if(SendPacketState<SendLength)
			{
				USART1->TDR = (G_SendByteTable_8u[SendPacketState] & (uint16_t)0x00FF);	
				SendPacketState ++;
			}
			else 
			{
				RX_MODE;
				RXmodeFlag=1;
			}
		}		
		/*^发送^*/
		/*v接收处理v*/
		if((USART1->ISR & USART_ISR_RXNE) == USART_ISR_RXNE)
		{
			USART1->ICR = USART_ISR_RXNE;
	
			ReceiveDataTemp = (USART1->RDR&0x00FF);//取接收的数据
			
			if(ReceiveDataTemp == IDcode&&ReceiveVerifyFlag==0&&ReceivePacketState==0)// 找到帧头且无需求校验的数据条且接收位为头位
			{		
				ReceiveHeaderFlag = 1;
				G_BufferReceive_8u[ReceivePacketState] = ReceiveDataTemp;
				ReceivePacketState++;
			}
			else if(ReceiveHeaderFlag)
			{
				if(ReceivePacketState==1)//接收第二位功能码识别
				{
					if(ReceiveDataTemp==0x03||ReceiveDataTemp==0x04||ReceiveDataTemp==0x06||ReceiveDataTemp==0x10)//若为四个有效功能码之一
					{
						Functioncode=ReceiveDataTemp;
						G_BufferReceive_8u[ReceivePacketState] = Functioncode;
						ReceivePacketState++;
					}	
					else//为无效功能码
					{
						ReceivePacketState=0;
						ReceiveHeaderFlag=0;//本帧头无效，等待下一个帧头
					}	
				}
				else if(ReceivePacketState<ReceiveLength)//接收位其他位
				{
					G_BufferReceive_8u[ReceivePacketState] = ReceiveDataTemp;
					ReceivePacketState++;
					
					if(Functioncode==0x03||Functioncode==0x04||Functioncode==0x06)//计算接收字节长度
						ReceiveLength=8;
					if(Functioncode==0x10&&ReceivePacketState==7)
					{
						Write_RegAddress=G_BufferReceive_8u[2]*256+G_BufferReceive_8u[3];
						Write_RegNum=G_BufferReceive_8u[4]*256+G_BufferReceive_8u[5];
						if(Write_RegNum*2!=G_BufferReceive_8u[6]) 
						{
							ReceivePacketState=0;
							ReceiveHeaderFlag=0;//若字节数与寄存器数不对应则判定本次不合法
						}	
						else ReceiveLength=Write_RegNum*2+9;
					}	
					if(ReceivePacketState==ReceiveLength)ReceiveVerifyFlag=1;//暂时判定接收合法进入主循环函数判断校验合法性（由于校验消耗时间不放在中断中进行）
				}
			}
		}		
		/*^接收处理^*/		
	}
thornbird_echo
关注
  • 4
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STM32开发（六）STM32F103 通信 —— RS485 Modbus通信编程详解
weixin_43564241的博客
03-05 3万+
本实验基于STM32F103开发，实现 通过RS-485实现Modbus通信。Modbus是主从方式通讯，不能同步进行通信，总线上每次只有一个数据进行传输。主机发送，从机应答，主机不发送，总线上就没有数据通讯。MODBUS 协议允许在各种网络体系结构内进行简单通信。
stm32RS485串口通信——中断接收发送数据
热门推荐
zhubao124的博客
07-18 1万+
功能：通过PC机的串口调试助手发送数据给串口A，串口B接收到串口A发送的数据，再由串口B将接收到的数据返回给PC机的串口调试助手。 PC->串口A->串口B->PC。 实验平台：stm32f407 /********************************************************************* 本平台具有六个串口：
V6-RS485+MODBUS主站例程(V1.0)
08-31
V6-RS485+MODBUS主站例程(V1.0)，希望对大家的学习、工作有帮助
ModbusRTU（485）详细笔记
最新发布
qq_51275272的博客
06-09 1512
Modbus协议的简要介绍
c语言485通讯源程序,51单片机485通信实验C语言源代码实现
weixin_42468580的博客
05-17 2467
#include #include sbit RS485=P3^7; //定义485的使能脚bit SendFlag;unsigned int ReData,SenData;/**************************************延时程序**************************************/void delay(unsigned char i){u...
RS485电路及程序设计
qq_15174437的博客
05-14 1222
图中 A、B 总线接口，用于连接 485 总线。RO 是接收输出端，DI 是发送数据收入端，RE是接收使能信号（低电平有效），DE 是发送使能信号（高电平有效）。RE DE接在一起就是高电平发送 低电平接收。在实现串口通信的基础上加入收发使能控制即可。结尾延时太短时很易出错数据还没发送完就切换为接收模式了。
STM32RS485通信
weixin_63889667的博客
01-18 3808
STM32RS485通信
RS485串口编程
精诚所至
02-25 1万+
1.1 单工、半双工、全双工 首先，我使用的是芯片为 SP3485E 为半双工通信。那么先要明确什么是单工、半双工、全双工。 单工数据传输只支持数据在一个方向上传输； 半双工数据传输允许数据在两个方向上传输，但是，在某一时刻，只允许数据在一个方向上传输，它实际上是一种切换方向的单工通信；全双工数据通信允许数据同时在两个方向上传输，因此，全双工通信是两个单工通信方式的结合，它要求发送设备和接收设备...
C#Modbus Socket通信实例.rar
10-21
在本文中，我们将深入探讨如何...通过以上步骤，你可以构建一个功能完善的C#应用程序，不仅能够读取称重设备的数据，还可以控制其他支持Modbus协议的设备。在工业自动化和物联网应用中，这样的能力具有广泛的实用性。
单片机STM32 MODBUS RTU通讯实例 功能码很全
12-20
6. **中断处理**：为了实时响应串口事件，如接收完整帧或发送完成，需要设置串口的中断服务程序。 7. **调试与测试**：通过串口调试助手或实际硬件设备进行通信测试，确保STM32能够正确地接收、解析和响应MODBUS...
modbus_接收.rar
09-07
这可能包括了配置STM32的串口驱动、设置485硬件接口、实现ModBus协议栈以及处理接收数据的函数等。 在了解ModBus协议时，我们需要知道以下几个关键知识点： 1. **ModBus协议**: ModBus是一种主从架构的通信协议，...
51单片机modbus实例
11-16
代码中可能包含了函数定义、状态机设计、中断服务程序等，这些都是理解和实现51单片机Modbus通信的核心部分。 总的来说，51单片机结合Modbus协议的学习，能够让你掌握工业级的通信技术，这对于想要从事嵌入式系统...
STM32 MODBUS主机程序
05-07
5. **中断处理**: 在STM32中，可以配置UART中断，当接收到MODBUS响应时，中断服务程序会处理数据并执行相应的操作。 6. **RTOS集成**: 若项目使用实时操作系统（RTOS），如FreeRTOS或CMSIS-RTOS，可以将MODBUS任务...
Modbus 协议传输数据，简易算法可同时实现发送一个或连续发送多个数据
qq_24426625的博客
08-20 3175
modbus通讯协议简易代码
【STM32】RS485通信使用DMA串口发送数据出现数据丢失、断包问题排查方法
weixin_44562175的博客
03-30 6624
最近在搞这个Modbus协议，由于485协议是半双工的，区别于RS 232的全双工，考虑不周导致调试modbus协议时候出了不少问题。 第一，大多数开发板上的485芯片是MAX485，发送和接收状态的切换是通过IO给到这个两个引脚不同的电平进行切换，由于你的软件程序跑的太快了，写程序给485芯片进行接收或发送时切换注意加点延时等待一下。 /*加短暂延时，保证MAX485芯片转发数据完毕*/ Delay(0xFFFF); // 使能接收数据 RS485_RX_EN() ; 第二，485数据使用DMA串口发送
嵌入式Linux开发---RS485通信驱动硬件编程
weixin_49337111的博客
01-12 4255
RS485的使用与UART串口的使用基本相同，差别在于使用485时需要手动切换485芯片的收发引脚模式。 实际上，使用RS485通信的本质还是在使用UART串口通信，只是在程序编写时，需要对read、write多一步的处理。即，进行写485操作时，通过控制引脚切换485芯片为发送模式，读操作时，通过控制引脚切换485芯片为接收模式。485处理芯片相对于串口，就是需要将TTL逻辑电平信号转换为RS485差分电平信号。
rs485接收中断函数使能_关于STM32中断知识
weixin_39825105的博客
12-30 707
1.1.1 中断概念程序正在执行，突然有外部信号或者内部信号打断正在执行的程序，需要执行该事件，执行完后再回到当前打断的位置继续往下执行程序的过程称为中断。例如：正在写代码 -- 程序正在执行微信信息 -- 事件发生 --> 中断请求 看微信信息 -- 执行事件 --> 中断执行 继续写代码 -- 继续执行代码 -...
[源代码] RS485和modbus协议通讯实例 详细代码 项目案例
小超嵌入式笔记
04-13 7511
文章目录 文章目录文章目录前言一、main.c二、rs485.c三、rs485.h 前言 RS485使用modbus协议通讯实例演示，参考正点原子。 一、main.c #include "led.h" #include "delay.h" #include "key.h" #include "sys.h" #include "lcd.h" #include "usart.h" #include "rs485.h" //Modbus寄存器和单片机寄存器的映射关系 vu32 *Modbus_Inpu
第12-15周-Modbus编程实践
w_pig的博客
01-16 348
1
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值