21ic电子技术开发论坛 › 单片机与嵌入式系统 › ST MCU › STM32F103单片机modbus通信示例
12下一页
返回列表 发新帖我要提问

[STM32F1] STM32F103单片机modbus通信示例

[复制链接]
1339|36
 楼主| 花间一壶酒sd 发表于 2023-4-21 23:59 | 显示全部楼层 |阅读模式
Modbus通信, ST, STM, STM32, STM32F
      前两天在研究STM32F103单片机的串口空闲中断时，突然想起来Modbus通信非常适合用空闲中断来处理。先看看Modbus RTU模式下的通信规范。


416086442b2e8447da.png

   可以看到Modbus RTU通信模式下，数据的开始和结束是由空闲字符间隔时间来区分的，而STM32F103单片机自带串口空闲模式检测。
回复

收藏1 举报

评论

花间一壶酒sd
———————————————— 版权声明：本文为CSDN博主「嵌入式@hxydj」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/qq_20222919/article/details/109110998  发表于 2023-4-22 00:00

相关帖子
 楼主| 花间一壶酒sd 发表于 2023-4-22 00:00 | 显示全部楼层
840776442b31a7bf14.png

在通常情况下Modbus通信一帧数据的检测可以用时间判断，不停的去读取接收数据的长度是否发送变化，如果在一定时间内，接收数据的长度没有发生变化，就认为一帧数据结束完毕。具体实现可参考 STM8学习笔记---Modbus通信协议简单移植。
回复

收藏1 举报

 楼主| 花间一壶酒sd 发表于 2023-4-22 00:00 | 显示全部楼层
通过时间来判断一帧数据是否接收完成，会导致单片机不停的进入中断。而STM32F103单片机自带了空闲数据检测功能，这个功能是由单片机内部的硬件完成的，不需要程序去处理，这样单片机的就有机会去执行更多了任务了。为了让单片机在处理Modbus RTU通信时更简单快速，可以用 串口DMA加上空闲中断的方式来实现。
回复

收藏1 举报

 楼主| 花间一壶酒sd 发表于 2023-4-22 00:01 | 显示全部楼层
   下面直接用代码说明具体的实现过程，首先初始化串口。
复制
  1. #define UART2_DMA  1                                                                                                                                                                //使用串口2  DMA传输
    

  2. #define  CHECK_NONE_ONE_STOP    1 //无校验位  1个停止位  1有效  0 无效 
    

  3. #define  CHECK_NONE_TWO_STOP    0 //无校验位  2个停止位  1有效  0 无效 
    

  4. #define  CHECK_EVEN    0          //偶数校验   1有效  0 无效 
    

  5. #define  CHECK_ODD     0          //奇数校验   1有效  0 无效 
    

  6.  
    

  7.  
    

  8. void  uart2_init( u16 baud )
    

  9. {
    

  10.     GPIO_InitTypeDef GPIO_InitStructure;
    

  11.     USART_InitTypeDef USART_InitStructure;
    

  12.     NVIC_InitTypeDef  NVIC_InitStructure;
    

  13.  
    

  14.     RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA, ENABLE );
    

  15.     RCC_APB1PeriphClockCmd( RCC_APB1Periph_USART2, ENABLE );
    

  16.  
    

  17.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
    

  18.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;                                                                                                 //推挽复用模式
    

  19.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    

  20.     GPIO_Init( GPIOA, &GPIO_InitStructure );
    

  21.  
    

  22.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
    

  23.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;                                                                         //浮空输入模式
    

  24.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    

  25.     GPIO_Init( GPIOA, &GPIO_InitStructure );
    

  26.  
    

  27.     NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
    

  28.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x02;
    

  29.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x02;
    

  30.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    

  31.  
    

  32.     NVIC_Init( &NVIC_InitStructure );
    

  33.  
    

  34.     USART_InitStructure.USART_BaudRate = baud;
    

  35.     USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    

  36.     USART_InitStructure.USART_StopBits = USART_StopBits_1;
    

  37.     USART_InitStructure.USART_Parity = USART_Parity_No;
    

  38.                 
    

  39. #if(CHECK_EVEN == 1)                                                                                                                                                                                                                          //如果定义了偶校验  数据位长度要改为9位
    

  40.     USART_InitStructure.USART_WordLength = USART_WordLength_9b;
    

  41.     USART_InitStructure.USART_Parity = USART_Parity_Even;
    

  42. #endif
    

  43.  
    

  44. #if(CHECK_ODD == 1)                                                                                                                                                                                                                          //如果定义了奇校验  数据位长度要改为9位
    

  45.     USART_InitStructure.USART_WordLength = USART_WordLength_9b;
    

  46.     USART_InitStructure.USART_Parity = USART_Parity_Odd;
    

  47. #endif
    

  48.  
    

  49. #if(CHECK_NONE_ONE_STOP==1)                                                                                                                                                                                           //停止位为 一位
    

  50.     USART_InitStructure.USART_StopBits = USART_StopBits_1;
    

  51. #endif
    

  52.  
    

  53. #if(CHECK_NONE_TWO_STOP==1)                                                                                                                                                                                                 //停止位为 两位                                                                                                                                        
    

  54.     USART_InitStructure.USART_StopBits = USART_StopBits_2;
    

  55. #endif                
    

  56.                 
    

  57.                 
    

  58.     USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    

  59.     USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    

  60.  
    

  61.     USART_Init( USART2, &USART_InitStructure );
    

  62.                 
    

  63. #if (UART2_DMA == 1)
    

  64.     USART_ITConfig( USART2, USART_IT_IDLE, ENABLE );                                                                                         //使能串口空闲中断
    

  65.     USART_DMACmd( USART2, USART_DMAReq_Rx, ENABLE );                                                                                         //使能串口2 DMA接收
    

  66.     uartDMA_Init();                                                                                                                                                                                                                                 //初始化 DMA
    

  67. #else
    

  68.     USART_ITConfig( USART2, USART_IT_RXNE, ENABLE );                                                                                   //使能串口RXNE接收中断
    

  69. #endif
    

  70.     USART_Cmd( USART2, ENABLE );                                                                                                                                                                         //使能串口2
    

  71.                 
    

  72. //RXNE中断和IDLE中断的区别？
    

  73. //当接收到1个字节，就会产生RXNE中断，当接收到一帧数据，就会产生IDLE中断。比如给单片机一次性发送了8个字节，就会产生8次RXNE中断，1次IDLE中断。
    

  74. }
