前两天在研究STM32F103单片机的串口空闲中断时，突然想起来Modbus通信非常适合用空闲中断来处理。先看看Modbus RTU模式下的通信规范。
& ?* \6 t9 S, _7 c3 V% M
8 s$ a" q% N) G

       可以看到Modbus RTU通信模式下，数据的开始和结束是由空闲字符间隔时间来区分的，而STM32F103单片机自带串口空闲模式检测。
" R) }1 X% v9 X6 c, ]# y$ p


; q, a# H) m  q' a9 @        在通常情况下Modbus通信一帧数据的检测可以用时间判断，不停的去读取接收数据的长度是否发送变化，如果在一定时间内，接收数据的长度没有发生变化，就认为一帧数据结束完毕。

        通过时间来判断一帧数据是否接收完成，会导致单片机不停的进入中断。而STM32F103单片机自带了空闲数据检测功能，这个功能是由单片机内部的硬件完成的，不需要程序去处理，这样单片机的就有机会去执行更多了任务了。为了让单片机在处理Modbus RTU通信时更简单快速，可以用 串口DMA加上空闲中断的方式来实现。
* C$ q2 Q; G) M7 `6 _
- P/ f3 ^8 h$ l4 A        下面直接用代码说明具体的实现过程，首先初始化串口。
  U8 @8 L8 g7 ]3 ]5 ~) E( h+ m
+ @& W% b, [" B$ q4 I+ D5 @

1. #define UART2_DMA  1                                                                                                                                                                //使用串口2  DMA传输
   
2. #define  CHECK_NONE_ONE_STOP    1 //无校验位  1个停止位  1有效  0 无效
   % C0 k. q' ^- f1 O( T7 T
3. #define  CHECK_NONE_TWO_STOP    0 //无校验位  2个停止位  1有效  0 无效
   1 \/ G7 D  h3 x& \
4. #define  CHECK_EVEN    0          //偶数校验   1有效  0 无效
   5 n" i, e/ b( n5 o
5. #define  CHECK_ODD     0          //奇数校验   1有效  0 无效
   / B' P! b$ F2 w9 W, g) }
6. 
   
7. 
   
8. void  uart2_init( u16 baud )
   ' f' T4 _* ^+ d9 M0 @
9. {
   + O4 V' R1 g+ \) m7 F# o- H
10.     GPIO_InitTypeDef GPIO_InitStructure;
    1 |) t! h' h' \, X- r
11.     USART_InitTypeDef USART_InitStructure;
    # b0 M) ?  J; w1 g
12.     NVIC_InitTypeDef  NVIC_InitStructure;
    
13. 
    
14.     RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA, ENABLE );
    7 Q% j5 R) L3 K2 O, o) p1 W
15.     RCC_APB1PeriphClockCmd( RCC_APB1Periph_USART2, ENABLE );
    
16. 
    
17.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
    6 p: R  ]+ L7 y6 r  H; |
18.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;                                                                                                 //推挽复用模式
    7 Q3 S, r3 l# A; K8 V
19.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    * s% E0 ^, d1 |9 N* C) l# O5 O
20.     GPIO_Init( GPIOA, &GPIO_InitStructure );
    
21. 
    ( R% G0 J; a, r; o# B
22.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
    1 H2 c( d& `4 t* m
23.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;                                                                         //浮空输入模式
    
24.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
25.     GPIO_Init( GPIOA, &GPIO_InitStructure );
    2 s' k$ e* L" g9 }! s. E
26. 
    1 j; J2 r; h. V- T9 M+ N3 B9 Q
27.     NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
    6 |; m/ P  {7 I; h, h" p# ^
28.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x02;
    
29.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x02;
    ! b' W1 u% a3 ~+ ~0 B" M/ U
30.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    ' m7 D) p5 t! k1 R  k
31. 
    
32.     NVIC_Init( &NVIC_InitStructure );
    9 r" A1 }: r3 @0 Q/ a! h( A
33. 
    
34.     USART_InitStructure.USART_BaudRate = baud;
    ' \# u7 r. u4 h' b& U$ F% E
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.                
    0 [6 H! U5 F" b9 O
39. #if(CHECK_EVEN == 1)                                                                                                                                                                                                                          //如果定义了偶校验  数据位长度要改为9位
    ! K1 \$ L6 M$ S  ~9 X+ E
40.     USART_InitStructure.USART_WordLength = USART_WordLength_9b;
    . f: k8 l: B3 Q, u
41.     USART_InitStructure.USART_Parity = USART_Parity_Even;
    ; g3 H9 H; c1 G2 s5 ]. X% R: {* p% X
42. #endif
    
43. 
    & g1 R5 s6 k5 a9 V
44. #if(CHECK_ODD == 1)                                                                                                                                                                                                                          //如果定义了奇校验  数据位长度要改为9位
    : d$ P/ b* W, h* N4 Z
45.     USART_InitStructure.USART_WordLength = USART_WordLength_9b;
    
46.     USART_InitStructure.USART_Parity = USART_Parity_Odd;
    % `6 d( \' y3 r
47. #endif
    
48. 
    & M9 a! j) k, X
49. #if(CHECK_NONE_ONE_STOP==1)                                                                                                                                                                                           //停止位为 一位
    $ E( \$ \3 d# H' w0 v
50.     USART_InitStructure.USART_StopBits = USART_StopBits_1;
    
51. #endif
    " y& G: X! X& x9 @
52. 
    ( `1 i; Z' \4 a  v7 L1 }* m6 ?9 z
53. #if(CHECK_NONE_TWO_STOP==1)                                                                                                                                                                                                 //停止位为 两位                                                                                                                                       
    
54.     USART_InitStructure.USART_StopBits = USART_StopBits_2;
    % ?/ n! m8 P7 ]+ X7 z
55. #endif               
    
56.                
    ' |: j( b. j- a2 |6 R
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.                
    9 R8 a* ^8 o9 l. x4 @$ p( l  V
63. #if (UART2_DMA == 1)
    6 G# j/ e& J  ]: [2 P9 x
64.     USART_ITConfig( USART2, USART_IT_IDLE, ENABLE );                                                                                         //使能串口空闲中断
    
65.     USART_DMACmd( USART2, USART_DMAReq_Rx, ENABLE );                                                                                         //使能串口2 DMA接收
    # T0 Z6 B) u% {# r( w* \& u9 E
66.     uartDMA_Init();                                                                                                                                                                                                                                 //初始化 DMA
    % p9 ]/ p2 R( Q
67. #else
    
68.     USART_ITConfig( USART2, USART_IT_RXNE, ENABLE );                                                                                   //使能串口RXNE接收中断
    
69. #endif
      Y% T" y! L* j! I3 `9 ^
70.     USART_Cmd( USART2, ENABLE );                                                                                                                                                                         //使能串口2
    
71.                
    
72. //RXNE中断和IDLE中断的区别？
    
73. //当接收到1个字节，就会产生RXNE中断，当接收到一帧数据，就会产生IDLE中断。比如给单片机一次性发送了8个字节，就会产生8次RXNE中断，1次IDLE中断。
    0 ?+ h2 h& s* t, G  Q) O# d, G7 |+ t
74. }

复制代码

        在Modbus通信时，需要对每个字节的数据进行校验，所以这里使用宏定义来初始化串口数据使用的是那种校验方式。如果需要偶校验就将CHECK_EVEN 设置为1，如果需要奇校验就将CHECK_ODD设置为1，如果不需要校验位，就将这两个都设置为0。在串口初始化的时候，需要开启空闲中断和DMA功能。

