基于EIA-232，的ModBus-ASCII协议,校验方式Lrc-8

最新推荐文章于 2023-10-24 22:43:51 发布
最新推荐文章于 2023-10-24 22:43:51 发布
阅读量469 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： stm32 嵌入式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_31890147/article/details/53491357
本文介绍了一个基于STM32的Modbus通信实现方案，详细展示了接收和发送Modbus报文的过程，并实现了ASCII码的转换及校验码计算等功能。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >


#include "stm32f10x.h"

  
u8 Rcv_Buffer[131]={0};			  
u8 Send_Buffer[131]={0};
u16 Rcv_Index=0;
u16 Send_Index=0;
u8 Comu_Busy=0;
u8	Sendcount=0;	
u8	Recivecount=0;
u16 KAIGUANLIANG=0;
extern u16 DLBJ,dlBJ,DWBJ,BJBZ,BJBZ1,BJBZ2,BJBZ3,BJBZ4,BJBZ5;         //¶Ï·±¨¾¯    

extern u16 DL1,DL2,DL3,DL4,DL5,DL6,DL7,DL8,DL9,DL10,DL11,DL12;
u16 DL=0;
u16 SendFlag=0;
extern u16 Rcv_For_User[80];//Õâ¸öÊý×éÊÇÒ»¸ö¶ÔÍâ½Ó¿Ú£¬Ö÷³ÌÐòÖдÓÕâ¸öÊý×éÖÐÈ¡³ö¿ÉÓõÄÊý¾Ý¡£µÚÒ»¸öÔªËØÖ»ÓÐ0ºÍ1Á½¸ö¿ÉÄÜÖµ£¬ÓÃÓÚ±íʾÊý×éÄÚÈÝÊÇ·ñÒѾ­¸úйý¡£
extern u16 Send_For_User[80];//Õâ¸öÊý×éÊÇÒ»¸ö¶ÔÍâ½Ó¿Ú£¬Ö÷³ÌÐò½«Òª·¢Ë͵ÄÊý¾Ý·ÅÖÃÔÚÕâ¸öÊý×éÖС£µÚÒ»¸öÔªËØÖ»ÓÐ0ºÍ1Á½¸ö¿ÉÄÜÖµ£¬ÓÃÓÚ±íʾÊý×éÄÚÈÝÊÇ·ñÒѾ­¸úйý¡£
extern u16 XH1;
extern u16 I1_1,IC_1,LIM_1,D_1,C_1;    //ÄǼ¸Â·µÄÄ£ÄâÖµ
extern u16 I1_2,IC_2,LIM_2,D_2,C_2;
extern u16 I1_3,IC_3,LIM_3,D_3,C_3;
extern u16 I1_4,IC_4,LIM_4,D_4,C_4; 
extern u16 I1_5,IC_5,LIM_5,D_5,C_5; 
extern u16 I1_6,IC_6,LIM_6,D_6,C_6; 
extern u16 I1_7,IC_7,LIM_7,D_7,C_7; 
extern u16 I1_8,IC_8,LIM_8,D_8,C_8; 
extern u8 LINEAR1,LINEAR2,LINEAR3,LINEAR4;
extern u16 YALI,XIEHE,ZUOYI;//ѹÁ¦¿ª¹Ø£¬Ð¶ºÉ¿ª¹Ø£¬×ùÒοª¹Ø
extern u16 T1_1,T1_2,T2_1,T2_2,T3_1,T3_2,T4_1,T4_2;  
extern u32 I_FEEDBACK1,I_FEEDBACK2,I_FEEDBACK3,I_FEEDBACK4,I_FEEDBACK5,I_FEEDBACK6,I_FEEDBACK7,I_FEEDBACK8;
extern u32 I_FEEDBACK9,I_FEEDBACK10,I_FEEDBACK11,I_FEEDBACK12;		
extern u32 V_DONGBI, V_ZONG, V_DONGBI,V_FANDOU,V_FUZHU1,V_FUZHU2;
////#define YX1 GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_11);
//#define YX2 GPIO_ReadInputDataBit(GPIOC, GPIO_Pin_11);
//#define YX3 GPIO_ReadInputDataBit(GPIOC, GPIO_Pin_12);
//#define YX4 GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_0);
//#define YL  GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_4);
//#define ZW  GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_3);
//#define XH  GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_7);
extern u8 YX1,YX2,YX3,YX4,YL,ZW,XH;
void MODBUS_Rcv(void);  //£¨½ÓÊÜ£©
void MODBUS_Send(void); //£¨·¢ËÍ£©
void LRC_Cal(u8 *buffer1,u8 len,u8 *buffer2);//LRCУÑéÂë
void response_handle(void);                  //µ±½ÓÊÜÍêÖ÷»úµÄÐÅÏ¢ºó£¬½øÐд¦Àí
void Respond_Read(void);//ÉèÖÃģʽÏ£¬ÎҵĻØÓ¦
void Respond_Write(void);                         //¼à¿ØÉèÖÃģʽÏ£¬ÎҵĻØÓ¦
void Sendvalue_Init(void);                       //·¢ËÍÖµµÄ³õʼ»¯
void HexToAscii(u8 *val);                    //Ê®Áù½øÖÆתΪASCIIÂë
u8 AsciiToHex(u8 val);                       //ASCIIÂëת»»Îª16½øÖÆ 
extern u16 DBJ(u16 n);                             //¶Ï·±¨¾¯¼ì²â
extern u16 dBJ(u16 n);                             //¶Ì·±¨¾¯¼ì²â
extern u16 DDBJ(u16 n);                            //µçλÆ÷¶Ï·±¨¾¯¼ì²â¡£ 
extern u16 XBJ(u16 n);                             //ϵͳ±¨¾¯¹ýѹ¼ì²â 
extern u16 XBJ1(u16 n);                            //ϵͳ±¨¾¯Ç·Ñ¹¼ì²â
extern u16 get_temperature(void);	          //ζȼì²â 
 /* º¯Êý¹¦ÄÜ£ºÓÃÓÚMODBUSeÐÅÏ¢½ÓÊÕ
 	º¯ÊýÊäÈ룺ÎÞ¡£														    
	º¯ÊýÊä³ö£ºÎÞ¡£                                                                                      */
  void MODBUS_Rcv(void)
  {
  	u8 Rcv_Data;
	if(Comu_Busy==0)//Èç¹û±¾»ú²»Ã¦£¬¿ÉÒÔ½ÓÊÕеÄÖ¡
	{
		Rcv_Data = USART_ReceiveData(USART3);                  //´ó¸ç£¬ÎÒÃÇÄǶùÊÇ3
		if(Rcv_Data == ':')//Ö¡Æðʼ±êÖ¾,±ê־еÄÖ¡¿ªÊ¼
		{
			Rcv_Index = 0;//½«Ö¡¶¨Î»µ½Rcv_Buffer´æ·ÅµÚÒ»¸öÓÐЧ×Ö½ÚµÄλ//ÓпÉÄÜÒª¸ÄΪ0£¨Ã²ËÆÓÖ²»ÓøÄÁË£©£¨Æäʵ»¹ÊǸÄΪ0ÁË£©
			Rcv_Buffer[Rcv_Index] = ':';
			Rcv_Index++;//ÒƵ½ÏÂÒ»¸öλÖÃ
		  Recivecount++;//½ÓÊÕµÄÓÐЧ×Ö½ÚÊý¼ÓÒ»
		}
		else if(Rcv_Data == '\n')//Èç¹ûÊÇ0x13£¬×îºóÒ»¸öÊý      //ԭΪ'\r'
		{
			Rcv_Buffer[Rcv_Index] = Rcv_Data;//´æ·Å½ÓÊÕµ½µÄ×Ö½Ú
			Recivecount++;//½ÓÊÕµÄÓÐЧ×Ö½ÚÊý¼ÓÒ»
			if(Rcv_Index>=1&&Rcv_Buffer[Rcv_Index-1]=='\r')//±êÖ¾Ö¡½áÊø ԭΪ'*'
			{
				Comu_Busy=1;//¿ªÊ¼´¦Àí»Ø¸´µÄÖ¡ÐÅÏ¢£¬½øÈëæ״̬
				response_handle();		//´¦ÀíÊý¾Ý
				Recivecount=0;//Êý×éÇåÁã
				Comu_Busy=0;//»Ö¸´¿ÕÏÐ״̬
			}		 
		}
		else//Èç¹ûÊDZðµÄ×Ö·û(Èç¹û½ÓÊÕµ½µÄÊÇÒ»¸öÊý×é)
		{
			Rcv_Buffer[Rcv_Index] = Rcv_Data;//´æ·Å½ÓÊÕµ½µÄ×Ö½Ú
			Rcv_Index++;//ÒƵ½ÏÂÒ»¸öλÖÃ
			Recivecount++;//½ÓÊÕµÄÓÐЧ×Ö½ÚÊý¼ÓÒ»					
		}	
	}		
  }

 /* º¯Êý¹¦ÄÜ£ºÓÃÓÚModbusÐÅÏ¢·¢ËÍ
 	º¯ÊýÊäÈ룺ÎÞ¡£														    
	º¯ÊýÊä³ö£ºÎÞ¡£																	   */
  void MODBUS_Send(void)	
 {
		u8 Send_Data;
		Send_Data = Send_Buffer[Send_Index];	           //
  	USART_SendData(USART3,Send_Data);                //ÒòΪÎÒÃÇÓõÄÊÇ3
		Send_Index++;		       
	if(Send_Index>=Sendcount)//Èç¹û·¢ËÍÍêÖ¸¶¨µÄÊý¾ÝÒÔºó
	{
		USART_ITConfig(USART3, USART_IT_TC, DISABLE);//¹Ø±ÕÊý¾Ý·¢ËÍÖжÏ
		Send_For_User[0]=0;//±íʾÊý¾ÝÒѾ­Ê¹ÓÃÍ꣬´ý¸úÐÂ
	}
			
 }


 /* º¯Êý¹¦ÄÜ£ºASCII¼ÆËãÓú¯Êý
 	º¯ÊýÊäÈ룺buffer1ÊÇÒª½øÐÐLRC¼ÆËãµÄÐÅÏ¢Ê×µØÖ·£¬lenÊÇÐÅÏ¢ÖÐ×Ö½ÚÊý£¬buffer2ÊǽÓÊÕLRCУÑé½á¹ûµÄ´æ´¢¿Õ¼äÊ×µØÖ·														    
	º¯ÊýÊä³ö£ºÎÞ                                                                                      */
 