回复

收藏1 举报

 楼主| 花间一壶酒sd 发表于 2023-4-22 00:01 | 显示全部楼层
  在Modbus通信时，需要对每个字节的数据进行校验，所以这里使用宏定义来初始化串口数据使用的是那种校验方式。如果需要偶校验就将CHECK_EVEN 设置为1，如果需要奇校验就将CHECK_ODD设置为1，如果不需要校验位，就将这两个都设置为0。在串口初始化的时候，需要开启空闲中断和DMA功能。
回复

收藏1 举报

 楼主| 花间一壶酒sd 发表于 2023-4-22 00:07 | 显示全部楼层
     下来初始化 串口2的DMA功能
复制
  1. void uartDMA_Init( void )
    

  2. {
    

  3.     DMA_InitTypeDef  DMA_IniStructure;
    

  4.  
    

  5.     RCC_AHBPeriphClockCmd( RCC_AHBPeriph_DMA1, ENABLE );                                                                          //使能DMA时钟
    

  6.  
    

  7.     DMA_DeInit( DMA1_Channel6 );                                                                                                                                                             //DMA1通道6对应 USART2_RX
    

  8.     DMA_IniStructure.DMA_PeripheralBaseAddr = ( u32 )&USART2->DR;                                         //DMA外设usart基地址
    

  9.     DMA_IniStructure.DMA_MemoryBaseAddr = ( u32 )dma_rec_buff;                                                  //DMA内存基地址
    

  10.     DMA_IniStructure.DMA_DIR = DMA_DIR_PeripheralSRC;                                                                                         //数据传输方向，从外设读取发送到内存
    

  11.     DMA_IniStructure.DMA_BufferSize = DMA_REC_LEN;                                                                                                 //DMA通道的DMA缓存的大小  也就是 DMA一次传输的字节数
    

  12.     DMA_IniStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;                                 //外设地址寄存器不变
    

  13.     DMA_IniStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;                                                                 //数据缓冲区地址递增
    

  14.     DMA_IniStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; //外设以字节为单位搬运
    

  15.     DMA_IniStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;                                  //数据缓冲区以字节为单位搬入
    

  16.     DMA_IniStructure.DMA_Mode = DMA_Mode_Normal;                                                                                                         //工作在正常缓存模式
    

  17.     DMA_IniStructure.DMA_Priority = DMA_Priority_Medium;                                                                         //DMA通道 x拥有中优先级
    

  18.     DMA_IniStructure.DMA_M2M = DMA_M2M_Disable;                                                                                                                 //DMA通道x没有设置为内存到内存传输
    

  19.  
    

  20.     DMA_Init( DMA1_Channel6, &DMA_IniStructure );
    

  21.     DMA_Cmd( DMA1_Channel6, ENABLE );
    

  22. }
回复

收藏1 举报

 楼主| 花间一壶酒sd 发表于 2023-4-22 00:08 | 显示全部楼层
50316442b4eaa5b74.png
串口2的接收对应的是DMA的通道6，所以DMA的通道选择通道6，然后将串口2的数据寄存器作为外设基地址，将数组dma_rec_buff作为DMA的内存地址。外设地址不自增，内存地址自增。这样串口2每接收一个字节的数据，DMA就将接收到的数据存入数组dma_rec_buff中，同时指向数组的地址增加一位，这样串口2接收到的数据就会被一直存放在数组dma_rec_buff中。
回复