3 b. Y9 G- b. ]        下来初始化 串口2的DMA功能
2 p  M, C" W0 g6 X4 ]

1. void uartDMA_Init( void )
   % C  _4 {. ~0 ]! d' l2 s
2. {
   
3.     DMA_InitTypeDef  DMA_IniStructure;
   
4. 
   
5.     RCC_AHBPeriphClockCmd( RCC_AHBPeriph_DMA1, ENABLE );                                                                          //使能DMA时钟
   4 S) w* |1 @' A% O9 \# e: P7 \
6. 
   & ~. g1 \  d, f9 a9 c! b- K
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;                                                                                         //数据传输方向，从外设读取发送到内存
    & z" s6 x- J9 ~+ Z- k
11.     DMA_IniStructure.DMA_BufferSize = DMA_REC_LEN;                                                                                                 //DMA通道的DMA缓存的大小  也就是 DMA一次传输的字节数
    1 S+ [6 x! O/ N. M2 }
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;                                                                                                         //工作在正常缓存模式
    ! C# t4 Z' q) \& Q
17.     DMA_IniStructure.DMA_Priority = DMA_Priority_Medium;                                                                         //DMA通道 x拥有中优先级
    - p& X' L% j  Q# f& @* M
18.     DMA_IniStructure.DMA_M2M = DMA_M2M_Disable;                                                                                                                 //DMA通道x没有设置为内存到内存传输
    ' S+ |! \. A# s
19. 
    5 o' |4 Q9 j$ N/ @! I3 P
20.     DMA_Init( DMA1_Channel6, &DMA_IniStructure );
    1 G1 S" g( |' ~, o" @# K
21.     DMA_Cmd( DMA1_Channel6, ENABLE );
    
22. }

复制代码

1 L& x; B' G7 n  C
0 K! ^. x# k  g. i/ M# B7 [        串口2的接收对应的是DMA的通道6，所以DMA的通道选择通道6，然后将串口2的数据寄存器作为外设基地址，将数组dma_rec_buff作为DMA的内存地址。外设地址不自增，内存地址自增。这样串口2每接收一个字节的数据，DMA就将接收到的数据存入数组dma_rec_buff中，同时指向数组的地址增加一位，这样串口2接收到的数据就会被一直存放在数组dma_rec_buff中。
: m0 g% d9 T5 Y$ G6 S4 x0 O# r' t
0 @7 Z2 @* F$ W3 t        这里要注意一点，数组的缓存区要大于串口2接收到的最长数据个数，否则如果接收到串口数据比较长，而数组比较小，数组中的数据就会被覆盖，导致接收到的数据错误。

* C0 x. _& R+ a0 s( f9 T     接下来就是串口中断的实现了
4 |4 }" ?9 k3 F) Y7 h9 D
8 w2 V3 @2 u& H. |" r

1. void USART2_IRQHandler( void )
   1 Q+ {  }/ z6 f
2. {
   
3.     u8 tem = 0;
   
4. #if (UART2_DMA == 1)                        //如果使能了 UART2_DMA 则使用串口空闲中断和 DMA功能接收数据
   ' o! n$ |, j/ o$ a
5.         if( USART_GetITStatus( USART2, USART_IT_IDLE ) != RESET )                                                                                   //空闲中断  一帧数据发送完成
   
6.     {
   
7.         USART_ReceiveData( USART2 );                                                                                                                                                                                 //读取数据注意：这句必须要，否则不能够清除空闲中断标志位。
   ' K" \' _1 e' C$ B
8.         DMA_Cmd( DMA1_Channel6, DISABLE );                                                                                                                                                         //关闭 DMA 防止后续数据干扰
   
9.         uart2_rec_cnt = DMA_REC_LEN - DMA_GetCurrDataCounter( DMA1_Channel6 );  //DMA接收缓冲区数据长度减去当前 DMA传输通道中剩余单元数量就是已经接收到的数据数量
   : q1 ^4 K9 o9 |/ I, C+ {7 |
10. 
    
11.         copy_data( dma_rec_buff, uart2_rec_cnt );                                                                                                                    //备份数据
    3 E$ ^0 O& C; K  W, P" t! _3 I. Z8 l( T
12.         receiveOK_flag = 1;                                                                                                                                                                                                                        //置位数据接收完成标志位
    
13.         USART_ClearITPendingBit( USART2, USART_IT_IDLE );                                                                                                 //清除空闲中断标志位
    8 B+ w3 ^: J5 P  F2 T  \8 s
14.         myDMA_Enable( DMA1_Channel6 );                                                                                                                                                                         //重新恢复 DMA等待下一次接收
    3 R/ v. C4 k& k- i- F* |3 }. L4 K
15.     }
    % @  i5 L$ M' z3 n, P4 |0 O# s: K
16. #else                                                                                //如果未使能 UART2_DMA 则通过常规方式接收数据  每接收到一个字节就会进入一次中断
    + S2 ^$ {& Z2 V* M4 H% P+ u
17.     if( USART_GetITStatus( USART2, USART_IT_RXNE ) != RESET )                                                 //接收中断
    / ~1 T! l5 j2 a. M- J5 A
18.     {
    7 s. f0 N$ o/ Z7 {6 h) f: q& F
19.         tem = USART_ReceiveData( USART2 );
    8 e. O. J1 c, h( U5 ]) s0 T
20.         USART_SendData( USART2, tem );
      U0 V) A+ x, \' B
21.     }
    
22. #endif
    
23. }

复制代码

        串口进入空闲中断后，说明一帧数据已经接收完成。关闭DMA通道，开始处理数据。获取DMA中接收到的数据长度，然后将数据拷贝到备份数组中，然后置接收完成标志位。开启 DMA进行下一次数据接收。
0 l: r( i7 K" C" `0 C" v3 {& a6 x9 u
        在主程序中如果检测到了数据接收完成标志时，就开始处理接收到的数据。这样就可以将串口接收数据和处理数据分开，在处理上一笔数据的时候，就可以继续接收下一笔数据。提高了系统的实时性。
  W- j; w2 T2 S( u4 {; b
, s- |/ w$ p, }1 W8 j, L        这里如果直接使用DMA接收数组去处理数据的话，有可能会出现，旧的一笔数据未处理完成时,DMA接收到了新的一笔数据，然后存储到了 DMA缓存数组中。这样在处理数据过程中，旧的数据就会被新的数据覆盖掉，导致系统异常。如果Modbus的通信速率没有那么快，在下一次数据来临之前，系统完全有时间处理完上一笔数据，那么直接使用DMA的缓存数据也是可以的。

       不过上面这种将数据拷贝倒其他数据中处理的方法也是有风险的。比如第一笔数据还没处理完成，第二笔数据已经接收完成，此时进入串口空闲中断，系统依然会将第二笔数据拷贝到备份数组中去。这样备份数组中的数据依然会被覆盖。但是这种情况如果出现的话，就说明接收数据的频率高于系统处理数据的频率，系统本身就存在风险，需要重新设计。
' q- N7 \+ R( X6 q" N! ?; t9 N
     接收数据完成后，就需要在主程序中调用数据处理函数。
/ D6 i1 T2 L6 @

1. int main(void)
   
2. {
   
3.     u8  j = 0;
   
4.         
   9 u4 G5 P! F2 g2 N
5.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
   ( f1 [" I/ j$ Z; p% ]" I
6.         
   # Q1 L  y- c  H3 _& [- E
7.     delay_init();       //延时函数初始化
   4 q, X- D# X' q' D% N6 ]
8.     LED_Init();         //初始化与LED连接的硬件接口
   4 n, M. h% s- r: t& d: C/ g
9.     uart2_init(9600);
   
10.     while(1)
    ) h! O5 {7 d7 n/ t* B* O1 q
11.     {
    2 I* _* R2 A; }: _& e3 v4 N) a
12. 
    
13.         if( receiveOK_flag )                                //一帧数据接收完成后开始处理数据
    
14.         {
    % Y/ J( t, `5 H+ m  m" Z+ X% T
15.             receiveOK_flag = 0;
    
16.             DisposeReceive();                                //处理modbus通信
    ' E) Q; c1 I  b1 m1 h5 Z0 @
17.         }
    
