1、前言
5 A( L- E- U7 ^  D0 j7 S1 t   modbus rtu在嵌入式方面非常的常见和使用，嵌入式linux中可以使用libmodbus这个库，但是对于嵌入式单片机，开源的有FreeModbus这个库，但是只是从机，对于modbus rtu主机的实现，网上却找不到开源的库，或者找到了但是不方便移植，使用者想要去使用还要去搞明白是怎么实现的，本博客基于以上原因，实现了一套modbus rtu主机协议栈。
; X; A* e  G; l( x5 m) _3 B6 D
本主机协议栈优点如下：
接口明确清晰，使用者无需关心协议栈内部实现
面向对象编程思想，使用C语言的struct作为一个modbus rtu主机的控制接口，此方法的好处是可以灵活的实现多个主机，例如：实现一个多主机的modbus pdu。
7 Q5 @) W& i  U% ~/ O# G支持RTOS
; X) @6 I+ X3 b5 X. p. P: M可搭配FreeModbus协议栈无缝使用
移植简单、可很方便的移植到其他单片机如GD32、MM32等
源码简单、只有一个头文件、一个源文件、一个移植接口示例文件
4 P7 C5 j& B0 T2、协议栈API介绍
2.1 控制结构

1. typedef struct
   + ~: R# G9 U& ?4 ^
2. {
   ' l8 y* a7 R7 Z5 H( e9 ]
3.         //
   
4.         // 收发数据缓存
   
5.         //
   3 ~6 H+ s/ j% C0 Q7 ?2 s1 D, N7 X& q) }
6.         uint8_t ucBuf[128];
   5 p' u/ Z2 r$ ~) p% p/ ]
7.         
   
