modbus命令码表：
6 T5 Y7 F2 \  s: r: x; i

5 b7 o* t* B6 B4 ~# q' h
0 A! E$ C; `. }- z1 P4 ~# ^8 H- LFreeModbus文件说明
      解压freemodbus文件后打开，我们需要demo目录下的BARE，该目录下的代码是空的，STM32移植工作基本就是修改：portserial.c、porttimer.c、port.h这三个文件。


      mobus文件夹就是完整的源码，包含rtu、ascii、tcp：
2 x9 R* C0 M4 j$ `
# \+ f8 y0 k6 F7 I4 D, W

      我为了移植时在keil添加源文件和头文件方便，就把modbus所有的头文件和源文件放到了一个文件夹下，并创建了一个port.c文件，用于编写modbus所必需的回调处理函数：

$ O6 |# O' ?- n$ M  U) a& G

4 {# Q$ Z: B8 X: y" ~, z% I, MSTM32CUBEMX配置
6 s$ v5 g- ?9 E& A# o+ e( X1 f时钟配置，设置主频工作在72MHz下：



配置串口1，这里随便配置就行，在modbus移植过程中还会对串口重新初始化：

2 z: s5 m' U6 |) ]4 g" b; C+ I3 O
/ U; L3 S# w7 @) N! M& c0 i
配置定时器4，用于3.5个字符的定时检测，这里随便配置就行，在modbus移植过程中还会对定时器重新初始化：

6 f& H% ?, @6 Y; D% H6 V* O+ R2 x+ P

中断配置，这里注意，串口的优先级是要比定时器优先高的：

" N8 o3 p  T# H8 S/ s. T/ Q0 y
& Q9 S( Z2 A% q* {取消掉自动生成中断服务程序，在移植过程中我们要自己编写串口和定时器的中断服务程序：
1 p: w" c$ ]* r' R+ I( r  b
, H/ A% o' L# a5 r; j5 ~

8 V' o% b* a' e2 b+ R0 ^移植代码修改
" p% [9 |& h2 W0 W! {生成代码后将modbus放到工程目录下：

4 i+ K  B/ v$ r+ b8 K- C
/ B, o( w, U  R, J  x/ S
* Y. a3 \4 d/ J9 s( \" g打开keil工程添加modbus源码：



添加包含头文件：
# F0 k! ~/ b0 ?- e8 g3 p9 W: w


修改modbus定时器初始化源代码porttimer.c文件
       定时器的修改比较容易，将定时器设置为每50us的时长记一个数，传入的usTim1Timerout50us变量给自动装载即可，prvvTIMERExpiredISR函数需要在定时器中断服务函数中调用，它的作用是用于通知modbus协议栈3.5个字符的等待时间已经到达；由于我们在STM32CUBEMX中取消掉了定时器和串口的中断服务函数程序，所以我们在该文件中添加定时器的中断服务程序，修改后的代码如下：

% b* E$ p) I, b4 g8 U+ [  E

1. BOOL
   ) s& s; C0 V: ^" e* V+ p8 h( m- C
2. xMBPortTimersInit( USHORT usTim1Timerout50us )
   $ ^3 H) Q6 p( @" @+ S8 S
3. {
   
4.     TIM_ClockConfigTypeDef sClockSourceConfig = {0};
   
5.     TIM_MasterConfigTypeDef sMasterConfig = {0};
   
6. 
   ! r3 [! u, R$ n8 ^
7.     htim4.Instance = TIM4;
   6 e  ~% N: S9 h' o
8.     htim4.Init.Prescaler = 3599;                                                                // 50us记一次数
   0 F: g6 S# J- T6 y5 t, l! l: e
9.     htim4.Init.CounterMode = TIM_COUNTERMODE_UP;
   $ Q, o$ w6 H# ?! n9 c3 s
10.     htim4.Init.Period = usTim1Timerout50us - 1;                                        // usTim1Timerout50us * 50即为定时器溢出时间
    
11.     htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    1 B/ Y  K3 H5 w  L
12.     htim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
    9 B" N' w; ^) b, _
13.     if (HAL_TIM_Base_Init(&htim4) != HAL_OK)
    
14.     {
    
15.         return FALSE;
    
16.     }
    ( [- f. I8 c0 P2 |) C
17.     sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
    
18.     if (HAL_TIM_ConfigClockSource(&htim4, &sClockSourceConfig) != HAL_OK)
    " n% a# H* h7 {$ B: c5 M( ~
19.     {
    
20.         return FALSE;
    2 u! q( G8 r6 A
21.     }
    * f. V" }: L: P/ G# I( ^
22.     sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
    7 ^, s# e! n! G8 C$ `* w
23.     sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
    ) K* j4 ^* ?5 Y
24.     if (HAL_TIMEx_MasterConfigSynchronization(&htim4, &sMasterConfig) != HAL_OK)
    
25.     {
    # T0 w; ?5 ~$ Y
26.         return FALSE;
    ' l5 Q  s! q# G/ ^8 Y2 ^
27.     }
    3 _, _7 c5 F# w+ B* ~
28. 
    ( f6 l" e- }; K, R
29.     __HAL_TIM_ENABLE_IT(&htim4, TIM_IT_UPDATE);                                        // 使能定时器更新中断
    7 ]% q0 W" c! E
30.     return TRUE;
    
31. }
    : a: Y8 o  k0 \
32. 
    
33. inline void
    6 e' H% {3 {+ H/ r: M; b$ W0 Z
34. vMBPortTimersEnable(  )
    3 {/ l- n  P/ Q
35. {
    
36.     __HAL_TIM_SET_COUNTER(&htim4, 0);                // 清空计数器
    
37.     __HAL_TIM_ENABLE(&htim4);                                // 使能定时器
    8 S8 v# j. a9 [* H
38. }
    : D! ]! v2 R9 \" Q7 B# i
39. 
    + X: S' U& }2 r" S+ f
40. inline void
    
41. vMBPortTimersDisable(  )
    
42. {
    
43.     __HAL_TIM_DISABLE(&htim4);                                // 禁能定时器
    
44. }
    
45. 
    - X9 A' W+ Z! ^
46. /* Create an ISR which is called whenever the timer has expired. This function
    
47. * must then call pxMBPortCBTimerExpired( ) to notify the protocol stack that
    
48. * the timer has expired.
    9 o+ x/ I5 p  \6 Z$ d: ^# z
49. */
    ' A4 d. m8 s4 o+ F3 z9 o. S
50. static void prvvTIMERExpiredISR( void )
    ) [' h7 s% r. h" G, }/ J- c
51. {
    
52.     ( void )pxMBPortCBTimerExpired(  );
    
53. }
    
54. 
    
55. /// 定时器4中断服务程序
    ; D" o$ V2 W; \. q+ _* ]; R
56. void TIM4_IRQHandler(void)
    
57. {
    
58.     if(__HAL_TIM_GET_FLAG(&htim4, TIM_FLAG_UPDATE))                        // 更新中断标记被置位
    1 k+ D( x! a4 k+ @# b' r
59.     {
    : f. V6 q: {: j3 k/ B- o& b  q# [
60.         __HAL_TIM_CLEAR_FLAG(&htim4, TIM_FLAG_UPDATE);                // 清除中断标记
    " Y: z: p$ v  P9 H3 Z; ]) |4 R
61.         prvvTIMERExpiredISR();                                                                // 通知modbus3.5个字符等待时间到
    
62.     }
    
63. }
    , ~) i3 t* A: ~1 F; t
64. 
    & a1 ?1 @3 p) U! a* I: R5 a7 ]! \. x& ]
65. 
    

复制代码

! j% l# X% ^( S, u+ q修改modbus串口初始化源代码portserial.c文件
$ e! `! O" ?  O. M4 I! k         ~~~~~~~~        在该文件中实现串口1的中断服务程序，prvvUARTTxReadyISR和prvvUARTRxISR函数需要填写进中断服务程序，前者得到作用为通知modbus协议栈串口已经空闲可以发送数据了，后者的作用为通知modbus串口1有数据到达，修改后的代码如下：
) ?( k# T! b- Z# y% e" l. Z- G

1. /*
   9 k3 O. o; d: \
2. * FreeModbus Libary: BARE Port
   1 ]1 o3 d$ V* \) y3 _- P
3. * Copyright (C) 2006 Christian Walter <<a href="mailto:wolti@sil.at">wolti@sil.at</a>>
   
4. *
   : E; J& O& [5 r6 C( P/ ^$ [
5. * This library is free software; you can redistribute it and/or
   
6. * modify it under the terms of the GNU Lesser General Public
   . S% V: C* \% c1 |  |
7. * License as published by the Free Software Foundation; either
   
8. * version 2.1 of the License, or (at your option) any later version.
   ! z+ r& N8 N" h9 U' n: ?
9. *
   
10. * This library is distributed in the hope that it will be useful,
    
11. * but WITHOUT ANY WARRANTY; without even the implied warranty of
    + P9 n) K# @9 }) M
12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    $ E5 w% ?$ z$ A7 L, M. S5 W
13. * Lesser General Public License for more details.
    
14. *
    
15. * You should have received a copy of the GNU Lesser General Public
    
16. * License along with this library; if not, write to the Free Software
    + ?$ ?0 F, l# X; G
17. * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
    
18. *
    " W3 D, a/ S$ A- {. I* I
19. * File: $Id$
    . E, }: x) P4 b; `# ~2 o' J) Q
20. */
    
21. 
    5 w+ i" U: U& a/ `. }
22. #include "port.h"
    
23. #include "usart.h"
    
24. 
    1 {1 {* N( K0 H" w4 m' Y
25. /* ----------------------- Modbus includes ----------------------------------*/
    / j; f2 k: J) m2 P+ [: Q# [0 g# A
26. #include "mb.h"
    " e& N6 y9 {5 W0 _: K
27. #include "mbport.h"
    
28. 
    ' K! O7 u- X$ ]& ]+ b6 ]
29. /* ----------------------- static functions ---------------------------------*/
    8 v) S. ]9 l8 i* N! Y$ k
30. static void prvvUARTTxReadyISR( void );
    
31. static void prvvUARTRxISR( void );
    
32. 
    ! c+ B1 W9 Y% y0 u' i9 e+ }  t! R
33. /* ----------------------- Start implementation -----------------------------*/
    $ ]: {( F# K. d" m: k, z* X& L
34. void
    
35. vMBPortSerialEnable( BOOL xRxEnable, BOOL xTxEnable )
    " k. T$ O8 L0 g; S9 `
36. {
    
37.     if(xRxEnable)
    
38.     {
    . g4 Y/ B& n' p, ?
39.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_RXNE);                // 使能接收非空中断
    * a3 g* z# z' J. @
40.     }
    
41.     else
    
42.     {
    
43.         __HAL_UART_DISABLE_IT(&huart1, UART_IT_RXNE);                // 禁能接收非空中断
    
44.     }
    ' Y2 h$ @9 F7 y' }
45. 
    
46.     if(xTxEnable)
    ! A( z* y9 u  {: m0 ~( a9 t* ], I
47.     {
    ( t9 [8 g8 _7 q/ ~; Z5 e
48.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_TXE);                        // 使能发送为空中断
    
49.     }
    
50.     else
    3 F" C/ d( p( }6 N. Z$ Q
51.     {
    ) W. E% r+ \0 R
52.         __HAL_UART_DISABLE_IT(&huart1, UART_IT_TXE);                // 禁能发送为空中断
    % R+ [: F. m) B# B" L
53.     }
    - P) p1 A. L( x/ m# D0 r1 @
54. }
    / G# J& W* @( }9 _: p
55. 
    ( K. U  n5 W0 }3 R2 r" `
56. BOOL
    
57. xMBPortSerialInit( UCHAR ucPORT, ULONG ulBaudRate, UCHAR ucDataBits, eMBParity eParity )
    0 f" _. R* b, W5 c" Z3 I/ X
58. {
    
59.     huart1.Instance = USART1;
    2 r  C5 ]: U% a) ^6 g1 K# W
60.     huart1.Init.BaudRate = ulBaudRate;
    
61.     huart1.Init.StopBits = UART_STOPBITS_1;
    * ^( F/ p; r7 @, [1 z
62.     huart1.Init.Mode = UART_MODE_TX_RX;
    / p: P* U$ l  `3 w9 H6 |8 X$ y8 p
63.     huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    
64.     huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    
65. 
    2 j; |. G1 e3 r& h8 {, l$ ?3 ~
66.     switch(eParity)
    & f1 v4 V9 W# N6 G9 Y9 `
67.     {
    2 c( @" [4 m% d1 \, ]6 j# S6 O; g
68.         // 奇校验
    
69.     case MB_PAR_ODD:
    4 ^( d" u" \8 d3 {7 Y3 |
70.         huart1.Init.Parity = UART_PARITY_ODD;
    
71.         huart1.Init.WordLength = UART_WORDLENGTH_9B;                        // 带奇偶校验数据位为9bits
    
72.         break;
    
73.         
    * J4 O/ t# c2 r$ y
74.         // 偶校验
    ( V; h! _2 i# n5 B: M  o4 \' M* Z" N2 h
75.     case MB_PAR_EVEN:
    
76.         huart1.Init.Parity = UART_PARITY_EVEN;
    
77.         huart1.Init.WordLength = UART_WORDLENGTH_9B;                        // 带奇偶校验数据位为9bits
    , t2 C6 b* i( c  t
78.         break;
    
79.         
    
80.         // 无校验
    ! R$ q' o, ^" }# u! \
81.     default:
    % }" K" R+ W' P* a
82.         huart1.Init.Parity = UART_PARITY_NONE;
    - B, e/ P5 {/ O8 N0 D' w
83.         huart1.Init.WordLength = UART_WORDLENGTH_8B;                        // 无奇偶校验数据位为8bits
    
84.         break;
    1 a: ?# w/ z( v) V+ K! N
85.     }
    
86.     return HAL_UART_Init(&huart1) == HAL_OK ? TRUE : FALSE;
    
87. }
    
88. 
    * Y7 r. }7 @3 @( ?  J
89. BOOL
    4 x; A! _1 H7 D4 F
90. xMBPortSerialPutByte( CHAR ucByte )
    
91. {
    
92.     USART1->DR = ucByte;
    
93.     return TRUE;
    
94. }
    
95. 
    0 }( T4 x1 R; F( s# r
96. BOOL
    . ]" ?8 U& h; r9 ?" P! S/ ^
97. xMBPortSerialGetByte( CHAR * pucByte )
    
98. {
    / @* w* V9 L; `9 s& e( X
99.     *pucByte = (USART1->DR & (uint16_t)0x00FF);
    
100.         return TRUE;
     
101. }
     
102. 
     
103. /* Create an interrupt handler for the transmit buffer empty interrupt
     
104. * (or an equivalent) for your target processor. This function should then
     
105. * call pxMBFrameCBTransmitterEmpty( ) which tells the protocol stack that
     
106. * a new character can be sent. The protocol stack will then call
     
107. * xMBPortSerialPutByte( ) to send the character.
     ) i& Z& L, A! }' @. Z
108. */
     9 |5 R. L2 y3 w* c" h
109. static void prvvUARTTxReadyISR( void )
     ' T! R. S9 U( O& a
110. {
     6 `1 [' U  |# F' A7 x' v
111.     pxMBFrameCBTransmitterEmpty(  );
     * s0 w& ^2 d1 i, u
112. }
     9 g; T: @) T: d7 Z  ?+ p% S9 l
113. 
     
114. /* Create an interrupt handler for the receive interrupt for your target
     
115. * processor. This function should then call pxMBFrameCBByteReceived( ). The
     
116. * protocol stack will then call xMBPortSerialGetByte( ) to retrieve the
     6 E9 H1 n# M6 R& j. k# f
117. * character.
     
118. */
     
119. static void prvvUARTRxISR( void )
     ' `$ N3 N5 z+ ]+ w* a' k
120. {
     ' _7 t+ Y) e$ L3 A- W) R, M3 R
121.     pxMBFrameCBByteReceived(  );
     
122. }
     
123. 
     ! t+ U* [; M; q2 [2 K
124. void USART1_IRQHandler(void)
     ; x7 X! `+ m4 m( r) l3 P
125. {
     
126.     if(__HAL_UART_GET_FLAG(&huart1, UART_FLAG_RXNE))                        // 接收非空中断标记被置位
     1 k& Y7 w! C) t/ X, |+ }. K4 l
127.     {
     * ^# F) o( d% M$ s, H4 N
128.         __HAL_UART_CLEAR_FLAG(&huart1, UART_FLAG_RXNE);                        // 清除中断标记
     
129.         prvvUARTRxISR();                                                                                // 通知modbus有数据到达
     
130.     }
     
131. 
     
132.     if(__HAL_UART_GET_FLAG(&huart1, UART_FLAG_TXE))                                // 发送为空中断标记被置位
     
133.     {
     
134.         __HAL_UART_CLEAR_FLAG(&huart1, UART_FLAG_TXE);                        // 清除中断标记
     ; m* w/ p. m2 ~7 ?/ D
135.         prvvUARTTxReadyISR();                                                                        // 通知modbus数据可以发松
     
136.     }
     
137. }

复制代码

) w- D: b9 z; [  S- t注意一点，一般如果使用了485芯片的话，那么同一时刻只能接收或者发送，可以将函数vMBPortSerialEnable修改成这样：

1. void
   
2. vMBPortSerialEnable( BOOL xRxEnable, BOOL xTxEnable )
   
3. {
     m6 X) J; \* r
4.     if(xRxEnable)
   
5.     {
   
6.             //
   2 T0 I7 u% V9 J( g
7.         // 在此处将485芯片设置为接收模式
   
8.         //
   8 o3 q6 o" }. u
9.                 /* do something */
   7 R# a/ h) @* W" d0 A* }# E
10.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_RXNE);                // 使能接收非空中断
    " y' P0 K# N" O  v% M4 f- X: `
11.     }
    
12.     else
    
13.     {
    ( w0 w- t% D) e" s
14.         __HAL_UART_DISABLE_IT(&huart1, UART_IT_RXNE);                // 禁能接收非空中断
    
15.     }
    
16. 
    
17.     if(xTxEnable)
    8 j: E; m6 r5 R
18.     {
    & h2 c' K7 l  W) ^8 }
19.             //
    , J$ t; K# h1 \* d1 G' C
20.         // 在此处将485芯片设置为发送模式
    
21.         //
    
22.         /* do something */
    
23.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_TXE);                        // 使能发送为空中断
    
24.     }
    9 E0 r+ v$ [$ M4 R6 x  S
25.     else
    
26.     {
    
27.         __HAL_UART_DISABLE_IT(&huart1, UART_IT_TXE);                // 禁能发送为空中断
    
28.     }
    
29. }

复制代码

编写modbus命令处理回调函数port.c文件
本例程只实现了读取输入寄存器和保持寄存器的功能，详细代码如下：

; I8 ^" D. K) {/ \0 Q" I4 f

1. #include "mb.h"
   
2. #include "mbport.h"
   ; N: z4 a9 ^  R0 I& m+ Q1 X/ [( G
3. 
   " W2 o$ v4 q. i% o: _% M* ?
4. 
   & T6 N+ D" _6 @
5. // 十路输入寄存器
   8 o. B. q) s6 C) N: E
6. #define REG_INPUT_SIZE  10
   . f8 g; }# K7 d8 V- n! f
7. uint16_t REG_INPUT_BUF[REG_INPUT_SIZE];
   
8. 
   
9. 
   . m$ Z* R7 `4 |
10. // 十路保持寄存器
    * O$ S+ E/ E' @
11. #define REG_HOLD_SIZE   10
    8 |2 H3 G' B8 L' h( Z
12. uint16_t REG_HOLD_BUF[REG_HOLD_SIZE];
    
13. 
    
14. 
    
15. // 十路线圈
    
16. #define REG_COILS_SIZE 10
    
17. uint8_t REG_COILS_BUF[REG_COILS_SIZE];
    9 |6 D9 M3 D* w9 Y
18. 
    5 H; S. q3 X% W0 a
19. 
    
20. // 十路离散量
    
21. #define REG_DISC_SIZE  10
    + M& v  k* {8 B+ k8 c& C! v& n( Y) W# d
22. uint8_t REG_DISC_BUF[10];
    
23. 
    " h$ }* Y' U8 X" E
24. 
    % x, q* L% W# n, [/ J  W/ J
25. /// CMD4
    & f) `! O/ m1 w% A! {
26. eMBErrorCode eMBRegInputCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs )
    9 h- l) ~! u5 R6 z( e
27. {
    $ m4 c8 W' G# w* }3 V, M; R/ V
28.     USHORT usRegIndex = usAddress - 1;
    ! d! a$ v+ ?" @! p
29. 
    7 B( J0 H! f0 E7 M
30.     // 非法检测
    
31.     if((usRegIndex + usNRegs) > REG_INPUT_SIZE)
    $ q/ z  z6 {5 M; H: f
32.     {
    
33.         return MB_ENOREG;
    
34.     }
    
35. 
    2 G  ?. w  w! @! P& D. O
36.     // 循环读取
    
37.     while( usNRegs > 0 )
    2 y7 F  d6 v8 G* ^4 n
38.     {
    ! \3 t' m' F/ W2 O/ e% s) R6 \+ q
39.         *pucRegBuffer++ = ( unsigned char )( REG_INPUT_BUF[usRegIndex] >> 8 );
    
40.         *pucRegBuffer++ = ( unsigned char )( REG_INPUT_BUF[usRegIndex] & 0xFF );
    0 s$ T! J# ~3 g% s
41.         usRegIndex++;
    
42.         usNRegs--;
    
43.     }
    
44. 
    7 \/ ?6 e2 O4 l; Z$ c: R2 j) v
45.     // 模拟输入寄存器被改变
    
46.     for(usRegIndex = 0; usRegIndex < REG_INPUT_SIZE; usRegIndex++)
    
47.     {
    6 a% k( p6 [+ l5 s
48.         REG_INPUT_BUF[usRegIndex]++;
    
49.     }
    
50. 
    # |0 b, G6 d. {8 i' }. x: J% E
51.     return MB_ENOERR;
    
52. }
    3 w( y" _% A7 j+ a0 p% J1 M
53. 
    
54. /// CMD6、3、16
    0 y: n9 X" v4 U' b
55. eMBErrorCode eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs, eMBRegisterMode eMode )
    2 q. |% D6 D0 [5 L7 p+ T: c7 a1 |% }
56. {
    
57.     USHORT usRegIndex = usAddress - 1;  
    
58. 
    6 _' u8 e2 ~% ]0 j  \; Z' f2 I  Y
59.     // 非法检测
    
60.     if((usRegIndex + usNRegs) > REG_HOLD_SIZE)
    
61.     {
    
62.         return MB_ENOREG;
    3 X' p6 M/ h9 v7 Q) q
63.     }
      c1 s( x- D# q2 c8 y5 [0 x
64. 
    6 C+ H! h5 Z) O8 O) X
65.         // 写寄存器
    
66.     if(eMode == MB_REG_WRITE)
    
67.     {
    
68.         while( usNRegs > 0 )
    % f7 \' H3 Y0 J& |: I) C! W
69.         {
    
70.                         REG_HOLD_BUF[usRegIndex] = (pucRegBuffer[0] << 8) | pucRegBuffer[1];
    + D2 ]- k8 T; ?4 S
71.                         pucRegBuffer += 2;
    
72.             usRegIndex++;
    . P7 N$ q/ Y0 U5 K3 _- F! P
73.             usNRegs--;
    
74.         }
    
75.     }
    
76.         
    4 b7 P( {2 o4 m1 m0 C8 L( c2 g
77.         // 读寄存器
    % u7 g4 v: n& h) ?( i
78.     else
    
79.     {
    * S) _) T* ?/ {3 U* i: t. R9 f. _
80.         while( usNRegs > 0 )
    1 [/ [1 d4 \6 x  [; X4 B
81.         {
    
82.             *pucRegBuffer++ = ( unsigned char )( REG_HOLD_BUF[usRegIndex] >> 8 );
    % i( x$ ^: [# v3 s  t7 L
83.             *pucRegBuffer++ = ( unsigned char )( REG_HOLD_BUF[usRegIndex] & 0xFF );
    0 B$ J6 l& ]3 u% o0 H9 B% }; ~. P
84.             usRegIndex++;
    + Z3 W' }  Y) e1 O+ R
85.             usNRegs--;
    
86.         }
    2 z" B6 _: a: z  _3 F
87.     }
    & s7 D/ Z( Q! C* [
88. 
    
89.     return MB_ENOERR;
    
90. }
    ) u" K& h+ H8 u3 f  t1 R1 s
91. 
    
92. /// CMD1、5、15
    # m6 p6 I" H  j+ Z) d
93. eMBErrorCode eMBRegCoilsCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNCoils, eMBRegisterMode eMode )
    
94. {
    - T7 ~7 P3 x, T) f+ V( y
95.     USHORT usRegIndex   = usAddress - 1;
    
96.     USHORT usCoilGroups = ((usNCoils - 1) / 8 + 1);
    
97.     UCHAR  ucStatus     = 0;
    : B2 k! Y; ^# s
98.     UCHAR  ucBits       = 0;
    
99.     UCHAR  ucDisp       = 0;
    
100. 
     & t' T7 Y3 \& ^3 {  ^/ m$ U9 Y
101.     // 非法检测
     
102.     if((usRegIndex + usNCoils) > REG_COILS_SIZE)
     9 w+ O0 _9 @% T3 Y9 F1 ?  o& @
103.     {
     
104.         return MB_ENOREG;
     + U! q# R% K1 s0 \7 [/ g4 }9 A; z
105.     }
     5 X1 L# ~0 V* ]" q
106. 
     
107.     // 写线圈
     $ `+ B9 G$ @  v  M$ `
108.     if(eMode == MB_REG_WRITE)
     9 ?& w: z1 w) m; G( r) d
109.     {
     : j, U( _3 d5 i' D$ a3 S
110.         while(usCoilGroups--)
     
111.         {
     
112.             ucStatus = *pucRegBuffer++;
     ; F; q3 t+ `; ~
113.             ucBits   = 8;
     
114.             while((usNCoils--) != 0 && (ucBits--) != 0)
     : U& Z9 F; l. R0 F) I# m3 s9 S/ V" C+ r' I
115.             {
     
116.                 REG_COILS_BUF[usRegIndex++] = ucStatus & 0X01;
     
117.                 ucStatus >>= 1;
     " e; }' t( R7 P( w
118.             }
     1 V( T1 p  z) q
119.         }
     ( ?, Y# q- S1 Q* R! a# i
120.     }
     * O7 G; q- ~# x( e) R  [% n
121. 
     5 g+ U! {8 u" |' u; b( Q
122.     // 读线圈
     ( s0 y" p- @& o) |5 A9 z# u
123.     else
     & o% o& c7 g, g( L" X" v4 N/ R
124.     {
     
125.         while(usCoilGroups--)
     9 s! M) o% O- i! t
126.         {
     
127.             ucDisp = 0;
     
128.             ucBits = 8;
     
129.             while((usNCoils--) != 0 && (ucBits--) != 0)
     * E) M- F6 y6 D* n; H( f
130.             {
     , O) b4 H2 N5 A
131.                 ucStatus |= (REG_COILS_BUF[usRegIndex++] << (ucDisp++));
     
132.             }
     ( m$ f  v* `% Y; O1 D) Y. p
133.             *pucRegBuffer++ = ucStatus;
     
134.         }
     : ]8 m' x* N% d* K
135.     }
     
136.     return MB_ENOERR;
     ! b! r) p1 o3 g
137. }
     - w0 Y# l4 D1 u8 p4 M8 Z8 {3 A9 ~
138. 
     
139. 
     
140. /// CMD4
     6 K1 T2 z" ^4 D3 L& T' H' ^) O
141. eMBErrorCode eMBRegDiscreteCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNDiscrete )
     5 A( Y" K9 N; \% p# q: d. E! K
142. {
     * v3 ]6 m) L. f7 ]: b; b
143.     USHORT usRegIndex   = usAddress - 1;
     
144.     USHORT usCoilGroups = ((usNDiscrete - 1) / 8 + 1);
     - s$ i+ |$ k% s9 N, ?
145.     UCHAR  ucStatus     = 0;
     
146.     UCHAR  ucBits       = 0;
     
147.     UCHAR  ucDisp       = 0;
     
148. 
     # Y) ]3 Z- L, e2 {
149.     // 非法检测
     
150.     if((usRegIndex + usNDiscrete) > REG_DISC_SIZE)
     
151.     {
     
152.         return MB_ENOREG;
     
153.     }
     
154. 
     ) N' I* w- s* R+ V9 z. ^, j: x
155.         // 读离散输入
     
156.         while(usCoilGroups--)
     4 o2 w" v& [& Z. i$ v
157.         {
     . v& A# ?: Y' N, L# [5 |$ P
158.                 ucDisp = 0;
     
159.                 ucBits = 8;
       Z9 \8 |$ O* }$ [& T- v, U* ^8 F
160.                 while((usNDiscrete--) != 0 && (ucBits--) != 0)
     5 Y) G0 ~% P: F# i
161.                 {
     
162.                         if(REG_DISC_BUF[usRegIndex])
     1 P, N% A! p% ?) E& @
163.                         {
     
164.                                 ucStatus |= (1 << ucDisp);
     
165.                         }
     
166.                         ucDisp++;
     
167.                 }
     
168.                 *pucRegBuffer++ = ucStatus;
     " C3 |$ s8 l0 O  O" o
169.         }
     
170. 
     
171.     // 模拟改变
     3 Z. r& A/ w+ L9 M! @
172.     for(usRegIndex = 0; usRegIndex < REG_DISC_SIZE; usRegIndex++)
     
173.     {
     + q: l) _' E" i# P; a
174.         REG_DISC_BUF[usRegIndex] = !REG_DISC_BUF[usRegIndex];
     - |1 {9 R! e$ C4 N) j9 D6 ?) z
175.     }
     + k6 I2 D: ?( {* ?  I# N( D
176. 
     . R) y6 e) M1 X" _
177.     return MB_ENOERR;
     . \/ q. c. D, J: @( E5 k) p
178. }

复制代码

5 l+ p' c+ c% U1 }3 G9 T) J主函数
+ m/ u: Y5 z* N* h5 _$ ^* H; c

1. int main(void)
   9 u% x8 f7 D: U- M! {/ }  Q, R& {
2. {
   9 A: n6 I, x7 N5 G4 x4 ~$ s
3.     HAL_Init();
   1 u- k& R4 M' K6 j" z# I) x
4.     SystemClock_Config();
   
5.     MX_GPIO_Init();
   5 g( R6 i2 M* I7 s+ V: m
6.     eMBInit(MB_RTU, 0x01, 0, 9600, MB_PAR_ODD);                // 初始化modbus为RTU方式，波特率9600，奇校验
   
7.     eMBEnable();                                                                        // 使能modbus协议栈
   
8. 
   
9.     for( ;; )
   
10.     {
    
11.         eMBPoll();                                                                        // 轮训查询
    8 E8 q! I$ Y' `& _
12.     }
    
13. }

复制代码

移植测试
4 K* w/ }# u' Z" z( r' V

8 x) w1 J3 d' ?6 U# }
7 p% v/ ?  D3 m" M. Rends…
: G4 A; E$ l; L7 C" i5 v
% K4 h+ ?( k, e" m4 z3 N  ^

我的是stm32g071系列，移植上去不行怎么办