void LRC_Cal(u8 * buffer1, u8 len, u8 * buffer2)    //??????16???ASCII?
{
	u8 i = 0;
u8 temp = 0;
u8 buffer[80] = { 0 };

   while (i <(len/2))
	{
		buffer[i] = AsciiToHex(*(buffer1 + 2 * i))*16  +( AsciiToHex(*(buffer1 + 2 * i + 1)));
		temp += buffer[i];
		i++;
	}
	
	temp = temp % 0X100;
	temp =255-temp;
	temp= temp + 1;
	*buffer2 = temp/16;
	*(buffer2 + 1) = (temp % 16);
	HexToAscii(buffer2);
	HexToAscii(buffer2 + 1);

	
}



void HexToAscii(u8 *val)   //Ê®Áù½øÖÆת»»ÎªASCIIÂë
{
	if(*val>9)
		*val += 'A'-10;//ת»»³É×ÖĸµÄasciiÂë
	else
		*val += '0';//ת»»³ÉÊý×ÖµÄasciiÂë
	return;
}


u8 AsciiToHex(u8 val)      //ASCIIת»¯Îª16½øÖÆ
{
	if(val>='0'&&val<='9')   
	{
	 	val -= '0';
		return val;
	}
	if(val>='A'&&val<='F')
	{
		val -= 'A'-10;
		return val;
	}
	return val;
}
 /* º¯Êý¹¦ÄÜ£º¶Ô½ÓÊյĻظ´ÐÅÏ¢½øÐд¦Àí,´Ó»Ø¸´ÐÅÏ¢»ñµÃÐèÒªµÄÊý¾Ý
 	º¯ÊýÊäÈ룺ÎÞ¡£														    
	º¯ÊýÊä³ö£ºÎÞ¡£                                                                                      */