收藏1 举报

 楼主| 花间一壶酒sd 发表于 2023-4-22 00:09 | 显示全部楼层
    这里要注意一点，数组的缓存区要大于串口2接收到的最长数据个数，否则如果接收到串口数据比较长，而数组比较小，数组中的数据就会被覆盖，导致接收到的数据错误。
回复

收藏1 举报

 楼主| 花间一壶酒sd 发表于 2023-4-22 00:15 | 显示全部楼层
接下来就是串口中断的实现了
复制
  1. void USART2_IRQHandler( void )
    

  2. {
    

  3.     u8 tem = 0;
    

  4. #if (UART2_DMA == 1)                        //如果使能了 UART2_DMA 则使用串口空闲中断和 DMA功能接收数据
    

  5.         if( USART_GetITStatus( USART2, USART_IT_IDLE ) != RESET )                                                                                   //空闲中断  一帧数据发送完成
    

  6.     {
    

  7.         USART_ReceiveData( USART2 );                                                                                                                                                                                 //读取数据注意：这句必须要，否则不能够清除空闲中断标志位。
    

  8.         DMA_Cmd( DMA1_Channel6, DISABLE );                                                                                                                                                         //关闭 DMA 防止后续数据干扰
    

  9.         uart2_rec_cnt = DMA_REC_LEN - DMA_GetCurrDataCounter( DMA1_Channel6 );  //DMA接收缓冲区数据长度减去当前 DMA传输通道中剩余单元数量就是已经接收到的数据数量
    

  10.        
    

  11.         copy_data( dma_rec_buff, uart2_rec_cnt );                                                                                                                    //备份数据
    

  12.         receiveOK_flag = 1;                                                                                                                                                                                                                        //置位数据接收完成标志位
    

  13.         USART_ClearITPendingBit( USART2, USART_IT_IDLE );                                                                                                 //清除空闲中断标志位
    

  14.         myDMA_Enable( DMA1_Channel6 );                                                                                                                                                                         //重新恢复 DMA等待下一次接收
    

  15.     }
    

  16. #else                                                                                //如果未使能 UART2_DMA 则通过常规方式接收数据  每接收到一个字节就会进入一次中断
    

  17.     if( USART_GetITStatus( USART2, USART_IT_RXNE ) != RESET )                                                 //接收中断
    

  18.     {
    

  19.         tem = USART_ReceiveData( USART2 );
    

  20.         USART_SendData( USART2, tem );
    

  21.     }
    

  22. #endif
    

  23. }
回复

收藏1 举报

 楼主| 花间一壶酒sd 发表于 2023-4-22 00:15 | 显示全部楼层
串口进入空闲中断后，说明一帧数据已经接收完成。关闭DMA通道，开始处理数据。获取DMA中接收到的数据长度，然后将数据拷贝到备份数组中，然后置接收完成标志位。开启 DMA进行下一次数据接收。
回复

收藏1 举报

 楼主| 花间一壶酒sd 发表于 2023-4-22 00:16 | 显示全部楼层
  在主程序中如果检测到了数据接收完成标志时，就开始处理接收到的数据。这样就可以将串口接收数据和处理数据分开，在处理上一笔数据的时候，就可以继续接收下一笔数据。提高了系统的实时性。
回复

收藏1 举报

 楼主| 花间一壶酒sd 发表于 2023-4-22 00:16 | 显示全部楼层
  这里如果直接使用DMA接收数组去处理数据的话，有可能会出现，旧的一笔数据未处理完成时,DMA接收到了新的一笔数据，然后存储到了 DMA缓存数组中。这样在处理数据过程中，旧的数据就会被新的数据覆盖掉，导致系统异常。如果Modbus的通信速率没有那么快，在下一次数据来临之前，系统完全有时间处理完上一笔数据，那么直接使用DMA的缓存数据也是可以的。
回复

收藏1 举报

 楼主| 花间一壶酒sd 发表于 2023-4-22 00:16 | 显示全部楼层
    不过上面这种将数据拷贝倒其他数据中处理的方法也是有风险的。比如第一笔数据还没处理完成，第二笔数据已经接收完成，此时进入串口空闲中断，系统依然会将第二笔数据拷贝到备份数组中去。这样备份数组中的数据依然会被覆盖。但是这种情况如果出现的话，就说明接收数据的频率高于系统处理数据的频率，系统本身就存在风险，需要重新设计。
回复

收藏1 举报

 楼主| 花间一壶酒sd 发表于 2023-4-22 00:16 | 显示全部楼层
   接收数据完成后，就需要在主程序中调用数据处理函数。