18.                         
    : B; a: S' t. t5 M* `
19.         j++;
    
20.         if(j > 50)
    
21.         {
    
22.             j = 0;
    
23.             LED = !LED;
    
24.         }
    
25.         delay_ms(10);
    ! _8 A* N* t+ N4 o* j# ?: k  c+ d
26.     }
    . R6 Y' A) h, S# E/ b3 o, u( U& F- G
27. }

复制代码

最后是Modbus的协议解析

1. void DisposeReceive( void )
   ! m. [6 I0 ?% G/ A5 m7 r. ~2 ]
2. {
   
3.     u16 CRC16 = 0, CRC16Temp = 0;
   : U/ q1 U7 E0 ~( n" W. M
4.     if( data_backup[0] == SlaveID )                                                                         //地址等于本机地址 地址范围:1 - 32
   
5.     {
   . x4 p$ r# [* u2 ^2 g
6.         CRC16 = App_Tab_Get_CRC16( data_backup, dataLen_backup - 2 );                                  //CRC校验 低字节在前 高字节在后 高字节为报文最后一个字节
   ; \- W% o; K4 H
7.         CRC16Temp = ( ( u16 )( data_backup[dataLen_backup - 1] << 8 ) | data_backup[dataLen_backup - 2] );
   
8.         if( CRC16 != CRC16Temp )
   
9.         {
   
10.             err = 4;                                                                                               //CRC校验错误
    
11.         }
    6 ^' s0 u( B1 {4 q2 z9 z
12.         StartRegAddr = ( u16 )( data_backup[2] << 8 ) | data_backup[3];
    
13.         if( StartRegAddr > (HoldRegStartAddr + HoldRegCount - 1) )
    
14.         {
    . }4 d4 {' t6 G) h8 e. \8 \* a9 H* Z
15.             err = 2;                                                                                               //起始地址不在规定范围内 00 - 07    1 - 8号通道
    
16.         }
      l  m$ H5 _2 i. X$ o9 x
17.         if( err == 0 )
    
18.         {
    2 h% D/ f7 [( D3 F
19.             switch( data_backup[1] )                                                                        //功能码
    
20.             {
    7 w% J1 t4 u6 h8 A2 Q
21.                 case 3:                                                                                            //读多个寄存器
    ! @, K2 j8 Q+ M1 S. j( d
22.                 {
    ; q$ h9 \6 A% s2 b6 o* f
23.                     Modbus_03_Slave();
    
24.                     break;
    
25.                 }
    
26.                 case 6:                                                                                            //写单个寄存器
    - O: s, p- U6 J# L
27.                 {
    
28.                     Modbus_06_Slave();
    4 N3 r, Y* Y; ]. [3 n7 R! F5 a, j
29.                     break;
    6 h: \1 u& U" Q; J0 \+ W
30.                 }
    
31.                 case 16:                                                                                           //写多个寄存器
    
32.                 {
    
33.                     Modbus_16_Slave();
    8 n- S# w. V# A9 A; j
34.                     break;
    
35.                 }
    
36.                 default:
    
37.                 {
    . s6 U  g; Z- ?, p  y
38.                     err = 1;                                                                                       //不支持该功能码
    
39.                     break;
    
40.                 }
    
41.             }
    $ Y7 S- n0 c$ h  y( E" r( \3 }
42.         }
    
43.         if( err > 0 )
    . ?( C  J) W0 N- }
44.         {
    # I  y1 a4 b) m! I, v% h
45.             SendBuf[0] = data_backup[0];
    2 h9 U( f3 b6 L
46.             SendBuf[1] = data_backup[1] | 0x80;
    
47.             SendBuf[2] = err;                                                                                      //发送错误代码
    ( d, c/ T6 t8 q# c) K
48.             CRC16Temp = App_Tab_Get_CRC16( SendBuf, 3 );                                                           //计算CRC校验值
    ' i4 o+ ]+ p& \6 Q; `, W
49.             SendBuf[3] = CRC16Temp & 0xFF;                                                                         //CRC低位
    , q0 {. X& m. f4 S2 ~" z* T
50.             SendBuf[4] = ( CRC16Temp >> 8 );                                                                       //CRC高位
    ) N0 U9 V% p$ ]4 A# H
51.             uart2_Send( SendBuf, 5 );                                       
    
52.             err = 0;                                                                                               //发送完数据后清除错误标志
    
53.         }
    
54.     }
    2 I3 J2 ^( L  [* n3 ?  N
55. }
    
56. 
    9 j& {8 [7 }) j" k( t5 x. W' V) D
57. /*
    
58. 函数功能：读保持寄存器  03
    
59. 主站请求报文:      0x01 0x03   0x0000  0x0001  0x840A     读从0开始的1个保持寄存器
    
60. 从站正常响应报文:  0x01 0x03   0x02    0x09C4  0xBF87     读到的2字节数据为 0x09C4
    ) b$ z' S& i/ N; {
61. */
    
62. void Modbus_03_Slave( void )
    
63. {
    
64.     u16 RegNum = 0;
    4 I. U9 L/ P/ h2 d: l. z
65.     u16 CRC16Temp = 0;
    ! M; C3 B: n7 S- L
66.     u8 i = 0;
    
67.     RegNum = ( u16 )( data_backup[4] << 8 ) | data_backup[5];                                                //获取寄存器数量
    
68.     if( ( StartRegAddr + RegNum ) <= (HoldRegStartAddr + HoldRegCount) )      //寄存器地址+寄存器数量 在规定范围内 <=8
    
69.     {
    ) ^; K6 ]+ J4 I, Q
70.         SendBuf[0] = data_backup[0];                                                                                                                                                                        //地址        
    # N! E8 d2 e* j- \1 X& C
71.         SendBuf[1] = data_backup[1];                                                                                                                                                                        //功能码
    ( t( T- b- @2 s  L0 C- u
72.         SendBuf[2] = RegNum * 2;                                                                                                                                                                                        //返回字节数量
    + Q; v8 R, g+ l; b0 Y9 f. u
73.         for( i = 0; i < RegNum; i++ )                                                                             //循环读取保持寄存器内的值
    9 J1 ~+ ]0 c( r7 m
74.         {
    6 C8 P" X3 R" t- t9 ~/ D
75.             SendBuf[3 + i * 2] = HoldReg[StartRegAddr * 2 + i * 2];
    ! n/ G# h7 E8 w) A3 c& m! a# I+ P
76.             SendBuf[4 + i * 2] = HoldReg[StartRegAddr * 2 + i * 2 + 1];
    : W8 ~8 p& d6 Y. s6 \
77.         }
    
78.         CRC16Temp = App_Tab_Get_CRC16( SendBuf, RegNum * 2 + 3 );                                                  //获取CRC校验值
    
79.         SendBuf[RegNum * 2 + 3] = CRC16Temp & 0xFF;                                                                //CRC低位
    4 n3 S6 C/ h  g  ^
80.         SendBuf[RegNum * 2 + 4] = ( CRC16Temp >> 8 );                                                              //CRC高位
    
81.         uart2_Send( SendBuf, RegNum * 2 + 5 );
    
82.     }
    5 t: p  i4 Z: x  {3 ^. R
83.     else
    ; j8 o2 r# l- {) X) i
84.     {
    
85.         err = 3;                                                                                                   //寄存器数量不在规定范围内
    
86.     }
    
87. }
    * T8 K, X( M; t/ e
88. /*
    / j7 Z( R" s6 u* D: T
89. 函数功能:写单个保持寄存器 06
    & p/ K% ^9 i4 X# Y+ [
90. 主站请求报文:      0x01 0x06    0x0000  0x1388    0x849C   写0号寄存器的值为0x1388
    
91. 从站正常响应报文:  0x01 0x06    0x0000  0x1388    0x849C    0号寄存器的值为0x1388
    
92. */
    ) `2 _2 R8 a* Q
93. void Modbus_06_Slave( void )
    ( l! B4 m2 m+ s
94. {
    
95.     u16  RegValue = 0;
    
96.     u16 CRC16Temp = 0;
    : ?" m; v! K* G
97.     RegValue = ( u16 )( data_backup[4] << 8 ) | data_backup[5];                                              //获取寄存器值
    5 V4 d# I, _0 R% H
98.     if( RegValue <= HoldMaxValue )                                                  //寄存器值不超过1000
    
99.     {
    2 m& l) m3 ?) c& P, U& U# m8 j
100.         HoldReg[StartRegAddr * 2] = data_backup[4];                                                         //存储寄存器值
     + K/ u/ V' Q; t0 W
101.         HoldReg[StartRegAddr * 2 + 1] = data_backup[5];
     / g2 t" z! N$ o
102.         SendBuf[0] = data_backup[0];                                                                                                                                                                        //地址
     # w4 u6 Q  A# J6 a( t
103.         SendBuf[1] = data_backup[1];                                                                                                                                                                        //功能码
     ! A" Y: ~4 M+ H$ ?
104.         SendBuf[2] = data_backup[2];                                                                                                                                                                        //地址高位
     - x, H( n! y# e" Y- ~3 S
105.         SendBuf[3] = data_backup[3];                                                                                                                                                                        //地址低位
     
106.         SendBuf[4] = data_backup[4];                                                                                                                                                                        //值高位
     3 t: h: D% G9 U) M' P' w
107.         SendBuf[5] = data_backup[5];                                                                                                                                                                        //值低位
     * B! u" R/ G; f
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 );
     & }, }5 O8 z  k
112.     }
     
113.     else
     
114.     {
     
115.         err =  3;                                                                                                  //寄存器数值不在规定范围内
     
116.     }
     
117. }
     - Y5 q; N, \5 y' V$ B3 w
118. /*
     
119. 函数功能:写多个连续保持寄存器值 16
     
120. 主站请求报文:       0x01 0x10    0x7540  0x0002  0x04  0x0000 0x2710    0xB731  写从0x7540地址开始的2个保持寄存器值 共4字节
     
121. 从站正常响应报文:   0x01 0x10    0x7540  0x0002  0x5A10                         写从0x7540地址开始的2个保持寄存器值
     5 |% x  y2 n* s9 m
122. */
     * a% t1 o8 \8 ]! |
123. void Modbus_16_Slave( void )
     
124. {
     9 Y. P4 Y9 b3 O/ ?  K: f- C
125.     u16 RegNum = 0;
     
126.     u16 CRC16Temp = 0;
     4 s( y& w& W' q; l, r) `
127.     u8 i = 0;
     
128.     RegNum = ( u16 )( data_backup[4] << 8 ) | data_backup[5];                                                //获取寄存器数量
     9 R" ^& V, j8 o( j9 r: @
129.     if( ( StartRegAddr + RegNum ) <= (HoldRegStartAddr + HoldRegCount) )             //寄存器地址+寄存器数量 在规定范围内 <=8
     * y1 |  o. d* ?
130.     {
     - ~  ]4 p2 r) [# Q; z% u! G$ c
131.         for( i = 0; i < RegNum; i++ )                                                                              //存储寄存器设置值
     ) p" o% s; |7 ~0 ~  L
132.         {
     / t* V  M: s7 N& D5 M1 w9 u
133.             HoldReg[StartRegAddr * 2 + i * 2] = data_backup[i * 2 + 7];
     
134.             HoldReg[StartRegAddr * 2 + 1 + i * 2] = data_backup[i * 2 + 8];
     1 v! R- `( }! N# P, E" [" L
135.         }
     # j8 ~0 {) F4 K/ J% K
136.         SendBuf[0] = data_backup[0];                                                                                                                                                                        //起始地址
     
137.         SendBuf[1] = data_backup[1];                                                                                                                                                                        //功能码
     . G9 j/ w( u. t
138.         SendBuf[2] = data_backup[2];                                                                                                                                                                        //地址高位
     - S+ v! P8 X8 K
139.         SendBuf[3] = data_backup[3];                                                                                                                                                                        //地址低位
     ' I* I% a* w7 d- I: b8 m
140.         SendBuf[4] = data_backup[4];                                                                                                                                                                        //寄存器数量高位
     8 t" Q( {1 A$ g+ _+ c  `
141.         SendBuf[5] = data_backup[5];                                                                                                                                                                        //寄存器数量低位
     
142.         CRC16Temp = App_Tab_Get_CRC16( SendBuf, 6 );                                                        //获取CRC校验值
     
143.         SendBuf[6] = CRC16Temp & 0xFF;                                                                      //CRC低位
     2 k6 k- F5 ?2 ~3 }, ~
144.         SendBuf[7] = ( CRC16Temp >> 8 );                                                                    //CRC高位
     
145.         uart2_Send( SendBuf, 8 );
     
146.     }
     4 v; V7 M3 c, M
147.     else
     
148.     {
     . A/ r# l. P! u* j: L" \
149.         err = 3;                                                                                                   //寄存器数量不在规定范围内
     
150.     }
     
151. }

复制代码

. e; J& K# `4 p8 }- LModbus的执行在这里只实现了最常用的三个。
! o( y9 I6 {/ A# I0 t+ N  G

) G/ A5 j; D( `( s  L2 A
4 I$ K, }3 ?* x$ W7 k各个功能码的实现原理在这里就不说了，直接通过代码中和注释就可以看明白了。
$ j3 Z' X' g1 n$ Z# I
下面贴出串口和modbus的完整代码
9 [/ ]: j6 Q8 T- r
/ R& H. r, n8 B) i0 ]0 X3 p  Suart2.h

; q3 A! ?- E* t/ |

1. #ifndef __UART2_H
   
2. #define __UART2_H
   
3. #include "sys.h"
   * [* Q) {7 }( Q
4. 
   
5. #define DMA_REC_LEN 50                                                                                                                                                        //DMA数据接收缓冲区
   
6. 
   : t' X/ l; {0 _) l: F4 V$ H, X
7. void  uart2_init(u16 baud);
   
8. void uartDMA_Init( void );
   / y5 V' E4 B( _+ H
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
    

复制代码

$ U0 A) G( U: M# l+ z' p# M7 C' Juart2.c

1. //串口2空闲中断 + DMA数据传输
   
2. #include "uart2.h"
   4 k+ L) S; |1 n
3. #define UART2_DMA  1                                                                                                                                                                //使用串口2  DMA传输
   6 E  U, _8 k, u7 p9 O# Z
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 无效
   % v& {; [/ R2 ^  |
7. #define  CHECK_ODD     0          //奇数校验   1有效  0 无效
   0 H( P9 ?5 i# b0 L! F& Q
8. 
   
9. u8 dma_rec_buff[DMA_REC_LEN] = {0};
   3 M) `) J! |3 q/ l  o! x
10. u16 uart2_rec_cnt = 0;                                                                                                                                                        //串口接收数据长度
    
11. 
    
12. u8 data_backup[DMA_REC_LEN] = {0};                                                                                                         //数据备份
    
13. u16 dataLen_backup = 0;                                                                                                                                                        //长度备份
    / Z* H: p  ^" `) w4 |/ p, a
14. _Bool receiveOK_flag = 0;                                                                                                                                                //接收完成标志位
    6 z! [. m3 V" M4 P
15. 
    
16. /*
    
17. 空闲中断是什么意思呢？
    
18. 指的是当总线接收数据时，一旦数据流断了，此时总线没有接收传输，处于空闲状态，IDLE就会置1，产生空闲中断；又有数据发送时，IDLE位就会置0；
    
19. 注意：置1之后它不会自动清0，也不会因为状态位是1而一直产生中断，它只有0跳变到1时才会产生，也可以理解为上升沿触发。
    - R9 m6 K3 v. I" r0 H
20. 所以，为确保下次空闲中断正常进行，需要在中断服务函数发送任意数据来清除标志位。
    " z( e  P, g6 N2 n
21. */
    
22. 
    
23. void  uart2_init( u16 baud )
    ' y+ F: ~2 e6 b, W" x9 Q
24. {
    8 X# S5 k. t* A' l3 c
25.     GPIO_InitTypeDef GPIO_InitStructure;
    " q5 F, l" e6 f7 d
26.     USART_InitTypeDef USART_InitStructure;
    
27.     NVIC_InitTypeDef  NVIC_InitStructure;
    / F+ O* g+ B1 ?" A
28. 
    
29.     RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA, ENABLE );
    3 g6 P+ K5 w! f' _4 n- C
30.     RCC_APB1PeriphClockCmd( RCC_APB1Periph_USART2, ENABLE );
    4 Z2 p# ^2 ]  ]) v2 [8 y5 S) |
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 );
      j/ y; I+ E+ B; o
36. 
    
37.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
    
38.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;                                                                         //浮空输入模式
    % Z) E* S) B7 V/ W
39.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    ; ^9 f# {. r/ X. P; t
40.     GPIO_Init( GPIOA, &GPIO_InitStructure );
    3 e+ F6 r* N; r" D
41. 
    
42.     NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
    
43.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x02;
    4 T( C$ U$ e) @, V5 r7 m% C
44.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x02;
    % f3 n" \+ E. y6 t: p
45.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
46. 
    
47.     NVIC_Init( &NVIC_InitStructure );
    ' [% W; g  h+ {( s& X
48. 
    1 a- k# Y/ i: }
49.     USART_InitStructure.USART_BaudRate = baud;
    % v- w$ q# k3 @1 |
50.     USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    / A; w. C( ]5 P6 O6 d" v3 i
51.     USART_InitStructure.USART_StopBits = USART_StopBits_1;
    
52.     USART_InitStructure.USART_Parity = USART_Parity_No;
    
53.                
    
54. #if(CHECK_EVEN == 1)                                                                                                                                                                                                                          //如果定义了偶校验  数据位长度要改为9位
    * |. l* Q, G4 Y* W
55.     USART_InitStructure.USART_WordLength = USART_WordLength_9b;
    
56.     USART_InitStructure.USART_Parity = USART_Parity_Even;
    * ?4 j. X" G/ S$ H- m5 @
57. #endif
    * d4 J* u$ X7 S5 s
58. 
    
59. #if(CHECK_ODD == 1)                                                                                                                                                                                                                          //如果定义了奇校验  数据位长度要改为9位
    
60.     USART_InitStructure.USART_WordLength = USART_WordLength_9b;
    
61.     USART_InitStructure.USART_Parity = USART_Parity_Odd;
    ' Z8 I: ]9 V/ s/ [) g7 E+ @2 O# S
62. #endif
    
63. 
    ) C6 w) q: j  \! C# U
64. #if(CHECK_NONE_ONE_STOP==1)                                                                                                                                                                                           //停止位为 一位
    
65.     USART_InitStructure.USART_StopBits = USART_StopBits_1;
    ) l; \/ N  f+ b' b: ]3 [3 K) N
66. #endif
    
67. 
    
68. #if(CHECK_NONE_TWO_STOP==1)                                                                                                                                                                                                 //停止位为 两位                                                                                                                                       
    
69.     USART_InitStructure.USART_StopBits = USART_StopBits_2;
    
70. #endif               
    
71.                
    5 Z) G, y. g2 i  o) o1 I+ K
