测试板卡： 正点原子MINISTM32（STM32F103RB）

实现思路： 位机向STM32发送连续数据，STM32串口中断一直接收，期间使用定时器控制接收时间，如果在3.5个时间字符时间内没有接收到任何数据，那么定时器就判定为一帧数据接收完毕，然后根据modbus协议处理接收到的数据就可以了。

MODBUS RTU 方式的收发都需要3.5个字符的等待时间，这个时间可以通过定时器控制，两个字符之间的间隔时间按照9600的波特率算，1s可以发9600/8=1200字节，1个字节发送的时间就是1/1200≈833微秒，3.5个字符时间就是1/1200*3.5≈2917微秒，这里我为了方便直接用了5ms，如果你测试不行的话，调小定时器的超时时间。


$ M, b( V5 P' |0 n; y# x/ {贴一下modbus的命令码表：
- Y' u$ M! G9 u

6 y) e4 j7 Q4 ?! V# M
贴一下主要的代码片段：串口接收中断回调函数：

串口1为调试串口
! ^" j6 a* m; O& k串口3作为modbus的收发数据端口

1. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
     n1 r  k' |/ i: M5 U0 a
2. {
   
3.     if (huart->Instance == DEBUG_UART_HANDLER.Instance)
   
4.     {
   1 A# `6 ^. \4 m% f- L
5.         if ((DEBUG_UART_RX_STA & 0x8000) == 0)                                                  // 接收未完毕
   
6.         {
   
7.             if (DEBUG_UART_RX_STA & 0x4000)                                                     // 已经接收到了回车符
   4 Y$ `. _8 N, o
8.             {
   
9.                 if (DEBUG_UART_RX_BYTE == '\n')     DEBUG_UART_RX_STA |= 0x8000;                // 本次接收到的是换行符，标记接收到了换行符
   
10.                 else                                DEBUG_UART_RX_STA = 0;                      // 本次接收到的不是换行符，视为接收错误，状态置为初始
    
11.             }
    ! k# r& P4 a5 ]. g4 X) z
12.             else
    
13.             {
    2 s6 P% m' L- e
14.                 if (DEBUG_UART_RX_BYTE == '\r')     DEBUG_UART_RX_STA |= 0x4000;                // 本次接收到的是回车符，标记接收到了回车符
    
15.                 else
    & f3 z  ?# ~: X& W1 i" s: Z- I7 r
16.                 {
    
17.                     DEBUG_UART_RX_BUF[DEBUG_UART_RX_STA & 0x3FFF] = DEBUG_UART_RX_BYTE;         // 将本次接收到的数据保存到接收缓存中
    
18.                     if (DEBUG_UART_RX_STA++ >= DEBUG_UART_RX_LEN)   DEBUG_UART_RX_STA = 0;      // 连续接收到的数据长度高于最大接收长度，则视为接收错误
    
19.                 }
    
20.             }
    
21.         }
    
22.         HAL_UART_Receive_IT(huart, &DEBUG_UART_RX_BYTE, 1);                                     // 再次使能接收中断
    + V* `+ T+ M. \$ d* Z) I/ l
23.     }
    4 ?4 l2 e3 j0 P* h
24.     else if (huart->Instance == huart3.Instance)
    8 V2 y( V& N; M, s8 v; E
25.     {
    
26.         if (MODBUS_RX_STA < MODBUS_RX_LEN)
    
27.         {
    $ k: U# I$ R" h* E& [$ j
28.             __HAL_TIM_SET_COUNTER(&htim4, 0);                                                                // 清除5ms定时器的计数值
    9 l9 K8 S, u8 T- E7 |
29.             if (MODBUS_RX_STA == 0)   TIM4_Set(TIM4_ENABLE);                                // 如果接收为初始状态，则启动定时器
    
30.             MODBUS_RX_BUF[MODBUS_RX_STA++] = MODBUS_RX_BYTE;                                // 接收数据
    
31.         }
    ( N  @: }2 i0 r' U" f
32.         else
    8 v5 @- j- u& g# b  i2 F3 }% f
33.         {
    
34.             MODBUS_RX_STA |= 0x8000;                                                                                // 超长，标记接收结束
    $ _& G$ M- R1 ^, F
35.         }
    - ~3 Z% p/ h; V. X1 |. U
36.         HAL_UART_Receive_IT(huart, &MODBUS_RX_BYTE, 1);                                                // 再次使能接收中断
    " `2 F7 V. K! g! p, ^& e1 _' G1 o
37.     }
    
38. }
    
39. 
    

复制代码

MODBUS RTU数据解析，我只实现了功能码3，其他功能码请根据协议自行进行补充：
0 p, U+ Y5 u8 ?- A6 n0 E% p

1. 
   
2. 
   
3. // 保持寄存器
   . N. p* `1 `8 l
4. #define REG_HOLD_SIZE        10UL
   
5. uint16_t REG_HOLD[REG_HOLD_SIZE] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
   & [4 t7 B# A9 `! i  L
6. 
   
7. // 互换两个变量的值
   
8. void swap(unsigned char* byte1, unsigned char* byte2)
   
9. {
   
10.     *byte1 ^= *byte2;
    / u. l( A( x' R+ }8 G5 g
11.     *byte2 ^= *byte1;
    3 M/ W- J' H# u* l- F* U4 u
12.     *byte1 ^= *byte2;
    
13. }
    * i4 N2 B' Y# I: x! E
14. 
    4 I  I2 A) R9 z' {: Y
15. inline void modbus_slave_write(const void* buf, uint32_t len)
    
16. {
    
17.     HAL_UART_Transmit(&huart3, (uint8_t *)buf, len, 1000);
    
18. }
    3 j9 x9 T, k4 g3 b$ M/ h
19. 
    
20. /**
    / P' G1 K% E. S4 n* e
21. * 串口三数据接收处理
    
22. */
    
23. void MODBUS_RecvHandler(void)
    
24. {
    
25.     // 无数据收到
    
26.     if ((MODBUS_RX_STA & 0x8000) == 0)
    
27.         return;
    % h9 t. t7 C- b
28. 
    1 X7 U# C+ V0 L- w4 |
29.     // 收到的数据有误
    
30.     if (MODBUS_RX_BUF[0] != SLAVE_ADDRESS)
    
31.         goto __exit;
    
32. 
    
33.     // 选择相应功能码
    9 C7 S/ R7 p1 t3 K' _9 O
34.     switch (MODBUS_RX_BUF[1])
    
35.     {
    7 J8 ]& r( b9 d$ ]% D
36.     case CMD3:
    
37.     {
    
38.         int i      = 0;
    
39.         int nread  = 0;
    
40.         int offset = 0;
    
41.         int num    = 0;
    
42. 
    9 j, p" J' a4 ^, Q# N: d
43.         // CRC校验
    
44.         if (usMBCRC16(MODBUS_RX_BUF, 6) != *((uint16_t *)(MODBUS_RX_BUF + 6)))
    
45.             goto __exit;
    
46. 
    + `1 E9 ^" f+ w) a( r1 [4 Z
47.         // 大端转小端
    
48.         swap(MODBUS_RX_BUF + 2, MODBUS_RX_BUF + 3);
    
49.         swap(MODBUS_RX_BUF + 4, MODBUS_RX_BUF + 5);
    
50. 
    * q1 A% J. k: Y6 u6 ?) |' X3 t/ \  P
51.         // 得到保持寄存器偏移地址
    
52.         offset = *((uint16_t *)(MODBUS_RX_BUF + 2));
    . ]% k/ M( F6 I  |7 F- ^% e: N
53. 
    # k- t2 @6 Z% J$ o
54.         // 偏移地址错误
    9 [6 C+ f$ R' {
55.         if (offset >= REG_HOLD_SIZE)        goto __exit;
    
56. 
    0 T$ P7 ?) ]6 t: R9 t3 t
57.         // 得到要读取的保持寄存器个数
    5 o8 @) T$ I0 K$ w/ A2 S% P% |
58.         num = *((uint16_t *)(MODBUS_RX_BUF + 4));
    # B6 V$ C8 q8 N7 s4 L2 f
59. 
    
60.         // 计算实际可读的保持寄存器个数
    - A( D8 l* c( c' I6 Y# N* C
61.         nread = REG_HOLD_SIZE - offset >= num ? num : REG_HOLD_SIZE - offset;
    , ]( D, {# e. C
62. 
    # T# N; W+ k  z+ c2 {) W
63.         // 实际能够被读取的保持寄存器数量错误
    ! P3 |3 T2 V# E) g; o% @' t
64.         if (nread <= 0)        goto __exit;
    . @  M, ?) z* _3 [/ N
65. 
    
66.         // 填充响应数据的字节长度
    ' C3 _* }7 s! A; f* o! }
67.         MODBUS_RX_BUF[2] = nread * sizeof(uint16_t);
    ' g3 y; F2 _1 e) i9 y0 h
68. 
    
69.         // 填充保持寄存器的值
    ' q: f# z9 j( r0 [: n' z
70.         for (i = 0; i != nread; i++)
    % E' ^+ b3 ~7 Y5 v# N! f# h8 T8 V
71.         {
    
72.             *((uint16_t *)(MODBUS_RX_BUF + 3 + i * 2)) = swap_uint16(REG_HOLD[offset + i]);
    
73.         }
    " O& z6 R0 [! a6 k: l
74. 
    ) s0 H8 a* @1 Y
75.         // 计算CRC
    % p3 c! E0 `. `( d
76.         *((uint16_t *)(MODBUS_RX_BUF + 3 + nread * 2)) = usMBCRC16(MODBUS_RX_BUF, 3 + nread * 2);
    * T# v" \3 V4 v1 [
77. 
    
78.         // 发送给主机
    
79.         modbus_slave_write(MODBUS_RX_BUF, 3 + nread * 2 + 2);
    
80. 
    
81.         // 等待3.5个字符的时间
    * h9 l0 d2 q5 [7 u! n
82.         HAL_Delay(5);
    
83. 
    
84.         // 改变保持寄存器的值
    
85.         for (i = 0; i != REG_HOLD_SIZE; i++)
    9 D# }9 ?7 l0 f2 q* E& K
86.         {
    
87.             REG_HOLD<i>++;
    * W8 ?3 A  U, d. r/ e
88.         }
    
89. 
    
90.         // 退出
    , U; `5 y4 R; G
91.         goto __exit;
    / ?- F- \4 S; @4 G4 s# G% c- y
92.     }
    4 d5 ?, V% }# ]6 I/ j! C5 J
93.     default:
    , M: ~5 C, i: C& [& X( f
94.         goto __exit;
    
95.     }
    * `% A* L* w& d( [
96. 
    4 b/ `" j) @, u) u
97. __exit:
    
98.     MODBUS_RX_STA = 0;                // 清空接收
    
99.     return;
    
100. }
     
101. </i>

复制代码

在主函数中轮训调用modbus的接收处理函数：
& n* h+ R4 J- f& ~& C( h8 F; h


单片机串口3我设置为9600的波特率，无流控、无奇偶校验、8bit数据、1bit停止位，上位机打开modbus poll软件，串口设置与单片机相同，Steup->Read/Write Definition，然后从机地址为1，功能码为3，偏移地址0，读取10个保持寄存器的值：
1 [2 g9 M5 F9 k  o  L  A

% T  _9 ^  V" B- D- K+ B0 [5 s
8 i9 \% b; ^5 V4 m: V) H然后收到单片机的modbus rtu的回复：
/ r* i; ~) z$ K8 Z
9 R: o/ o$ F- [, w: T! h9 |
' o. {% v# N( z6 ]; r: y& W. h' x
ends。。。
! C# B# I9 g. X( S" h. c/ ~
" U3 T2 H  Z1 O  J( C
( n8 d: c. ?5 z( T9 K