复制
  1. int main(void)
    

  2. {
    

  3.     u8  j = 0;
    

  4.         
    

  5.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    

  6.         
    

  7.     delay_init();       //延时函数初始化
    

  8.     LED_Init();         //初始化与LED连接的硬件接口
    

  9.     uart2_init(9600);
    

  10.     while(1)
    

  11.     {
    

  12.       
    

  13.         if( receiveOK_flag )                                //一帧数据接收完成后开始处理数据
    

  14.         {
    

  15.             receiveOK_flag = 0;
    

  16.             DisposeReceive();                                //处理modbus通信
    

  17.         }
    

  18.                         
    

  19.         j++;
    

  20.         if(j > 50)
    

  21.         {
    

  22.             j = 0;
    

  23.             LED = !LED;
    

  24.         }
    

  25.         delay_ms(10);
    

  26.     }
    

  27. }
回复

收藏1 举报

 楼主| 花间一壶酒sd 发表于 2023-4-22 00:17 | 显示全部楼层
最后是Modbus的协议解析
复制
  1. void DisposeReceive( void )
    

  2. {
    

  3.     u16 CRC16 = 0, CRC16Temp = 0;
    

  4.     if( data_backup[0] == SlaveID )                                                                         //地址等于本机地址 地址范围:1 - 32
    

  5.     {
    

  6.         CRC16 = App_Tab_Get_CRC16( data_backup, dataLen_backup - 2 );                                  //CRC校验 低字节在前 高字节在后 高字节为报文最后一个字节
    

  7.         CRC16Temp = ( ( u16 )( data_backup[dataLen_backup - 1] << 8 ) | data_backup[dataLen_backup - 2] );
    

  8.         if( CRC16 != CRC16Temp )
    

  9.         {
    

  10.             err = 4;                                                                                               //CRC校验错误
    

  11.         }
    

  12.         StartRegAddr = ( u16 )( data_backup[2] << 8 ) | data_backup[3];
    

  13.         if( StartRegAddr > (HoldRegStartAddr + HoldRegCount - 1) ) 
    

  14.         {
    

  15.             err = 2;                                                                                               //起始地址不在规定范围内 00 - 07    1 - 8号通道
    

  16.         }
    

  17.         if( err == 0 )
    

  18.         {
    

  19.             switch( data_backup[1] )                                                                        //功能码
    

  20.             {
    

  21.                 case 3:                                                                                            //读多个寄存器
    

  22.                 {
    

  23.                     Modbus_03_Slave();
    

  24.                     break;
    

  25.                 }
    

  26.                 case 6:                                                                                            //写单个寄存器
    

  27.                 {
    

  28.                     Modbus_06_Slave();
    

  29.                     break;
    

  30.                 }
    

  31.                 case 16:                                                                                           //写多个寄存器
    

  32.                 {
    

  33.                     Modbus_16_Slave();
    

  34.                     break;
    

  35.                 }
    

  36.                 default:
    

  37.                 {
    

  38.                     err = 1;                                                                                       //不支持该功能码
    

  39.                     break;
    

  40.                 }
    

  41.             }
    

  42.         }
    

  43.         if( err > 0 )
    

  44.         {
    

  45.             SendBuf[0] = data_backup[0];
    

  46.             SendBuf[1] = data_backup[1] | 0x80;
    

  47.             SendBuf[2] = err;                                                                                      //发送错误代码
    

  48.             CRC16Temp = App_Tab_Get_CRC16( SendBuf, 3 );                                                           //计算CRC校验值
    

  49.             SendBuf[3] = CRC16Temp & 0xFF;                                                                         //CRC低位
    

  50.             SendBuf[4] = ( CRC16Temp >> 8 );                                                                       //CRC高位
    

  51.             uart2_Send( SendBuf, 5 );                                        
    

  52.             err = 0;                                                                                               //发送完数据后清除错误标志
    

  53.         }
    

  54.     }
    

  55. }
    

  56.  
    

  57. /*
    

  58. 函数功能：读保持寄存器  03
    

  59. 主站请求报文:      0x01 0x03   0x0000  0x0001  0x840A     读从0开始的1个保持寄存器
    

  60. 从站正常响应报文:  0x01 0x03   0x02    0x09C4  0xBF87     读到的2字节数据为 0x09C4
    

  61. */
    

  62. void Modbus_03_Slave( void )
    

  63. {
    

  64.     u16 RegNum = 0;
    

  65.     u16 CRC16Temp = 0;
    

  66.     u8 i = 0;
    

  67.     RegNum = ( u16 )( data_backup[4] << 8 ) | data_backup[5];                                                //获取寄存器数量
    

  68.     if( ( StartRegAddr + RegNum ) <= (HoldRegStartAddr + HoldRegCount) )      //寄存器地址+寄存器数量 在规定范围内 <=8
    

  69.     {
    

  70.         SendBuf[0] = data_backup[0];                                                                                                                                                                        //地址        
    

  71.         SendBuf[1] = data_backup[1];                                                                                                                                                                        //功能码
    

  72.         SendBuf[2] = RegNum * 2;                                                                                                                                                                                        //返回字节数量
    

  73.         for( i = 0; i < RegNum; i++ )                                                                             //循环读取保持寄存器内的值
    

  74.         {
    

  75.             SendBuf[3 + i * 2] = HoldReg[StartRegAddr * 2 + i * 2];
    

  76.             SendBuf[4 + i * 2] = HoldReg[StartRegAddr * 2 + i * 2 + 1];
    

  77.         }
    

  78.         CRC16Temp = App_Tab_Get_CRC16( SendBuf, RegNum * 2 + 3 );                                                  //获取CRC校验值
    

  79.         SendBuf[RegNum * 2 + 3] = CRC16Temp & 0xFF;                                                                //CRC低位
    

  80.         SendBuf[RegNum * 2 + 4] = ( CRC16Temp >> 8 );                                                              //CRC高位
    

  81.         uart2_Send( SendBuf, RegNum * 2 + 5 );
    

  82.     }
    

  83.     else
    

  84.     {
    

  85.         err = 3;                                                                                                   //寄存器数量不在规定范围内
    

  86.     }
    

  87. }
    

  88. /*
    

  89. 函数功能:写单个保持寄存器 06
    

  90. 主站请求报文:      0x01 0x06    0x0000  0x1388    0x849C   写0号寄存器的值为0x1388
    

  91. 从站正常响应报文:  0x01 0x06    0x0000  0x1388    0x849C    0号寄存器的值为0x1388
    

  92. */
    

  93. void Modbus_06_Slave( void )
    

  94. {
    

  95.     u16  RegValue = 0;
    

  96.     u16 CRC16Temp = 0;
    

  97.     RegValue = ( u16 )( data_backup[4] << 8 ) | data_backup[5];                                              //获取寄存器值
    

  98.     if( RegValue <= HoldMaxValue )                                                  //寄存器值不超过1000
    

  99.     {
    

  100.         HoldReg[StartRegAddr * 2] = data_backup[4];                                                         //存储寄存器值
    

  101.         HoldReg[StartRegAddr * 2 + 1] = data_backup[5];
    

  102.         SendBuf[0] = data_backup[0];                                                                                                                                                                        //地址
    

  103.         SendBuf[1] = data_backup[1];                                                                                                                                                                        //功能码
    

  104.         SendBuf[2] = data_backup[2];                                                                                                                                                                        //地址高位
    

  105.         SendBuf[3] = data_backup[3];                                                                                                                                                                        //地址低位
    

  106.         SendBuf[4] = data_backup[4];                                                                                                                                                                        //值高位
    

  107.         SendBuf[5] = data_backup[5];                                                                                                                                                                        //值低位
    

  108.         CRC16Temp = App_Tab_Get_CRC16( SendBuf, 6 );                                                              //获取CRC校验值
    

  109.         SendBuf[6] = CRC16Temp & 0xFF;                                                                            //CRC低位
    

  110.         SendBuf[7] = ( CRC16Temp >> 8 );                                                                          //CRC高位
    

  111.         uart2_Send( SendBuf, 8 );
    

  112.     }
    

  113.     else
    

  114.     {
    

  115.         err =  3;                                                                                                  //寄存器数值不在规定范围内
    

  116.     }
    

  117. }
    

  118. /*
    

  119. 函数功能:写多个连续保持寄存器值 16
    

  120. 主站请求报文:       0x01 0x10    0x7540  0x0002  0x04  0x0000 0x2710    0xB731  写从0x7540地址开始的2个保持寄存器值 共4字节
    

  121. 从站正常响应报文:   0x01 0x10    0x7540  0x0002  0x5A10                         写从0x7540地址开始的2个保持寄存器值
    

  122. */
    

  123. void Modbus_16_Slave( void )
    

  124. {
    

  125.     u16 RegNum = 0;
    

  126.     u16 CRC16Temp = 0;
    

  127.     u8 i = 0;
    

  128.     RegNum = ( u16 )( data_backup[4] << 8 ) | data_backup[5];                                                //获取寄存器数量
    

  129.     if( ( StartRegAddr + RegNum ) <= (HoldRegStartAddr + HoldRegCount) )             //寄存器地址+寄存器数量 在规定范围内 <=8
    

  130.     {
    

  131.         for( i = 0; i < RegNum; i++ )                                                                              //存储寄存器设置值
    

  132.         {
    

  133.             HoldReg[StartRegAddr * 2 + i * 2] = data_backup[i * 2 + 7];
    

  134.             HoldReg[StartRegAddr * 2 + 1 + i * 2] = data_backup[i * 2 + 8];
    

  135.         }
    

  136.         SendBuf[0] = data_backup[0];                                                                                                                                                                        //起始地址
    

  137.         SendBuf[1] = data_backup[1];                                                                                                                                                                        //功能码
    

  138.         SendBuf[2] = data_backup[2];                                                                                                                                                                        //地址高位
    

  139.         SendBuf[3] = data_backup[3];                                                                                                                                                                        //地址低位
    

  140.         SendBuf[4] = data_backup[4];                                                                                                                                                                        //寄存器数量高位
    

  141.         SendBuf[5] = data_backup[5];                                                                                                                                                                        //寄存器数量低位
    

  142.         CRC16Temp = App_Tab_Get_CRC16( SendBuf, 6 );                                                        //获取CRC校验值
    

  143.         SendBuf[6] = CRC16Temp & 0xFF;                                                                      //CRC低位
    

  144.         SendBuf[7] = ( CRC16Temp >> 8 );                                                                    //CRC高位
    

  145.         uart2_Send( SendBuf, 8 );
    

  146.     }
    

  147.     else
    

  148.     {
    

  149.         err = 3;                                                                                                   //寄存器数量不在规定范围内
    

  150.     }
    

  151. }