72.                
    . x9 ]5 n$ i8 [) t
73.     USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    ; B% L4 [9 O' c6 _
74.     USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    " c6 W3 H: s# B4 z
75. 
    
76.     USART_Init( USART2, &USART_InitStructure );
    
77.                
    
78. #if (UART2_DMA == 1)
    7 @5 u# @! U! ]8 r0 m3 l4 c' Z
79.     USART_ITConfig( USART2, USART_IT_IDLE, ENABLE );                                                                                         //使能串口空闲中断
    9 [* A" a( R, l
80.     USART_DMACmd( USART2, USART_DMAReq_Rx, ENABLE );                                                                                         //使能串口2 DMA接收
    
81.     uartDMA_Init();                                                                                                                                                                                                                                 //初始化 DMA
    - c3 m1 I4 K" \- H9 ]: @/ J. O
82. #else
    5 p! ?1 u- b! q% j0 a" e) T0 @9 C
83.     USART_ITConfig( USART2, USART_IT_RXNE, ENABLE );                                                                                   //使能串口RXNE接收中断
    ' m; J7 ^8 d0 A- N8 Z# o8 A5 Q% V8 w
84. #endif
    
85.     USART_Cmd( USART2, ENABLE );                                                                                                                                                                         //使能串口2
    
86.                
    
87. //RXNE中断和IDLE中断的区别？
    
88. //当接收到1个字节，就会产生RXNE中断，当接收到一帧数据，就会产生IDLE中断。比如给单片机一次性发送了8个字节，就会产生8次RXNE中断，1次IDLE中断。
    
89. }
    8 [$ V. n& W) i5 i* j" t# I* x. d
90. 
    
91. void uartDMA_Init( void )
    
92. {
    ) s. G) n0 R* x