void response_handle(void)	//»Ø¸´µÄÊÇRDµÄÃüÁWDµÄÃüÁîûÓÐʵ¼ÊÊý¾Ý	  
 {
 	u8 CalKey[2]={0};//¼ÆËã³öÀ´µÄУÑéÖµ
	u8 i=0;
	u16 cnt=0;
	u16 dizhi=0;
	LRC_Cal(&Rcv_Buffer[1],Recivecount-5, CalKey);//×îºóËÄλÊÇLRCºÍ
	if(CalKey[0]==Rcv_Buffer[Recivecount-4]&& CalKey[1]==Rcv_Buffer[Recivecount-3]//¼ÆËã³öµÄУÑéÓë½ÓÊÕµ½µÄLRC±È½ÏÕýºÃÔÚµ¹ÊýµÚ3¸ö
		&&Rcv_Buffer[1]==(0 + '0')&&Rcv_Buffer[2]==(1 + '0'))//Èç¹ûУÑéÕýÈ·,ͬʱµ¥ÔªºÅÕýÈ·
	{
     dizhi=AsciiToHex(Rcv_Buffer[5])*16*16*16+AsciiToHex(Rcv_Buffer[6])*16*16
										+AsciiToHex(Rcv_Buffer[7])*16+AsciiToHex(Rcv_Buffer[8]);
	   cnt=AsciiToHex(Rcv_Buffer[9])*16*16*16+AsciiToHex(Rcv_Buffer[10])*16*16
										+AsciiToHex(Rcv_Buffer[11])*16+AsciiToHex(Rcv_Buffer[12]);
			if(Rcv_Buffer[3]==(1+'0') && Rcv_Buffer[4]==(0+'0'))//ÊǸøÎÒдÊý¾Ý
			{
				                                   //Ö÷»ú¸øÎÒÊý¾Ý£¬ÎÒÏìÓ¦Ëû
				if(dizhi==1000)//×ÜÌåÉèÖ㬴«µ¥ÏßÐÔÒÔ¼°Ë«ÏßÐÔ
				{
					Rcv_For_User[1]=AsciiToHex(Rcv_Buffer[15])*16*16*16+AsciiToHex(Rcv_Buffer[16])*16*16
										+AsciiToHex(Rcv_Buffer[17])*16+AsciiToHex(Rcv_Buffer[18+i*4]);
				}
				 if(dizhi>=1100 && dizhi<=1109)
				{
					for(i=0;i=1200 && dizhi<=1209)
				{
					for(i=0;i=1300 && dizhi<=1309)
				{
					for(i=0;i=1400 && dizhi<=1409)
				{
					for(i=0;i=2011 && dizhi<=2012)
				{
					for(i=0;i=2021 && dizhi<=2022)
				{
					for(i=0;i=2031 && dizhi <=2032)
				{
					for(i=0;i=2041 && dizhi<=2042)
				{
					for(i=0;i=1100 && dizhi<=1109)
			{
				temp = Send_For_User[dizhi-1099+i];
				Send_Buffer[7+i*4] = temp/(16*16*16);
				HexToAscii(&Send_Buffer[7+i*4]);
				temp %= 16*16*16;
				
				Send_Buffer[8+i*4] = temp/(16*16);
				HexToAscii(&Send_Buffer[8+i*4]);
				temp %= 16*16;
				Send_Buffer[9+i*4] = temp/(16);
				HexToAscii(&Send_Buffer[9+i*4]);
				temp %= 16;
				Send_Buffer[10+i*4] = temp;
				HexToAscii(&Send_Buffer[10+i*4]);
			}
				else if(dizhi>=1200 && dizhi<=1209)
				{
					temp = Send_For_User[dizhi-1189+i];
					Send_Buffer[7+i*4] = temp/(16*16*16);
					HexToAscii(&Send_Buffer[7+i*4]);
					temp %= 16*16*16;
					
					Send_Buffer[8+i*4] = temp/(16*16);
					HexToAscii(&Send_Buffer[8+i*4]);
					temp %= 16*16;
					Send_Buffer[9+i*4] = temp/(16);
					HexToAscii(&Send_Buffer[9+i*4]);
					temp %= 16;
					Send_Buffer[10+i*4] = temp;
					HexToAscii(&Send_Buffer[10+i*4]);
				}
				else if(dizhi>=1300 && dizhi<=1309)
				{
					temp = Send_For_User[dizhi-1279+i];
					Send_Buffer[7+i*4] = temp/(16*16*16);
					HexToAscii(&Send_Buffer[7+i*4]);
					temp %= 16*16*16;
					
					Send_Buffer[8+i*4] = temp/(16*16);
					HexToAscii(&Send_Buffer[8+i*4]);
					temp %= 16*16;
					Send_Buffer[9+i*4] = temp/(16);
					HexToAscii(&Send_Buffer[9+i*4]);
					temp %= 16;
					Send_Buffer[10+i*4] = temp;
					HexToAscii(&Send_Buffer[10+i*4]);
				}
				else if(dizhi>=1400 && dizhi<=1409)
				{
					temp = Send_For_User[dizhi-1369+i];
					Send_Buffer[7+i*4] = temp/(16*16*16);
					HexToAscii(&Send_Buffer[7+i*4]);
					temp %= 16*16*16;
					
					Send_Buffer[8+i*4] = temp/(16*16);
					HexToAscii(&Send_Buffer[8+i*4]);
					temp %= 16*16;
					Send_Buffer[9+i*4] = temp/(16);
					HexToAscii(&Send_Buffer[9+i*4]);
					temp %= 16;
					Send_Buffer[10+i*4] = temp;
					HexToAscii(&Send_Buffer[10+i*4]);
				}
				else if(dizhi>=2011 && dizhi<=2012)
				{
					temp = Send_For_User[dizhi-1970+i];
					Send_Buffer[7+i*4] = temp/(16*16*16);
					HexToAscii(&Send_Buffer[7+i*4]);
					temp %= 16*16*16;
					
					Send_Buffer[8+i*4] = temp/(16*16);
					HexToAscii(&Send_Buffer[8+i*4]);
					temp %= 16*16;
					Send_Buffer[9+i*4] = temp/(16);
					HexToAscii(&Send_Buffer[9+i*4]);
					temp %= 16;
					Send_Buffer[10+i*4] = temp;
					HexToAscii(&Send_Buffer[10+i*4]);
				}
					else if(dizhi>=2021 && dizhi<=2022)
				{
					temp = Send_For_User[dizhi-1978+i];
					Send_Buffer[7+i*4] = temp/(16*16*16);
					HexToAscii(&Send_Buffer[7+i*4]);
					temp %= 16*16*16;
					
					Send_Buffer[8+i*4] = temp/(16*16);
					HexToAscii(&Send_Buffer[8+i*4]);
					temp %= 16*16;
					Send_Buffer[9+i*4] = temp/(16);
					HexToAscii(&Send_Buffer[9+i*4]);
					temp %= 16;
					Send_Buffer[10+i*4] = temp;
					HexToAscii(&Send_Buffer[10+i*4]);
				}
					else if(dizhi>=2031 && dizhi<=2032)
				{
					temp = Send_For_User[dizhi-1986+i];
					Send_Buffer[7+i*4] = temp/(16*16*16);
					HexToAscii(&Send_Buffer[7+i*4]);
					temp %= 16*16*16;
					
					Send_Buffer[8+i*4] = temp/(16*16);
					HexToAscii(&Send_Buffer[8+i*4]);
					temp %= 16*16;
					Send_Buffer[9+i*4] = temp/(16);
					HexToAscii(&Send_Buffer[9+i*4]);
					temp %= 16;
					Send_Buffer[10+i*4] = temp;
					HexToAscii(&Send_Buffer[10+i*4]);
				}
				else if(dizhi>=2041 && dizhi<=2042)
				{
					temp = Send_For_User[dizhi-1994+i];
					Send_Buffer[7+i*4] = temp/(16*16*16);
					HexToAscii(&Send_Buffer[7+i*4]);
					temp %= 16*16*16;
					
					Send_Buffer[8+i*4] = temp/(16*16);
					HexToAscii(&Send_Buffer[8+i*4]);
					temp %= 16*16;
					Send_Buffer[9+i*4] = temp/(16);
					HexToAscii(&Send_Buffer[9+i*4]);
					temp %= 16;
					Send_Buffer[10+i*4] = temp;
					HexToAscii(&Send_Buffer[10+i*4]);
				}
				
					else if(dizhi>=3000&& dizhi<=3019)
				{
					temp = Send_For_User[dizhi-2951+i];
					Send_Buffer[7+i*4] = temp/(16*16*16);
					HexToAscii(&Send_Buffer[7+i*4]);
					temp %= 16*16*16;
					
					Send_Buffer[8+i*4] = temp/(16*16);
					HexToAscii(&Send_Buffer[8+i*4]);
					temp %= 16*16;
					Send_Buffer[9+i*4] = temp/(16);
					HexToAscii(&Send_Buffer[9+i*4]);
					temp %= 16;
					Send_Buffer[10+i*4] = temp;
					HexToAscii(&Send_Buffer[10+i*4]);
				}
			
		}	
	//	Send_For_User[0]=0;
		LRC_Cal(&Send_Buffer[1],Sendcount-4,CalKey);  //¼ÆËãLRCУÑéÂë
		Send_Buffer[7+4*cnt]=CalKey[0];
		Send_Buffer[8+4*cnt]=CalKey[1];
		
		//Ìîд½áÊø·û
		Send_Buffer[9+4*cnt]='\r';
		Send_Buffer[10+4*cnt]='\n';

		Send_Index = 0;
		USART_ITConfig(USART3, USART_IT_TC, ENABLE);//¿ªÆôÊý¾Ý·¢ËÍÖжÏ
	}		    
 }




void Sendvalue_Init(void) 
{
	
	if(Send_For_User[0]==0)
	{
		Send_For_User[1]=(u16)(I1_1);    //µÚһ·ͨµÀÕýÏò¼«ÏÞµçÁ÷
 		Send_For_User[2]=(u16)(LIM_1);   //µÚһ·ͨµÀÕýÏò¼«ÏÞLIM+
		Send_For_User[3]=(u16)(IC_1);    //ͨµÀÕýÏòÇл»µçÁ÷IC+
		Send_For_User[4]=(u16)(C_1);     //ͨµÀÕýÏòÇл»µãC+
		Send_For_User[5]=(u16)(D_1);     //ͨµÀÕýÏòËÀÇøD+
		
		Send_For_User[6]=(u16)(I1_2);
		Send_For_User[7]=(u16)(LIM_2);
		Send_For_User[8]=(u16)(IC_2);
		Send_For_User[9]=(u16)(C_2);
		Send_For_User[10]=(u16)(D_2);
		
		Send_For_User[11]=(u16)(I1_3);
		Send_For_User[12]=(u16)(LIM_3);
		Send_For_User[13]=(u16)(IC_3);
		Send_For_User[14]=(u16)(C_3);
		Send_For_User[15]=(u16)(D_3);
		
		Send_For_User[16]=(u16)(I1_4);
		Send_For_User[17]=(u16)(LIM_4);
		Send_For_User[18]=(u16)(IC_4);
		Send_For_User[19]=(u16)(C_4);
		Send_For_User[20]=(u16)(D_4);
		
		Send_For_User[21]=(u16)(I1_5);
		Send_For_User[22]=(u16)(LIM_5);
		Send_For_User[23]=(u16)(IC_5);
		Send_For_User[24]=(u16)(C_5);
		Send_For_User[25]=(u16)(D_5);
		
		Send_For_User[26]=(u16)(I1_6);
		Send_For_User[27]=(u16)(LIM_6);
		Send_For_User[28]=(u16)(IC_6);
		Send_For_User[29]=(u16)(C_6);
		Send_For_User[30]=(u16)(D_6);
		
		Send_For_User[31]=(u16)(I1_7);
		Send_For_User[32]=(u16)(LIM_7);
		Send_For_User[33]=(u16)(IC_7);
		Send_For_User[34]=(u16)(C_7);
		Send_For_User[35]=(u16)(D_7);
		
		Send_For_User[36]=(u16)(I1_8);
		Send_For_User[37]=(u16)(LIM_8);
		Send_For_User[38]=(u16)(IC_8);
		Send_For_User[39]=(u16)(C_8);
		Send_For_User[40]=(u16)(D_8);
		
		Send_For_User[41]=(u16)(T1_1);   
		Send_For_User[42]=(u16)(T1_2);
		Send_For_User[43]=(u16)(T2_1);
		Send_For_User[44]=(u16)(T2_2);
		Send_For_User[45]=(u16)(T3_1);   //²Ù×Ý¿ª¹Ø¼ÓËÙʱ¼ä
		Send_For_User[46]=(u16)(T3_2);
		Send_For_User[47]=(u16)(T4_1);
		Send_For_User[48]=(u16)(T4_2);
		KAIGUANLIANG=GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_11)+GPIO_ReadInputDataBit(GPIOC, GPIO_Pin_11)*2+
		            GPIO_ReadInputDataBit(GPIOC, GPIO_Pin_12)*4+GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_0)*8+
								GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_4)*16+GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_3)*32+
							  XH1*64;
		Send_For_User[49]=(u16)(KAIGUANLIANG);//¿ª¹ØÁ¿×´Ì¬
		Send_For_User[50]=(u16)(I_FEEDBACK1);  //±ÈÀýµç´ÅÌúµç1
		Send_For_User[51]=(u16)(I_FEEDBACK2);  //±ÈÀýµç´ÅÌúµç2
		Send_For_User[52]=(u16)(I_FEEDBACK3);  //±ÈÀýµç´ÅÌúµç3
		Send_For_User[53]=(u16)(I_FEEDBACK4);  //±ÈÀýµç´ÅÌúµç4
		Send_For_User[54]=(u16)(I_FEEDBACK5);  //±ÈÀýµç´ÅÌúµç5
		Send_For_User[55]=(u16)(I_FEEDBACK6);  //±ÈÀýµç´ÅÌúµç6
		Send_For_User[56]=(u16)(I_FEEDBACK7);  //±ÈÀýµç´ÅÌúµç7
		Send_For_User[57]=(u16)(I_FEEDBACK8);  //±ÈÀýµç´ÅÌúµç8
		Send_For_User[58]=(u16)(I_FEEDBACK9);  //¿ª¹Øµç´ÅÌú1
		Send_For_User[59]=(u16)(I_FEEDBACK10);  //¿ª¹Øµç´ÅÌú2
		Send_For_User[60]=(u16)(I_FEEDBACK11);  //¿ª¹Øµç´ÅÌú3
		Send_For_User[61]=(u16)(I_FEEDBACK12);  //¿ª¹Øµç´ÅÌú4
		

		Send_For_User[62]=(u16)(V_DONGBI/10);      //µçλÆ÷µçѹ1
		Send_For_User[63]=(u16)(V_FANDOU/10);      //µçλÆ÷µçѹ2
		Send_For_User[64]=(u16)(V_FUZHU1/10);      //µçλÆ÷µçѹ3
		Send_For_User[65]=(u16)(V_FUZHU2/10);      //µçλÆ÷µçѹ4
		DLBJ=DL1| (DL2<<1) | (DL3<<2)|(DL4<<3) |(DL5<<4) | (DL6<<5)	
		|(DL7<<6)| (DL8<<7) | (DL9<<8)|(DL10<<9) |(DL11<<10) | (DL12<<11);	
		Send_For_User[66]=(u16)(DLBJ);
		dlBJ=dBJ(I_FEEDBACK1)| (dBJ(I_FEEDBACK2)<<1) | (dBJ(I_FEEDBACK3)<<2)|(dBJ(I_FEEDBACK4)<<3) |(dBJ(I_FEEDBACK5)<<4) | (dBJ(I_FEEDBACK6)<<5)	
		|(dBJ(I_FEEDBACK7)<<6)| (dBJ(I_FEEDBACK8)<<7) | (dBJ(I_FEEDBACK9)<<8)|(dBJ(I_FEEDBACK10)<<9) |(dBJ(I_FEEDBACK11)<<10) | (dBJ(I_FEEDBACK12)<<11);	
		if(dlBJ>0)
			BJBZ2=1;
		else if(dlBJ==0)
			BJBZ2=0;
		Send_For_User[67]=(u16)(dlBJ);
		if(DWBJ % 8 >0 || DLBJ>0 )
			BJBZ1=1;
		else
			BJBZ1=0;
		DWBJ=DDBJ(V_DONGBI)| (DDBJ(V_FANDOU)<<1) | (DDBJ(V_FUZHU1)<<2)|(DDBJ(V_FUZHU2)<<3) |(XBJ(V_ZONG)<<4) |(XBJ1(V_ZONG)<<5) |(get_temperature()<<6);
		Send_For_User[68]=(u16)(DWBJ);
		Send_For_User[69]=(u16)(LINEAR1+LINEAR2*2+LINEAR3*4+LINEAR4*8+ZUOYI*256+XIEHE*512+YALI*1024);  //Ä£ÄâͨµÀÇúÏß״̬
		Send_For_User[0]=1;
	

	}
}
STM32F103之ModBus\RS232\RS422\RS485
DK3314219995的博客
07-10 756
RS-232 是美国电子工业协会EIA制定的一种串行物理接口标准。全称是 “数据终端设备（DTE）和数据通信设备（DCE）之间串行二进制数据交换接口技术标准”。RS（Recommended Standard）是英文“推荐标准”的缩写，232为标识号接口特性常用的串口接头有两种，一种是9针串口（简称DB-9），一种是25针串口（简称DB-25）。RS-232C标准接口有25条线，其中，4条数据线、11条控制线、3条定时线以及7条备用和未定义线。那么，这些信号线在9针串口和25针串口的管脚上是如何分配的呢？
Modbus协议基础
最新发布
qq_45578181的博客
05-27 636
Modbus是由Modicon（现为施耐德电气公司的一个品牌）在1979年发明的，是全球第一个真正用于工业现场的应用层总线协议。为更好地普及和推动Modbus在基于以太网上的分布式应用，目前施耐德公司已将Modbus协议的所有权移交给IDA（Interface for Distributed AutomaTIon，分布式自动化接口）组织，并成立了Modbus-IDA组织，为Modbus今后的发展奠定了基础。IDA是一种完全建立在以太网基础上的工业以太网规范。
ModbusRTU、ASCII 协议、CRC校验源码官方解说
07-27
ModbusRTU、ASCII 协议、CRC校验源码官方解说 MODBUS over Serial Line Specification and Implementation Guide V1.02
C# Modbus ASCII的LRC校验代码
b07lxh的博客
07-08 1928
Modbus常用的有ModbusRTU、Modbus ASCII和ModbusTCP。其中ModbusTCP不涉及自身协议的校验，另外两种Modbus的校验方法分为两种，一种是对每个单独报文的奇偶校验，另一个是对每帧数据的帧校验。（1）、奇偶校验奇偶校验有奇校验和偶校验（如果无校验，则报文中默认有两个停止位）两种。
MODBUS-RTU和ASCII模式及CRC和LRC校验方法简述
BUG从入门到精通
10-16 9657
MODBUS简述 Modbus是一种串行通信协议，是Modicon公司（现在的施耐德电气Schneider Electric）于1979年为使用可编程逻辑控制器（PLC）通信而发表。Modbus已经成为工业领域通信协议的业界标准（De facto），并且现在是工业电子设备之间常用的连接方式。 Modbus可将不同厂商生产的控制设备可以连成工业网络，进行集中监控，是一种通用工业标准。Modbus是一个master/slave架构的协议，有一个节点是master节点，其他使用Modbus协议参与通信的节点是
ModBusPoll434+ASCII查询器+汉字编码查询+CRC校验计算工具
06-29
ModBusPoll434+ASCII查询器+汉字编码查询+CRC校验计算工具ModBusPoll434+ASCII查询器+汉字编码查询+CRC校验计算工具ModBusPoll434+ASCII查询器+汉字编码查询+CRC校验计算工具
Modbus ASCII LRC生成
rediculous的专栏
07-12 933
Modbus ASCII的报文生成顺序为： 1、生成PDU 2、生成LRC校验码，将LRC附加到PDU后面 3、将2中的数组转换成HEX格式的文本 4、在HEX格式文本的0位置插入冒号，在HEX格式文本的后面附加Windows换行符 生成LRC的公式为：LRC= - sum(PDU) 以下为LRC校验码生成算法的通用性示范： /**将HEX格式的数据流包装成字符串对象*/ public static final int getLRC8FromAscIIBytes(byte[] hex, .
MODBUS协议(功能码及报文解析)-485功能码
12-11
MODBUS ASCII采用纵向冗余校验（LRC）进行数据完整性验证。 - **MODBUS/TCP**：这是针对以太网和其他IP网络的变体，该协议简化了数据包结构，不需要单独的校验和计算。 #### 三、MODBUS协议的数据模型与功能调用 ...
modbus协议(功能码及报文解析).pdf
03-16
Modbus协议不仅适用于串口通信，如EIA-485物理层，还扩展到了以太网和其他支持互联网协议的网络。 在串行通信中，Modbus分为两种变种：Modbus RTU和Modbus ASCII。RTU采用紧凑的二进制数据表示，适合高效传输，而...
Modbus通信协议详解：RTU与ASCII模式
在Modbus协议中，数据校验是必要的，串行通信中的ASCII模式使用LRC校验，RTU模式使用16位CRC校验。然而，Modbus TCP协议不额外规定校验，因为它依赖TCP协议的可靠性。在TCP模式下，请求和响应的数据结构包含了交易ID...
MODBUS-ASCII-通讯协议(16通道采集器LRC校验)
05-11
MODBUS_ASCII_通讯协议(16通道采集器LRC校验) MODBUS_ASCII 通讯协议 1、数据传输格式：1位起始位、7位数据位、1位停止位、偶校验位。 2、仪表数据格式：2字节寄存器值＝寄存器数高8位二进制数＋寄存器低8位二进制数 3、仪表通讯帧格式： 读寄存器命令格式：DE： 设备地址 LRC： 校验字节 采用LRC－纵向冗余错误校验 4、拨盘设置：（注意地址有效范围1—16）
MODBUS调试软件 ASCII版
08-30
用于MODBUS协议调试,可以对接收数据进行校验,可以自动计算LRC校验码,可设置串口及波特率 RTU版的见这里: http://download.youkuaiyun.com/source/3119148
Modbus协议详解4：RTU帧 & ASCII帧的差错校验
weixin_43866583的博客
10-24 3305
纵向冗余校验(LRC)为一个字节，含有8位二进制值。LRC由发送设备计算，并附加LRC到报文。接收设备在接收文时计算LRC,并将计算的结果与在LRC接收到的实际值相比较，如果两个值不相等，则结果为错。
MODBUS三种通讯模式RTU,ASCII,TCP，功能码，RCR校验
热门推荐
浮若于心
10-23 2万+
MODBUS通信模式最主要有两种： RTU模式和ASCII模式。 RTU模式： 地址码 功能码 数据 校验码 一字节 一字节 n字节 两字节(CRC) 从机都有相应的地址码，便于主机识别。其中数据已帧为单位进行数据传输，每帧最长为252字节，最短为0。如果一byte数据的传输时间为T,那么每两帧之间的间隔最小应该要大于3.5T,否则从机不能分辨这是两帧。第二,同一帧连续的两个数据之间的间隔时间不能超过1.5T,否则节点会认为这一帧数据不完整,这说明我们在m
java modbus lrc_Modbus ASCII RTU LRC CRC
weixin_30969479的博客
02-13 223
RTU即Remote Terminal Unit的缩写，中文译为远程终端装置。CRC即循环冗余校验码(Cyclic Redundancy Check)：是数据通信领域中最常用的一种差错校验码，其特征是信息字段和校验字段的长度可以任意选定。LRC 纵向冗余校验(Longitudinal Redundancy Check，简称：LRC)是通信中常用的一种校验形式，也称LRC校验或纵向校验。LRC校验码...
java modbus lrc,Modbus ASCII RTU LRC CRC 校验
weixin_27717759的博客
03-19 458
RTU即Remote Terminal Unit的缩写，中文译为远程终端装置。CRC即循环冗余校验码(Cyclic Redundancy Check)：是数据通信领域中最常用的一种差错校验码，其特征是信息字段和校验字段的长度可以任意选定。LRC 纵向冗余校验(Longitudinal Redundancy Check，简称：LRC)是通信中常用的一种校验形式，也称LRC校验或纵向校验。LRC校验码...
Modbus ASCII模式下的LRC校验算法
Roads
05-04 8679
在发送报文到平台后重新将数据组织LRC校验码,但是使用Modbus规约文档上给的代码总是与发送报文的校验码不符, 查资料可知LRC校验码的算法有两种,实现起来也很简单.但是却不对.因为这些都是一个字节的, 但是发送报文中其实是两个字节的校验码,其高位在后,低位在前!  这与前面几段数据不同,需要注意下.没办法, 网上的资料虽多,但是能用的也寥寥. 不过有两份资料还是说明出问题的要害, LRC校验C...
java modbus lrc,C#实现modbus基于ASCII的LRC校验
weixin_34707242的博客
03-19 392
若所求校验为两位ASCII码，LRC就是循环求和后，取256的模，取补码，即为所求校验码；若要四位就改变模值即可用了两个textbox;textBox1用于字符输入textBox2用于处理后输出button1用于响应using System;using System.Collections.Generic;using System.ComponentModel;using System.Data;...
Modbus ASCII LRC检验码VB6代码表示法
weixin_45707491的博客
08-13 195
Next I。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值