回复

收藏1 举报

 楼主| 花间一壶酒sd 发表于 2023-4-22 00:17 | 显示全部楼层
307216442b72668bf4.png
各个功能码的实现原理在这里就不说了，直接通过代码中和注释就可以看明白了。
回复

收藏1 举报

 楼主| 花间一壶酒sd 发表于 2023-4-22 00:17 | 显示全部楼层
255886442b72ab4199.png
回复

收藏1 举报

 楼主| 花间一壶酒sd 发表于 2023-4-22 00:18 | 显示全部楼层
下面贴出串口和modbus的完整代码

uart2.h

复制
  1. #ifndef __UART2_H
    

  2. #define __UART2_H
    

  3. #include "sys.h"
    

  4.  
    

  5. #define DMA_REC_LEN 50                                                                                                                                                        //DMA数据接收缓冲区
    

  6.  
    

  7. void  uart2_init(u16 baud);
    

  8. void uartDMA_Init( void );
    

  9. void myDMA_Enable( DMA_Channel_TypeDef*DMA_CHx );
    

  10. void uart2_Send( u8 *buf, u16 len );
    

  11. void copy_data( u8 *buf, u16 len );
    

  12. #endif
    

  13.
回复

收藏1 举报

 楼主| 花间一壶酒sd 发表于 2023-4-22 00:18 | 显示全部楼层