93.     DMA_InitTypeDef  DMA_IniStructure;
    
94. 
    * J; S3 d* K) N0 `' }4 t6 `% g+ u
95.     RCC_AHBPeriphClockCmd( RCC_AHBPeriph_DMA1, ENABLE );                                                                          //使能DMA时钟
    
96. 
    
97.     DMA_DeInit( DMA1_Channel6 );                                                                                                                                                             //DMA1通道6对应 USART2_RX
    + ^+ ^, k/ p- ~" @7 N
98.     DMA_IniStructure.DMA_PeripheralBaseAddr = ( u32 )&USART2->DR;                                         //DMA外设usart基地址
    5 j" x( c: N8 J
99.     DMA_IniStructure.DMA_MemoryBaseAddr = ( u32 )dma_rec_buff;                                                  //DMA内存基地址
    
100.     DMA_IniStructure.DMA_DIR = DMA_DIR_PeripheralSRC;                                                                                         //数据传输方向，从外设读取发送到内存
     8 n' l% H1 P9 [' F! X! N
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;                                  //数据缓冲区以字节为单位搬入
       c9 x. ~" x' R$ H, E2 `4 l. @. {
106.     DMA_IniStructure.DMA_Mode = DMA_Mode_Normal;                                                                                                         //工作在正常缓存模式
     