8.         //
   1 A( u* u9 u0 M. H1 f% ~
9.         // 收发数据状态
   
10.         //
    
11.         uint16_t usStatus;
    
12.         
    
13.         //
    # l3 W6 P7 X8 A/ {  M1 e
14.         // 如果使用了RTOS需要进行互斥,那么需要实现以下两个函数的绑定
    
15.         //
    2 o* {; P6 g7 N; w2 Q& I* O& u/ A
16.         void (*lock)(void);
    
17.         void (*unlock)(void);
    $ Q" C: w* t4 y7 U
18.         
    
19.         //
    . `  T  k0 w8 L2 W& b/ ^4 l
20.         // 微秒延时函数,用于等待超时
    ! \7 V5 D6 ~4 W9 A8 {* Y, J, Y
21.         //
    
22.         void (*delayms)(uint32_t nms);
    + l4 w5 e! J! U  r7 w, H- x' q
23.         
    
24.         //
    ; U* s0 k* ?- ?( R
25.         // 定时器启动和停止函数
    % L* ]- X( x! X6 D4 w- O) R
26.         //
    
27.         void (*timerStop)(void);
    
28.         void (*timerStart)(void);
    / F! E- j6 }5 g# T5 ~, v
29.         
    . a0 N; M* F% t( b+ y. d- K
30.         //
    
31.         // 发送数据函数,可以是串口、TCP等
    
32.         //
    
33.         uint32_t (*sendData)(const void* buf, uint32_t len);
    
34. 
    
35. }MBRTUMaterTypeDef;

复制代码

* u+ R- D5 d- F! q* q2.2 主机读线圈状态（CMD1）
  I/ U0 ~" z: k( U

1. /**
   
2. * 主机读取线圈状态
   
3. * @param  ucSlaveAddress 从机地址
     P2 z* ~( n5 u; V
4. * @param  usAddress      要读取的线圈起始地址
   # R+ \% b5 R2 q# n- @7 k( U
5. * @param  usNum          要读取的线圈数量
   % v1 a8 C; n' {* x& U# Z
6. * @param  usTimeout      超时时间,单位毫秒
   
7. * @param  pucCoilsBuffer 存储读取到的线圈状态，一个字节代表一个线圈状态，值范围：0/1
   
8. * @return                0:成功  <0:执行失败
   
9. */
   . w3 @) M7 R$ Z* n7 w8 R0 Y
10. int MBRTUMasterReadCoils(MBRTUMaterTypeDef* psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint16_t usNum, uint16_t usTimeout, uint8_t* pucCoilsBuffer)

复制代码

6 k) n7 z) D: Q2.2 主机读离散量输入（CMD2）

1. /**
   
2. * 主机读取离散量输入
   
3. * @param  ucSlaveAddress 从机地址
   6 f: a6 D, a7 p8 L9 ^6 i
4. * @param  usAddress      要读取的离散量起始地址
   " s3 j( m. _  V. `! w
5. * @param  usNum          要读取的离散量数量
   ) j& X3 h+ h5 i4 v9 X
6. * @param  usTimeout      超时时间,单位毫秒
   # l5 ]% a/ @! x6 \1 T' h
7. * @param  pucDiscBuffer  存储读取到的离散量输入状态，一个字节代表一个离散量的状态，值范围：0/1
   , e; `# t% h+ z, w$ {4 N
8. * @return                0:成功  <0:执行失败
   5 Y$ h0 U" Y0 @0 P3 V
9. */
   
10. int MBRTUMasterReadDiscreteInputs(MBRTUMaterTypeDef* psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint16_t usNum, uint16_t usTimeout, uint8_t* pucDiscBuffer)

复制代码

) [7 [+ {6 }7 N  n$ J: ?' z; g1 r2.2 主机读保持寄存器（CMD3）
; |$ x* B5 i4 r! L* P

1. /**
   4 A6 U# y3 ]$ F% g; ~8 X, B- V  Q" A: c
2. * 主机读取保持寄存器
   
3. * @param  ucSlaveAddress 从机地址
   
4. * @param  usAddress      要读取的保持寄存器起始地址
   4 [9 X" L& Z- |; X
5. * @param  usNum          要读取的保持寄存器数量
   
6. * @param  usTimeout      超时时间,单位毫秒
   
7. * @param  pusRegBuffer   存储读取到的寄存器值
   & l) `0 u! a9 g* [; j1 @9 s0 V
8. * @return                0:成功  <0:执行失败
   
9. */
   6 X# j  H3 o/ ]6 R  V
10. int MBRTUMasterReadHoldingRegisters(MBRTUMaterTypeDef* psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint16_t usNum, uint16_t usTimeout, uint16_t* pusRegBuffer)

复制代码

2.2 主机读输入寄存器（CMD4）

1. /**
   
2. * 主机读取输入寄存器
   
3. * @param  ucSlaveAddress 从机地址
   $ X# F, q) t; R2 S; [! A
4. * @param  usAddress      要读取的输入寄存器起始地址
   $ W. p! \9 X) m; [, I5 Y* R5 @
5. * @param  usNum          要读取的输入寄存器数量
   % v/ D7 V" U$ N0 {5 Z8 M& _9 w4 D
6. * @param  usTimeout      超时时间,单位毫秒
   7 o2 i6 E) J  f; ~* z
7. * @param  pusRegBuffer   存储读取到的寄存器值
   
8. * @return                0:成功  <0:执行失败
   
9. */
   7 D6 S5 _1 a4 U$ l
10. int MBRTUMasterReadInputRegisters(MBRTUMaterTypeDef* psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint16_t usNum, uint16_t usTimeout, uint16_t* pusRegBuffer)

复制代码

2.2 主机写单个线圈（CMD5）
0 k  q  I  U2 W0 J. {; Z- D2 I6 \7 z


1 J  `( f# f2 w" o/ U) {' W6 m2.2 主机写单个寄存器（CMD6）

1 o# S4 S$ ~& X5 v) G) G
( x  ]8 N* j' L: O( x. b
2.2 主机写多个线圈（CMD15）
$ A% O! u, U$ t8 v% m0 O; G, R. d" G
' f: r& X0 P; p/ V& V5 |0 I
) x$ g3 W2 T' O  K. p
- a: E2 Y8 b! O2 c$ H1 H+ P2.2 主机写多个寄存器（CMD16）
7 p- T+ U- V, H
7 v2 j8 ?% v+ d. N: C
# U- G  {; L/ a, b. u  }
* h) v- P: Q- `& ]- J# ~3、移植前的基础工程生成
基础工程这里我使用STM32CubeMX生成，使用的是STM32F103C8单片机，配置步骤如下，首先将时钟配置到72M：

4 P- E5 [0 [% a0 O! L
. Y7 d2 s/ V1 s
配置串口1用于调试打印，配置串口3用于modbus主机通信：
5 P: U/ T2 y9 d. y6 t
4 A- ?3 o% b. y
/ ~) v: t8 Y, U) A2 h! s+ `

$ g; n5 u* p3 B& d0 E
4 `. S& ~% {  Q, o/ m配置用于检测3.5个字符超时时间的定时器，我配置成了5ms超时。

这里需要跟你实际使用的波特率进行超时时间的计算，以：波特率9600、8bit数据位、1bit停止位，奇校验、无流控为例，那么1s内就可以传输9600bits÷(8+1+1)=960bytes，那么3.5个字节的时间就是1000ms÷960×3.5≈3.65ms，所以，我设置5ms的超时时间是没有问题的。
0 w5 f& t# s# m3 J
. W. A: N  c0 }

开启定时器和串口中断，注意：串口的中断要比定时器中断等级高：



最后输出工程就可以了：

$ I: i4 e& _; i4 C: O1 D, g



" X6 N- ?9 z# v
: z2 I6 F: K! \  A5 p8 t* g4、移植主机协议栈
主机协议栈源码就只有三个文件：


, z9 M% z/ B0 |2 N4 T
其中，mbrtu_master.h和mbrtu_master.c是协议栈实现，无需动，mbrtu_master_example.c是移植参考示例。
) A6 V& M7 B& U- o
下面讲解一下移植过程。

首先定义一个modbus主机的全局控制结构并初始化：
0 }" G* E' ]# p# B( f1 w
& a+ N5 x, f3 O: k+ C7 ^