uart2.c
复制
  1. //串口2空闲中断 + DMA数据传输
    

  2. #include "uart2.h"
    

  3. #define UART2_DMA  1                                                                                                                                                                //使用串口2  DMA传输
    

  4. #define  CHECK_NONE_ONE_STOP    1 //无校验位  1个停止位  1有效  0 无效 
    

  5. #define  CHECK_NONE_TWO_STOP    0 //无校验位  2个停止位  1有效  0 无效 
    

  6. #define  CHECK_EVEN    0          //偶数校验   1有效  0 无效 
    

  7. #define  CHECK_ODD     0          //奇数校验   1有效  0 无效 
    

  8.  
    

  9. u8 dma_rec_buff[DMA_REC_LEN] = {0};
    

  10. u16 uart2_rec_cnt = 0;                                                                                                                                                        //串口接收数据长度
    

  11.  
    

  12. u8 data_backup[DMA_REC_LEN] = {0};                                                                                                         //数据备份
    

  13. u16 dataLen_backup = 0;                                                                                                                                                        //长度备份
    

  14. _Bool receiveOK_flag = 0;                                                                                                                                                //接收完成标志位
    

  15.  
    

  16. /*
    

  17. 空闲中断是什么意思呢？
    

  18. 指的是当总线接收数据时，一旦数据流断了，此时总线没有接收传输，处于空闲状态，IDLE就会置1，产生空闲中断；又有数据发送时，IDLE位就会置0；
    

  19. 注意：置1之后它不会自动清0，也不会因为状态位是1而一直产生中断，它只有0跳变到1时才会产生，也可以理解为上升沿触发。
    

  20. 所以，为确保下次空闲中断正常进行，需要在中断服务函数发送任意数据来清除标志位。
    

  21. */
    

  22.  
    

  23. void  uart2_init( u16 baud )
    

  24. {
    

  25.     GPIO_InitTypeDef GPIO_InitStructure;
    

  26.     USART_InitTypeDef USART_InitStructure;
    

  27.     NVIC_InitTypeDef  NVIC_InitStructure;
    

  28.  
    

  29.     RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA, ENABLE );
    

  30.     RCC_APB1PeriphClockCmd( RCC_APB1Periph_USART2, ENABLE );
    

  31.  
    

  32.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
    

  33.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;                                                                                                 //推挽复用模式
    

  34.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    

  35.     GPIO_Init( GPIOA, &GPIO_InitStructure );
    

  36.  
    

  37.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
    

  38.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;                                                                         //浮空输入模式
    

  39.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    

  40.     GPIO_Init( GPIOA, &GPIO_InitStructure );
    

  41.  
    

  42.     NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
    

  43.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x02;
    

  44.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x02;
    

  45.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    

  46.  
    

  47.     NVIC_Init( &NVIC_InitStructure );
    

  48.  
    

  49.     USART_InitStructure.USART_BaudRate = baud;
    

  50.     USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    

  51.     USART_InitStructure.USART_StopBits = USART_StopBits_1;
    

  52.     USART_InitStructure.USART_Parity = USART_Parity_No;
    

  53.                 
    

  54. #if(CHECK_EVEN == 1)                                                                                                                                                                                                                          //如果定义了偶校验  数据位长度要改为9位
    

  55.     USART_InitStructure.USART_WordLength = USART_WordLength_9b;
    

  56.     USART_InitStructure.USART_Parity = USART_Parity_Even;
    

  57. #endif
    

  58.  
    

  59. #if(CHECK_ODD == 1)                                                                                                                                                                                                                          //如果定义了奇校验  数据位长度要改为9位
    

  60.     USART_InitStructure.USART_WordLength = USART_WordLength_9b;
    

  61.     USART_InitStructure.USART_Parity = USART_Parity_Odd;
    

  62. #endif
    

  63.  
    

  64. #if(CHECK_NONE_ONE_STOP==1)                                                                                                                                                                                           //停止位为 一位
    

  65.     USART_InitStructure.USART_StopBits = USART_StopBits_1;
    

  66. #endif
    

  67.  
    

  68. #if(CHECK_NONE_TWO_STOP==1)                                                                                                                                                                                                 //停止位为 两位                                                                                                                                        
    

  69.     USART_InitStructure.USART_StopBits = USART_StopBits_2;
    

  70. #endif                
    

  71.                 
    

  72.                 
    

  73.     USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    

  74.     USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    

  75.  
    

  76.     USART_Init( USART2, &USART_InitStructure );
    

  77.                 
    

  78. #if (UART2_DMA == 1)
    

  79.     USART_ITConfig( USART2, USART_IT_IDLE, ENABLE );                                                                                         //使能串口空闲中断
    

  80.     USART_DMACmd( USART2, USART_DMAReq_Rx, ENABLE );                                                                                         //使能串口2 DMA接收
    

  81.     uartDMA_Init();                                                                                                                                                                                                                                 //初始化 DMA
    

  82. #else
    

  83.     USART_ITConfig( USART2, USART_IT_RXNE, ENABLE );                                                                                   //使能串口RXNE接收中断
    

  84. #endif
    

  85.     USART_Cmd( USART2, ENABLE );                                                                                                                                                                         //使能串口2
    

  86.                 
    

  87. //RXNE中断和IDLE中断的区别？
    

  88. //当接收到1个字节，就会产生RXNE中断，当接收到一帧数据，就会产生IDLE中断。比如给单片机一次性发送了8个字节，就会产生8次RXNE中断，1次IDLE中断。
    

  89. }
    

  90.  
    

  91. void uartDMA_Init( void )
    

  92. {
    

  93.     DMA_InitTypeDef  DMA_IniStructure;
    

  94.  
    

  95.     RCC_AHBPeriphClockCmd( RCC_AHBPeriph_DMA1, ENABLE );                                                                          //使能DMA时钟
    

  96.  
    

  97.     DMA_DeInit( DMA1_Channel6 );                                                                                                                                                             //DMA1通道6对应 USART2_RX
    

  98.     DMA_IniStructure.DMA_PeripheralBaseAddr = ( u32 )&USART2->DR;                                         //DMA外设usart基地址
    

  99.     DMA_IniStructure.DMA_MemoryBaseAddr = ( u32 )dma_rec_buff;                                                  //DMA内存基地址
    

  100.     DMA_IniStructure.DMA_DIR = DMA_DIR_PeripheralSRC;                                                                                         //数据传输方向，从外设读取发送到内存
    

  101.     DMA_IniStructure.DMA_BufferSize = DMA_REC_LEN;                                                                                                 //DMA通道的DMA缓存的大小  也就是 DMA一次传输的字节数
    

  102.     DMA_IniStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;                                 //外设地址寄存器不变
    

  103.     DMA_IniStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;                                                                 //数据缓冲区地址递增
    

  104.     DMA_IniStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; //外设以字节为单位搬运
    

  105.     DMA_IniStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;                                  //数据缓冲区以字节为单位搬入
    

  106.     DMA_IniStructure.DMA_Mode = DMA_Mode_Normal;                                                                                                         //工作在正常缓存模式
    

  107.     DMA_IniStructure.DMA_Priority = DMA_Priority_Medium;                                                                         //DMA通道 x拥有中优先级
    

  108.     DMA_IniStructure.DMA_M2M = DMA_M2M_Disable;                                                                                                                 //DMA通道x没有设置为内存到内存传输
    

  109.  
    

  110.     DMA_Init( DMA1_Channel6, &DMA_IniStructure );
    

  111.     DMA_Cmd( DMA1_Channel6, ENABLE );
    

  112. }
    

  113.  
    

  114. //重新恢复DMA指针
    

  115. void myDMA_Enable( DMA_Channel_TypeDef*DMA_CHx )
    

  116. {
    

  117.     DMA_Cmd( DMA_CHx, DISABLE );                                                                                                                                                                   //关闭DMA1所指示的通道
    

  118.     DMA_SetCurrDataCounter( DMA_CHx, DMA_REC_LEN );                                                                                                 //DMA通道的DMA缓存的大小
    

  119.     DMA_Cmd( DMA_CHx, ENABLE );                                                                                                                                                                           //DMA1所指示的通道
    

  120. }
    

  121. //发送len个字节
    

  122. //buf:发送区首地址
    

  123. //len:发送的字节数
    

  124. void uart2_Send( u8 *buf, u16 len )
    

  125. {
    

  126.     u16 t;
    

  127.     for( t = 0; t < len; t++ )                                                                                                                                                                                 //循环发送数据
    

  128.     {
    

  129.         while( USART_GetFlagStatus( USART2, USART_FLAG_TC ) == RESET );
    

  130.         USART_SendData( USART2, buf[t] );
    

  131.     }
    

  132.     while( USART_GetFlagStatus( USART2, USART_FLAG_TC ) == RESET );
    

  133. }
    

  134.  
    

  135. //备份接收到的数据
    

  136. void copy_data( u8 *buf, u16 len )
    

  137. {
    

  138.     u16 t;
    

  139.     dataLen_backup = len;                                                                                                                                                                                                         //保存数据长度
    

  140.     for( t = 0; t < len; t++ )
    

  141.     {
    

  142.         data_backup[t] = buf[t];                                                                                                                                                                         //备份接收到的数据，防止在处理数据过程中接收到新数据，将旧数据覆盖掉。
    

  143.     }
    

  144. }
    

  145. // Modbus RTU 通信协议
    

  146. //地址码 功能码 寄存器高位 寄存器低位  数据高位  数据低位 CRC高位 CRC低位
    

  147. //01     03      00          00         03         e8      xx        xx
    

  148. //利用空闲中断接收串口不定长数据
    

  149. //串口接收一组数据结束后才会进入中断,在数据发送过程中,已经接收到的数据将会被存入DMA的缓冲区中
    

  150. void USART2_IRQHandler( void )
    

  151. {
    

  152.     u8 tem = 0;
    

  153. #if (UART2_DMA == 1)                        //如果使能了 UART2_DMA 则使用串口空闲中断和 DMA功能接收数据
    

  154.         if( USART_GetITStatus( USART2, USART_IT_IDLE ) != RESET )                                                                                   //空闲中断  一帧数据发送完成
    

  155.     {
    

  156.         USART_ReceiveData( USART2 );                                                                                                                                                                                 //读取数据注意：这句必须要，否则不能够清除空闲中断标志位。
    

  157.         DMA_Cmd( DMA1_Channel6, DISABLE );                                                                                                                                                         //关闭 DMA 防止后续数据干扰
    

  158.         uart2_rec_cnt = DMA_REC_LEN - DMA_GetCurrDataCounter( DMA1_Channel6 );  //DMA接收缓冲区数据长度减去当前 DMA传输通道中剩余单元数量就是已经接收到的数据数量
    

  159.         //uart2_Send( dma_rec_buff, uart2_rec_cnt );                                                                                                                //发送接收到的数据
    

  160.                           copy_data( dma_rec_buff, uart2_rec_cnt );                                                                                                                    //备份数据
    

  161.         receiveOK_flag = 1;                                                                                                                                                                                                                        //置位数据接收完成标志位
    

  162.         USART_ClearITPendingBit( USART2, USART_IT_IDLE );                                                                                                 //清除空闲中断标志位
    

  163.         myDMA_Enable( DMA1_Channel6 );                                                                                                                                                                         //重新恢复 DMA等待下一次接收
    

  164.     }
    

  165. #else                                                                                //如果未使能 UART2_DMA 则通过常规方式接收数据  每接收到一个字节就会进入一次中断
    

  166.     if( USART_GetITStatus( USART2, USART_IT_RXNE ) != RESET )                                                 //接收中断
    

  167.     {
    

  168.         tem = USART_ReceiveData( USART2 );
    

  169.         USART_SendData( USART2, tem );
    

  170.     }
    

  171. #endif
    

  172. }
    

  173.
回复

收藏1 举报

 楼主| 花间一壶酒sd 发表于 2023-4-22 00:18 | 显示全部楼层
modbus.h
复制
  1. #ifndef __MODBUS_H
    

  2. #define __MODBUS_H
    

  3. #include "sys.h"
    

  4.  
    

  5.  
    

  6. #define SlaveID  0x01     //从机地址
    

  7.  
    

  8. void DisposeReceive( void );
    

  9. void Modbus_03_Slave(void);
    

  10. void Modbus_06_Slave(void);
    

  11. void Modbus_16_Slave(void);
    

  12. #endif
回复

收藏1 举报

下一页 »
12下一页
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

花间一壶酒sd

101

主题

1219

帖子

2

粉丝
快速回复 在线客服 返回列表 返回顶部