107.     DMA_IniStructure.DMA_Priority = DMA_Priority_Medium;                                                                         //DMA通道 x拥有中优先级
       D- m% [4 v! h; [; b
108.     DMA_IniStructure.DMA_M2M = DMA_M2M_Disable;                                                                                                                 //DMA通道x没有设置为内存到内存传输
     
109. 
     - d$ G$ N: P  q, d2 a! _; [
110.     DMA_Init( DMA1_Channel6, &DMA_IniStructure );
     ; e* c0 F* o! d. c! j0 Y( g5 v
111.     DMA_Cmd( DMA1_Channel6, ENABLE );
     
112. }
     0 Y% y4 o/ d. y' A6 D9 N. q
113. 
     
114. //重新恢复DMA指针
     
115. void myDMA_Enable( DMA_Channel_TypeDef*DMA_CHx )
     
116. {
     # z/ P/ v4 m% H3 L/ @
117.     DMA_Cmd( DMA_CHx, DISABLE );                                                                                                                                                                   //关闭DMA1所指示的通道
     
118.     DMA_SetCurrDataCounter( DMA_CHx, DMA_REC_LEN );                                                                                                 //DMA通道的DMA缓存的大小
     ( U' @. l. v0 J# ~) Q. P+ \+ g$ U3 m
119.     DMA_Cmd( DMA_CHx, ENABLE );                                                                                                                                                                           //DMA1所指示的通道
     
120. }
     
121. //发送len个字节
     & X$ L" O$ P9 W6 C; y
122. //buf:发送区首地址
     
123. //len:发送的字节数
     
124. void uart2_Send( u8 *buf, u16 len )
     
125. {
     " t8 K& w4 A9 T/ ^. T' S
126.     u16 t;
     6 m6 G; n5 ]7 ?6 ~1 {/ O8 }
127.     for( t = 0; t < len; t++ )                                                                                                                                                                                 //循环发送数据
     
128.     {
     
129.         while( USART_GetFlagStatus( USART2, USART_FLAG_TC ) == RESET );
     : M' a, A9 J9 r7 p% Q5 s$ y  A
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 )
     0 {% n( X' Q1 I
137. {
     
138.     u16 t;
     % O+ l' E$ @) _! w4 c0 r
139.     dataLen_backup = len;                                                                                                                                                                                                         //保存数据长度
     * q3 F. f, j/ G8 ]# ^
140.     for( t = 0; t < len; t++ )
     
141.     {
     
142.         data_backup[t] = buf[t];                                                                                                                                                                         //备份接收到的数据，防止在处理数据过程中接收到新数据，将旧数据覆盖掉。
     
143.     }
     2 V8 E; u$ O2 ?$ \
144. }
     # t, F/ \; {; Y6 l, f! t9 J' n
145. // Modbus RTU 通信协议
     
146. //地址码 功能码 寄存器高位 寄存器低位  数据高位  数据低位 CRC高位 CRC低位
     
147. //01     03      00          00         03         e8      xx        xx
     7 @& T5 }2 N; B- J( F
148. //利用空闲中断接收串口不定长数据
     
149. //串口接收一组数据结束后才会进入中断,在数据发送过程中,已经接收到的数据将会被存入DMA的缓冲区中
     
150. void USART2_IRQHandler( void )
     
151. {
     
152.     u8 tem = 0;
     , a; r5 w. O" m! {: b
153. #if (UART2_DMA == 1)                        //如果使能了 UART2_DMA 则使用串口空闲中断和 DMA功能接收数据
     % D! l# A) a* b. a* k. `
154.         if( USART_GetITStatus( USART2, USART_IT_IDLE ) != RESET )                                                                                   //空闲中断  一帧数据发送完成
     * S6 H$ ?, \$ `) j+ {& t: ~
155.     {
     ! K, n( v7 y8 M9 x
156.         USART_ReceiveData( USART2 );                                                                                                                                                                                 //读取数据注意：这句必须要，否则不能够清除空闲中断标志位。
     6 M3 o/ [5 k2 V4 j
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 );                                                                                                 //清除空闲中断标志位
     ) Q, g$ z% i6 b9 N: {
163.         myDMA_Enable( DMA1_Channel6 );                                                                                                                                                                         //重新恢复 DMA等待下一次接收
     
164.     }
     
165. #else                                                                                //如果未使能 UART2_DMA 则通过常规方式接收数据  每接收到一个字节就会进入一次中断
     
166.     if( USART_GetITStatus( USART2, USART_IT_RXNE ) != RESET )                                                 //接收中断
     ' `1 z; V" }0 O% l* w
167.     {
     ( i3 r7 M% s) G7 }0 }- O' {1 m
168.         tem = USART_ReceiveData( USART2 );
     
169.         USART_SendData( USART2, tem );
     " P$ Q6 V/ ]) ?8 D
170.     }
     
171. #endif
     & k: I" J8 R) Y; O0 r- `+ h9 |6 ^
172. }

复制代码

modbus.h
" W( b+ w$ o4 |, g* o0 ?; h# v, N

1. #ifndef __MODBUS_H
   : {3 F- _# y! W- R. ^6 C
2. #define __MODBUS_H
   
3. #include "sys.h"
   
4. 
   
5. 
   
6. #define SlaveID  0x01     //从机地址
   
7. 
   + v0 k) [( d* t$ y9 O$ X. _# s
8. void DisposeReceive( void );
   % l4 ]: T& W9 ~3 v  `8 g
9. void Modbus_03_Slave(void);
   
10. void Modbus_06_Slave(void);
    . m( |1 @; x7 p% w/ _, S
11. void Modbus_16_Slave(void);
    5 Y& B- h" ^  y% ~
12. #endif

复制代码

) L) s% @% T4 B' @8 h, T  k; w5 D- Amodbus.c

1. #include "modbus.h"
   
2. #include "crc16.h"
   
3. #include "uart2.h"
   
4. 
   3 T' {8 ?* \' W7 E3 H% i# G
5. #define HoldRegStartAddr    0x0000                                                                                                                                                                                //保持寄存器起始地址
   , @  B4 y' K) u# T1 a9 h, @" _7 y
6. #define HoldRegCount        8                                                                                                                                                                                                        //保持寄存器数量
   
7. #define HoldMaxValue        1000                                                                                                                                                    //寄存器最大值
   
8. 
   
9. extern u8 data_backup[DMA_REC_LEN];                                                                                                                                                                   //modbus接收到数据备份
   
10. extern u16 dataLen_backup;                                                                                                                                                                                                                //modbus接收数据长度备份
    
11. 
    
12. 
    
13. u8 SendBuf[DMA_REC_LEN] = {0};
    
14. u16 StartRegAddr = HoldRegStartAddr;
    . j; \/ X3 [$ [6 J
15. u8 err = 0;                                                                                                        //错误代码
    # B# U" g4 P$ e9 `* h4 a) o
16. 
    * {8 O9 T( _) _! V
17. u8 HoldReg[HoldRegCount*2] = {1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8}; //存储8路数据值
    4 B( [: I( h" `
18. 
    9 v7 [2 Y) R( M0 X( h
19. 
    
20. /*
    5 D9 [! I4 E6 G8 g# F
21. 错误代码说明:
    5 h# s- H$ y+ n
22. 0x01  不是支持的功能码
    
23. 0x02  起始地址不在规定范围内
    
24. 0x03  寄存器数量不在规定范围内
    
25. 0x04  数据校验错误
    
26. */
    
27. //处理接收到的数据
    + B$ k4 f2 |! T, }4 o( M
28. // 接收: [地址][功能码][起始地址高][起始地址低][总寄存器数高][总寄存器数低][CRC低][CRC高]
    
29. void DisposeReceive( void )
    
30. {
    
31.     u16 CRC16 = 0, CRC16Temp = 0;
    
32.     if( data_backup[0] == SlaveID )                                                                         //地址等于本机地址 地址范围:1 - 32
    . d! }5 {+ f8 Z
33.     {
    " V% G5 t; D4 |
34.         CRC16 = App_Tab_Get_CRC16( data_backup, dataLen_backup - 2 );                                  //CRC校验 低字节在前 高字节在后 高字节为报文最后一个字节
    $ f# i, i( C" c
35.         CRC16Temp = ( ( u16 )( data_backup[dataLen_backup - 1] << 8 ) | data_backup[dataLen_backup - 2] );
    
36.         if( CRC16 != CRC16Temp )
    - Y" h' s0 `' r2 k
37.         {
    & T4 [+ a% X: H0 R; K" R- F7 r
38.             err = 4;                                                                                               //CRC校验错误
    ! g) A0 ?4 A; U/ I( d6 H* l
39.         }
    
40.         StartRegAddr = ( u16 )( data_backup[2] << 8 ) | data_backup[3];
    6 u# Z* B& c: T
41.         if( StartRegAddr > (HoldRegStartAddr + HoldRegCount - 1) )
    2 \! U4 G; _, L3 h0 Q% O$ z# A
42.         {
    
43.             err = 2;                                                                                               //起始地址不在规定范围内 00 - 07    1 - 8号通道
    
44.         }
    0 ]7 {. D3 {4 S9 Y2 J/ b+ A0 B! q
45.         if( err == 0 )
    
46.         {
    
47.             switch( data_backup[1] )                                                                        //功能码
    
48.             {
    0 u8 Y( a% I' X8 I9 z
49.                 case 3:                                                                                            //读多个寄存器
    
50.                 {
    6 @# B7 C8 D" J4 h; x! u5 ^
51.                     Modbus_03_Slave();
    
52.                     break;
    % N0 v/ \; @( H  J
53.                 }
    # W5 ~: c( F" F. X$ W- y& \, b8 H
54.                 case 6:                                                                                            //写单个寄存器
    
55.                 {
    
56.                     Modbus_06_Slave();
    
57.                     break;
    
58.                 }
    + w6 C4 }% F9 G0 C& P
59.                 case 16:                                                                                           //写多个寄存器
    , Q/ w  g( N; s- C
60.                 {
      ?+ b2 C! s% W! P
61.                     Modbus_16_Slave();
    ' r0 m$ [7 C, z  ^0 C1 a
62.                     break;
    
63.                 }
    3 W5 m8 B: S1 O' \* {
64.                 default:
    
65.                 {
    
66.                     err = 1;                                                                                       //不支持该功能码
    
67.                     break;
    ' T8 Z. O" b4 s1 @0 r
68.                 }
    
69.             }
    % Y1 X0 S% u: @  }
70.         }
    
71.         if( err > 0 )
    
72.         {
    
73.             SendBuf[0] = data_backup[0];
    ) ^5 E" _% S% s2 {9 Q: S
74.             SendBuf[1] = data_backup[1] | 0x80;
    
75.             SendBuf[2] = err;                                                                                      //发送错误代码
    
76.             CRC16Temp = App_Tab_Get_CRC16( SendBuf, 3 );                                                           //计算CRC校验值
      y0 ?* J2 S* |5 e/ o
77.             SendBuf[3] = CRC16Temp & 0xFF;                                                                         //CRC低位
    : O( o- a3 s: q' ]# j2 U% k
78.             SendBuf[4] = ( CRC16Temp >> 8 );                                                                       //CRC高位
    
79.             uart2_Send( SendBuf, 5 );                                       
    : P6 h8 }3 P$ Z- y% h
80.             err = 0;                                                                                               //发送完数据后清除错误标志
    
81.         }
    
82.     }
    
83. }
    
84. 
    2 c8 G6 J- G: U, t  m* E0 a; ?7 k
85. /*
    2 ~! z' R1 K! a8 V2 M$ M. Y
86. 函数功能：读保持寄存器  03
    % f. ?- x. n' v$ n' j
87. 主站请求报文:      0x01 0x03   0x0000  0x0001  0x840A     读从0开始的1个保持寄存器
    7 [- w- M# w! `$ Q" k2 s
88. 从站正常响应报文:  0x01 0x03   0x02    0x09C4  0xBF87     读到的2字节数据为 0x09C4
    
89. */
    ( R3 z2 e6 ^) w# i" d9 g; g
90. void Modbus_03_Slave( void )
    
91. {
    0 A/ m* O, V: f0 a  j
92.     u16 RegNum = 0;
    " F2 p; b) {: _- [
93.     u16 CRC16Temp = 0;
    ! }" [6 s4 x+ F5 z8 I0 V! G
94.     u8 i = 0;
    # I5 o  g8 K& c+ W( d
95.     RegNum = ( u16 )( data_backup[4] << 8 ) | data_backup[5];                                                //获取寄存器数量
    
96.     if( ( StartRegAddr + RegNum ) <= (HoldRegStartAddr + HoldRegCount) )      //寄存器地址+寄存器数量 在规定范围内 <=8
    
97.     {
    
98.         SendBuf[0] = data_backup[0];                                                                                                                                                                        //地址        
    
99.         SendBuf[1] = data_backup[1];                                                                                                                                                                        //功能码
    1 M' h! h$ L2 Q9 K6 H6 A( a
100.         SendBuf[2] = RegNum * 2;                                                                                                                                                                                        //返回字节数量
       h% T8 h9 `) [' o# H7 b8 W0 i
101.         for( i = 0; i < RegNum; i++ )                                                                             //循环读取保持寄存器内的值
     + n: ?! r3 q# S- K4 O- L4 |
102.         {
     
103.             SendBuf[3 + i * 2] = HoldReg[StartRegAddr * 2 + i * 2];
     . [* U" b( h$ P4 M7 D0 T  `0 B
104.             SendBuf[4 + i * 2] = HoldReg[StartRegAddr * 2 + i * 2 + 1];
     8 J; [3 [' @8 F
105.         }
     
106.         CRC16Temp = App_Tab_Get_CRC16( SendBuf, RegNum * 2 + 3 );                                                  //获取CRC校验值
     
107.         SendBuf[RegNum * 2 + 3] = CRC16Temp & 0xFF;                                                                //CRC低位
       m: i0 G8 A7 C- x+ F/ k. O/ K" H
108.         SendBuf[RegNum * 2 + 4] = ( CRC16Temp >> 8 );                                                              //CRC高位
     
109.         uart2_Send( SendBuf, RegNum * 2 + 5 );
     ) m: B- l9 M, N; X# s$ ~
110.     }
     
111.     else
     , \6 |- Q9 h8 X0 X& t! u1 g
112.     {
     . n: e- B( h# {/ }3 P% O; s" m2 y) B
113.         err = 3;                                                                                                   //寄存器数量不在规定范围内
     , ?! J7 P- {/ ^+ [2 g
114.     }
     
115. }
     
116. /*
     
117. 函数功能:写单个保持寄存器 06
     # b' a0 `1 p( \5 F* O# {. o! x
118. 主站请求报文:      0x01 0x06    0x0000  0x1388    0x849C   写0号寄存器的值为0x1388
     
119. 从站正常响应报文:  0x01 0x06    0x0000  0x1388    0x849C    0号寄存器的值为0x1388
     
120. */
     , n3 c6 G8 }' e& u- W1 d
121. void Modbus_06_Slave( void )
     * I* ]# ?0 q, ]: S+ j
122. {
     * }0 f( v4 {$ B/ w) B
123.     u16  RegValue = 0;
     
124.     u16 CRC16Temp = 0;
     
125.     RegValue = ( u16 )( data_backup[4] << 8 ) | data_backup[5];                                              //获取寄存器值
     9 d6 t( Z: q- l& l* ^
126.     if( RegValue <= HoldMaxValue )                                                  //寄存器值不超过1000
     
127.     {
     7 z8 l# d; P1 S2 A; {8 a4 m
128.         HoldReg[StartRegAddr * 2] = data_backup[4];                                                         //存储寄存器值
     8 }2 [5 ]( h/ \. H7 n! G9 ?
129.         HoldReg[StartRegAddr * 2 + 1] = data_backup[5];
     ( r2 u9 O' ]  g0 @8 ]6 }$ B: m
130.         SendBuf[0] = data_backup[0];                                                                                                                                                                        //地址
     
131.         SendBuf[1] = data_backup[1];                                                                                                                                                                        //功能码
     
132.         SendBuf[2] = data_backup[2];                                                                                                                                                                        //地址高位
     
133.         SendBuf[3] = data_backup[3];                                                                                                                                                                        //地址低位
     ' r# h+ n! h1 G6 `1 k
134.         SendBuf[4] = data_backup[4];                                                                                                                                                                        //值高位
     
135.         SendBuf[5] = data_backup[5];                                                                                                                                                                        //值低位
     
136.         CRC16Temp = App_Tab_Get_CRC16( SendBuf, 6 );                                                              //获取CRC校验值
     
137.         SendBuf[6] = CRC16Temp & 0xFF;                                                                            //CRC低位
     
138.         SendBuf[7] = ( CRC16Temp >> 8 );                                                                          //CRC高位
     
139.         uart2_Send( SendBuf, 8 );
     
140.     }
     
141.     else
     
142.     {
     ! \( X; I# L- i; m
143.         err =  3;                                                                                                  //寄存器数值不在规定范围内
     
144.     }
     ; q- K) }8 B* h3 c* \
145. }
     3 M. J$ E  z# j. B/ T7 k
146. /*
     
147. 函数功能:写多个连续保持寄存器值 16
     
148. 主站请求报文:       0x01 0x10    0x7540  0x0002  0x04  0x0000 0x2710    0xB731  写从0x7540地址开始的2个保持寄存器值 共4字节
     0 G4 {9 l7 ~+ H  x
149. 从站正常响应报文:   0x01 0x10    0x7540  0x0002  0x5A10                         写从0x7540地址开始的2个保持寄存器值
     6 p. P$ A- r( Q7 Q8 s1 S
150. */
     5 A5 j+ J- w2 {' d1 F
151. void Modbus_16_Slave( void )
     : ?- M2 x. O, T! h4 N4 X# A/ j
152. {
     
153.     u16 RegNum = 0;
     0 N5 y& R: [& Y- A0 h: _1 m
154.     u16 CRC16Temp = 0;
     / |$ ~- D6 `- f0 N
155.     u8 i = 0;
     ( g( m9 H( e, ?9 P5 ]
156.     RegNum = ( u16 )( data_backup[4] << 8 ) | data_backup[5];                                                //获取寄存器数量
     ! t$ ~1 |& N! ]0 V" ~# B
157.     if( ( StartRegAddr + RegNum ) <= (HoldRegStartAddr + HoldRegCount) )             //寄存器地址+寄存器数量 在规定范围内 <=8
     ) G  ^2 ^% q' r  C& q8 Z% V
158.     {
     3 q! ~. w( [* `% S4 v9 J
159.         for( i = 0; i < RegNum; i++ )                                                                              //存储寄存器设置值
     
160.         {
     / G: G* l8 }- g$ s" z; E$ @
161.             HoldReg[StartRegAddr * 2 + i * 2] = data_backup[i * 2 + 7];
     7 r" R: N+ u! N2 l& U! b
162.             HoldReg[StartRegAddr * 2 + 1 + i * 2] = data_backup[i * 2 + 8];
     4 y( B3 A0 f* B6 y; ^4 ^
163.         }
     % ^& t  g7 J' B9 a8 z
164.         SendBuf[0] = data_backup[0];                                                                                                                                                                        //起始地址
     
165.         SendBuf[1] = data_backup[1];                                                                                                                                                                        //功能码
     3 i  t# L0 a8 e; w
166.         SendBuf[2] = data_backup[2];                                                                                                                                                                        //地址高位
     2 V4 ?6 j. r7 l; g0 T
167.         SendBuf[3] = data_backup[3];                                                                                                                                                                        //地址低位
     . M' v( I5 u- s0 ?
168.         SendBuf[4] = data_backup[4];                                                                                                                                                                        //寄存器数量高位
     
169.         SendBuf[5] = data_backup[5];                                                                                                                                                                        //寄存器数量低位
     
170.         CRC16Temp = App_Tab_Get_CRC16( SendBuf, 6 );                                                        //获取CRC校验值
     
171.         SendBuf[6] = CRC16Temp & 0xFF;                                                                      //CRC低位
     ) `/ ~" z* d0 x; P- o; c
172.         SendBuf[7] = ( CRC16Temp >> 8 );                                                                    //CRC高位
     ) b+ Q; K! H% I1 N- ~0 {, |; u
173.         uart2_Send( SendBuf, 8 );
     
174.     }
     
175.     else
     
176.     {
     / D( W! \  |4 ?( x( G! z, t+ D; Z( Y
177.         err = 3;                                                                                                   //寄存器数量不在规定范围内
     
178.     }
     
179. }

复制代码

测试效果

测试功能码 0x03  读一个或者多个保持寄存器值

- w- E. W- t: P7 z. k# \( J! Q! Y

' I! B; Y8 g5 P& [$ y, H- b" G测试功能码 0x06 写单个保持寄存值

+ |6 {% }% N: g- z
3 |* B3 U" I- A
测试功能码 0x10 写多个保持寄存器值



再次读取所有寄存器值
8 W! J" w" j: G# A3 d9 y

( M4 d, v8 G" P3 T) K& Z" @
说明寄存器值修改成功。


; B8 t5 ?4 {% v4 F' M9 b- n3 S; P- Y