1. MBRTUMaterTypeDef MBRTUHandle =
   & C4 L( ?" d. U) A, u- [% X. X
2. {
   3 v# e7 H: B4 }* f. [  w( g3 H
3.     .delayms                      = delayms,
   
4.     .timerStart                   = timerStart,
   ) Z! r% q3 F* l& x5 Q/ S4 S1 F
5.     .timerStop                    = timerStop,
   ; e2 V/ l' x1 H; k! A, n" g
6.     .sendData                     = sendData,
   9 M4 T/ P, Y5 c$ U
7. 
   
8. #ifdef USE_RTOS  // 使用了RTOS那么需要实现互斥
   
9.     .lock                         = mutex_lock,
   + u4 }2 {* i; j' R9 B% \$ ^- ?! y
10.     .unlock                       = mutex_unlock,
    ) X# j! E+ q! c2 g0 B0 w. e; q) B$ y
11. #endif
    
12. };

复制代码

注意：如果使用了实时系统，需要实现lock和unlock函数。

3 u8 @- W- y' [1 F2 E: f) X1 J0 G结构体中的函数实现如下：

8 O$ C& T8 E6 q/ Y3 z+ }/ Q1 L

1. #ifdef USE_RTOS
   % F- y3 Y( Z& i- P
2. 
   ! ^6 v" R6 G" u
3. static void mutex_lock(void)
   
4. {
   
5. 
   ; s- u3 h8 R# g
6. }
   5 R) ^- I' j; {& ^8 G* A
7. 
   
8. static void mutex_unlock(void)
   
9. {
   * f& h. G/ m5 x- j  |" A* E+ ~
10. 
    . V. a# v7 F) ^& M4 S7 o4 E% O" R% b
11. }
    - q# B1 G6 A6 b' b$ o
12. 
    
13. #endif
    3 [# D3 o7 U9 G( y
14. 
    
15. static void timerStop(void)
    4 g9 K4 J5 k( m% W& I# r, O
16. {
    
17.     HAL_TIM_Base_Stop_IT(&htim3);
    9 l: Q! B0 Y& c8 }
18. }
    
19. 
    * v' [9 q- x+ Q) j/ w
20. static void timerStart(void)
    
21. {
    0 a9 B  I1 Z! S; b
22.     __HAL_TIM_SET_COUNTER(&htim3, 0);
    1 w& _+ Y, r+ }# ~& K, y3 K* |  m
23.     HAL_TIM_Base_Start_IT(&htim3);
    
24. }
    
25. 
    ; g5 `" `5 I$ k4 D
26. static void delayms(uint32_t nms)
    - v; m: r- P& W- j4 T1 p
27. {
    
28. #ifdef USE_RTOS
    
29.         osDelay(nms);
    
30. #else
    
31.     HAL_Delay(nms);
    9 v5 p  D. B/ \3 Z
32. #endif
    
33. }
    7 ^. k1 w9 f2 c
34. 
    " i5 d' P! P4 Y2 O8 k# H
35. static uint32_t sendData(const void* buf, uint32_t len)
    * v3 u# G, C$ I% |- M5 M: M/ x
36. {
    
37.     if(HAL_UART_Transmit(&huart3, (uint8_t *)buf, len, 100) != HAL_OK)
    
38.     {
    / t* Y- f" D7 }6 g5 B
39.         len = 0;
    4 }" g. `$ R5 _  t
40.     }
    " t; f* p2 r0 E  D4 x5 Q
41.     return len;
    
42. }

复制代码

将MBRTUMasterTimerISRCallback函数放置于定时器中断函数中，对于HAL库那就是这样的：

( a6 q3 H3 P5 u) P$ o

1. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
   ) E; ^5 N; a1 y4 a
2. {
   
3.     if(htim->Instance == htim3.Instance)
   % M4 Z. ?1 K; |% _# p/ M! N' L
4.     {
   
5.         MBRTUMasterTimerISRCallback(&MBRTUHandle);
   . g1 J, H4 }: r* K% _
6.     }
   
7. }

复制代码

2 J( a0 \- s2 w& ?2 x# A将MBRTUMasterRecvByteISRCallback函数放置于串口中断函数中，对于HAL库那就是这样的：
* A$ F9 O. |% T4 s' N
" T9 \7 v9 [5 I3 d$ N

1. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
   
2. {
   - k6 m3 O5 ?: O$ O# q
3.     if(huart->Instance == huart3.Instance)
   3 O6 p1 r& I- @  h
4.     {
   ; T3 W9 Q$ I& i4 A) _
5.         MBRTUMasterRecvByteISRCallback(&MBRTUHandle, g_Uart3RxByte);
   $ O3 h) e& ?, y' V
6.         HAL_UART_Receive_IT(&huart3, &g_Uart3RxByte, 1);  // 注册接收
   
7.     }
   : @6 j* g6 S/ A7 U7 S: y
8. }

复制代码

重定向printf到串口1：

4 H" m2 C( K% j

1. int fputc(int ch, FILE* fp)
   
2. {
   
3.     HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 100);
   $ ]4 @2 e" z! q* |* s0 \' {; V+ j
4.     return ch;
   
5. }

复制代码

2 v- v. C5 U* o9 g. M# J至此，就移植完毕了，测试函数如下：

1. int ret;
   
2. uint8_t ucBuf[10];
   8 M+ j) P$ L$ B+ J) s
3. uint16_t usBuf[10];
   ' h4 g" Y, Z. [# }0 t
4. 
   : g5 [& q) A2 P1 e
5. int main_example(void)
   
6. {
   ) t" W- _! m% j0 H. {& o& `
7.     // 定时器初始化,设置为3.5个字符的超时时间
   
8.     // Timer_Init();
   
9. 
   
10.     // 串口初始化,初始化波特率等
    
11.     // UART_Init();
    ; ~! C! R4 _! Q
12. 
    
13.     // 写单个线圈
    
14.     ret = MBRTUMasterWriteSingleCoil(&MBRTUHandle, 1, 0, 1, 500);
    ( r# u8 t. X1 [0 e/ h5 N  O
15.     printf(" write single coil %s. \r\n", ret < 0 ? "failed" : "ok");
    7 F+ q# E& E. k, e
16.     HAL_Delay(100);
    
17. 
    ! K. X( C* m' Y9 d4 @6 M
18.     // 写单个寄存器
    6 K2 H4 _, V, B
19.     ret = MBRTUMasterWriteSingleRegister(&MBRTUHandle, 1, 0, 0XAABB, 500);
    # y$ [1 F! p4 D
20.     printf(" write single reg %s. \r\n", ret < 0 ? "failed" : "ok");
    
21.     HAL_Delay(100);
    
22. 
    
23.     // 写多个线圈
    2 q; Y  z, y! y5 w5 x9 Y3 m
24.     memset(ucBuf, 0X01, 10);
    
25.     ret = MBRTUMasterWriteMultipleCoils(&MBRTUHandle, 1, 0, 10, ucBuf, 500);
    * A! a+ u7 B2 `9 o' Q4 _
26.     printf(" write coils %s. \r\n", ret < 0 ? "failed" : "ok");
    
27.     HAL_Delay(100);
    
28. 
    
29.     // 写多个寄存器
    2 U& N' `! C; X$ n9 s3 W$ M
30.     memset(usBuf, 0XFF, 20);
    
31.     ret = MBRTUMasterWriteMultipleRegisters(&MBRTUHandle, 1, 0, 10, usBuf, 500);
    
32.     printf(" write regs %s. \r\n", ret < 0 ? "failed" : "ok");
      U& t$ @. j/ X. J2 j/ B" V0 O
33.     HAL_Delay(100);
    
34. 
    
35.     // 读线圈
    
36.     MBRTUMasterReadCoils(&MBRTUHandle, 1, 0, 10, 500, ucBuf);
    1 z, D3 G3 Y! X; F+ P8 \3 J1 b' i
37.     printf(" read coils %s. \r\n", ret < 0 ? "failed" : "ok");
    
38.     HAL_Delay(100);
      H& J6 t1 ^4 g& r5 b
39. 
    " }. W$ }5 }. C9 |
40.     // 读离散量输入
    
41.     MBRTUMasterReadDiscreteInputs(&MBRTUHandle, 1, 0, 10, 500, ucBuf);
    9 ^( q1 v6 M: w) r/ Y
42.     printf(" read discs %s. \r\n", ret < 0 ? "failed" : "ok");
    ! E' h- x5 ~  w# z5 q; e$ I, ~
43.     HAL_Delay(100);
    # w# U4 g" e" K  T2 }9 E% e
44. 
    
45.     // 读保持寄存器
    
46.     MBRTUMasterReadHoldingRegisters(&MBRTUHandle, 1, 0, 10, 500, usBuf);
    % G6 t- O3 F7 _' r! E! q: n
47.     printf(" read hold regs %s. \r\n", ret < 0 ? "failed" : "ok");
    
48.     HAL_Delay(100);
    + R! q9 `. c4 W  A9 j- k
49. 
    
50.     // 读输入寄存器
    
51.     MBRTUMasterReadInputRegisters(&MBRTUHandle, 1, 0, 10, 500, usBuf);
    
52.     printf(" read input regs %s. \r\n", ret < 0 ? "failed" : "ok");
    / T* b% Q$ E, b- U/ B
53.     HAL_Delay(100);
    8 g0 C& b8 V6 N
54. 
    5 {- n1 p4 K$ d# B
55.     return 0;
    5 F* v" F  a/ o0 R- G
56. }

复制代码

4 x0 ^5 \) `  b3 J* n) k5、移植测试验证
移植完毕了现在需要测试，测试你可以使用MobusSlave软件模拟测试，也可以选用选用FreeModbus作为从机
. R+ M  R1 A( t
/ n  s5 n) y& O4 W2 ?! W' U% ^————————————————
1 q8 D9 H- y' _' q3 X版权转载自：雍正不秃头
: }* f' U" _- j5 j5 Z! D& o: N
5 I9 e% C$ ]7 {# S9 g% @
, v8 y1 y7 d6 \/ t. V: W
. G/ ]( q. v# F