modbus命令码表：

# C+ g: j+ _! G6 W! Z4 c0 W
- |8 H0 t3 B* C9 M% }) x/ M  Q
& k' o" q; C7 |" s( G) ?FreeModbus文件说明
      解压freemodbus文件后打开，我们需要demo目录下的BARE，该目录下的代码是空的，STM32移植工作基本就是修改：portserial.c、porttimer.c、port.h这三个文件。
- s" Q4 P2 e; N# U
3 K$ P. e7 R7 A5 O2 [) [
      mobus文件夹就是完整的源码，包含rtu、ascii、tcp：
8 \' V1 T  |. p* L
; c  }+ ]" d7 w# \- z* `

3 P! f2 a( }+ E( C      我为了移植时在keil添加源文件和头文件方便，就把modbus所有的头文件和源文件放到了一个文件夹下，并创建了一个port.c文件，用于编写modbus所必需的回调处理函数：
2 R- |- F% z( a( d/ y
" B# w4 j* y- c% s8 M' o
. Y0 [) V" q6 r. Y# b( {
STM32CUBEMX配置
时钟配置，设置主频工作在72MHz下：


) t) }9 j6 l( j! _# t& {
配置串口1，这里随便配置就行，在modbus移植过程中还会对串口重新初始化：
3 n# R( d; x( B5 E  V' ~/ j0 C
3 P% W2 e* |% s% t1 p- r9 v1 M

6 j2 b2 J7 {8 C0 F配置定时器4，用于3.5个字符的定时检测，这里随便配置就行，在modbus移植过程中还会对定时器重新初始化：
) Q& f+ h3 N, ?5 X- H0 t* j0 `7 |


中断配置，这里注意，串口的优先级是要比定时器优先高的：
$ T6 i" b1 Z: \# _5 G4 q& ?

+ S! L5 t) K2 s) l+ J8 C- g+ Z& v取消掉自动生成中断服务程序，在移植过程中我们要自己编写串口和定时器的中断服务程序：
2 k, }  t" N- s3 L2 X! [
& z/ W& a9 k7 {0 Q2 c

移植代码修改
# w* e# s9 Z) a- k( c0 [! j  t# P生成代码后将modbus放到工程目录下：
2 o2 w. a) t4 T
" f) k1 {# [" p( c! B
, o/ ?. I9 \( x/ D) N$ X
打开keil工程添加modbus源码：
+ |5 H0 Y2 k0 C  ]" Z. U! q7 J
5 J# x" b7 O& `5 J/ E

: w- ^. ^* J" h) O! @添加包含头文件：
7 F) C- m0 t; t4 J: P

0 G, G8 e1 {8 ^  o
) O9 p! k; R( Q& k" K" z* x修改modbus定时器初始化源代码porttimer.c文件
7 g- R2 k" L! d) n  ]       定时器的修改比较容易，将定时器设置为每50us的时长记一个数，传入的usTim1Timerout50us变量给自动装载即可，prvvTIMERExpiredISR函数需要在定时器中断服务函数中调用，它的作用是用于通知modbus协议栈3.5个字符的等待时间已经到达；由于我们在STM32CUBEMX中取消掉了定时器和串口的中断服务函数程序，所以我们在该文件中添加定时器的中断服务程序，修改后的代码如下：
% e7 \: b2 u6 f6 F% y

1. BOOL
   
2. xMBPortTimersInit( USHORT usTim1Timerout50us )
   
3. {
   
4.     TIM_ClockConfigTypeDef sClockSourceConfig = {0};
   $ J7 B5 p: ~: a* r/ B
5.     TIM_MasterConfigTypeDef sMasterConfig = {0};
   - D0 K2 p9 A2 r2 |0 r+ v) O% e
6. 
   9 p. D8 i! {7 M
7.     htim4.Instance = TIM4;
     y7 R' C( s" K" K0 B
8.     htim4.Init.Prescaler = 3599;                                                                // 50us记一次数
   
9.     htim4.Init.CounterMode = TIM_COUNTERMODE_UP;
   % d. e2 t6 h; X0 u# P
10.     htim4.Init.Period = usTim1Timerout50us - 1;                                        // usTim1Timerout50us * 50即为定时器溢出时间
    9 _7 V! ~; ?* D- g  ]
11.     htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    : D* o0 \4 K7 ?& B$ t
12.     htim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
    
13.     if (HAL_TIM_Base_Init(&htim4) != HAL_OK)
    
14.     {
    
15.         return FALSE;
    ( o/ t+ U9 {9 N6 P3 F
16.     }
    & H% m- t) B. s" L
17.     sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
    8 b1 L+ ~& N) R
18.     if (HAL_TIM_ConfigClockSource(&htim4, &sClockSourceConfig) != HAL_OK)
    & m; ~, U# i0 [/ Y$ b
19.     {
    
20.         return FALSE;
    
21.     }
    5 h, p1 C9 {0 R5 o( T' X
22.     sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
    
23.     sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
    
24.     if (HAL_TIMEx_MasterConfigSynchronization(&htim4, &sMasterConfig) != HAL_OK)
    : s& s6 Q0 M7 X/ k* C4 Z% W/ o7 T
25.     {
    . t8 R% F( ~4 J
26.         return FALSE;
    + S& {: s* P/ x5 O$ {2 M5 t
27.     }
    
28. 
    
29.     __HAL_TIM_ENABLE_IT(&htim4, TIM_IT_UPDATE);                                        // 使能定时器更新中断
    ( q7 a( S6 a- Q3 W' f
30.     return TRUE;
    
31. }
    
32. 
    
33. inline void
    
34. vMBPortTimersEnable(  )
    
35. {
    
36.     __HAL_TIM_SET_COUNTER(&htim4, 0);                // 清空计数器
    
37.     __HAL_TIM_ENABLE(&htim4);                                // 使能定时器
    
38. }
    
39. 
    3 a0 B7 \: }: C* L, ?/ P) {9 x; P  M- F; R
40. inline void
      v0 N3 A+ {/ b( y$ U
41. vMBPortTimersDisable(  )
    
42. {
    $ n6 `9 Q7 m$ J% y+ Q
43.     __HAL_TIM_DISABLE(&htim4);                                // 禁能定时器
    
44. }
    
45. 
    2 g3 Z5 t! A1 ^( m! c. X& q( e
46. /* Create an ISR which is called whenever the timer has expired. This function
    5 N/ E/ o1 z7 k1 H
47. * must then call pxMBPortCBTimerExpired( ) to notify the protocol stack that
    
48. * the timer has expired.
    ; P3 i0 L$ m  T! V! e
49. */
    
50. static void prvvTIMERExpiredISR( void )
    " v" [4 o7 m3 m' ]4 H2 _
51. {
    $ T8 c8 c" V/ L9 k
52.     ( void )pxMBPortCBTimerExpired(  );
    
53. }
    
54. 
    . w3 g+ D( v6 K3 i. h! C
55. /// 定时器4中断服务程序
    + X( \$ h" s" u7 _6 y
56. void TIM4_IRQHandler(void)
      h+ B: Y8 }: r
57. {
    
58.     if(__HAL_TIM_GET_FLAG(&htim4, TIM_FLAG_UPDATE))                        // 更新中断标记被置位
    , M+ _* D! d& C. V! Q' \9 \, E
59.     {
    ! m( V. ^1 |" k" C% M8 H& ]
60.         __HAL_TIM_CLEAR_FLAG(&htim4, TIM_FLAG_UPDATE);                // 清除中断标记
    ( U  }' `  R, g% ]5 b
61.         prvvTIMERExpiredISR();                                                                // 通知modbus3.5个字符等待时间到
    ' u% U$ G6 y) Q* G4 D; I8 c( }
62.     }
    
63. }
    8 l) _2 u  P# R1 }
64. 
    % a6 q! f; L+ ]/ ]
65. 
    

复制代码

修改modbus串口初始化源代码portserial.c文件
         ~~~~~~~~        在该文件中实现串口1的中断服务程序，prvvUARTTxReadyISR和prvvUARTRxISR函数需要填写进中断服务程序，前者得到作用为通知modbus协议栈串口已经空闲可以发送数据了，后者的作用为通知modbus串口1有数据到达，修改后的代码如下：
  Q2 F0 R" c/ \2 _) H

1. /*
   
2. * FreeModbus Libary: BARE Port
   
3. * Copyright (C) 2006 Christian Walter <<a href="mailto:wolti@sil.at">wolti@sil.at</a>>
   * I  p: v4 x! ]( m) b8 z+ N1 b+ W
4. *
   
5. * This library is free software; you can redistribute it and/or
   * _; f" j0 m" C4 o: T6 t' s
6. * modify it under the terms of the GNU Lesser General Public
   ! n$ j7 _* p7 B3 b) u
7. * License as published by the Free Software Foundation; either
   : I  ^, l  _* c* v& N7 ]
8. * version 2.1 of the License, or (at your option) any later version.
   . N* g& s. D2 F* E! s  O/ D) H) F
9. *
   
10. * This library is distributed in the hope that it will be useful,
    4 Q- X# F4 T+ V# V* o& o7 c4 q
11. * but WITHOUT ANY WARRANTY; without even the implied warranty of
    
12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    
13. * Lesser General Public License for more details.
    
14. *
    
15. * You should have received a copy of the GNU Lesser General Public
      d& a2 l/ J; f; l( c( ?8 Z
16. * License along with this library; if not, write to the Free Software
    ' }4 |6 H6 ^9 L% M. z
17. * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
    
18. *
    
19. * File: $Id$
    
20. */
    
21. 
    
22. #include "port.h"
    
23. #include "usart.h"
    
24. 
    3 P! n; K0 C0 e* [; Z
25. /* ----------------------- Modbus includes ----------------------------------*/
    
26. #include "mb.h"
    , x- _, X# X+ w. C
27. #include "mbport.h"
    
28. 
    $ e7 u% e, k' L: l9 @- W* x2 x+ _
29. /* ----------------------- static functions ---------------------------------*/
    ) f8 X) X6 C# A
30. static void prvvUARTTxReadyISR( void );
    % R1 j( `9 E6 j6 E
31. static void prvvUARTRxISR( void );
    
32. 
    " B4 _, C) |* U2 [  ~+ T; v
33. /* ----------------------- Start implementation -----------------------------*/
    
34. void
    
35. vMBPortSerialEnable( BOOL xRxEnable, BOOL xTxEnable )
    - z7 k( _0 C3 |! s
36. {
    
37.     if(xRxEnable)
    ! S- C  d1 @" g4 R
38.     {
    6 ?1 b6 o+ y! A
39.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_RXNE);                // 使能接收非空中断
    
40.     }
    
41.     else
    
42.     {
    
43.         __HAL_UART_DISABLE_IT(&huart1, UART_IT_RXNE);                // 禁能接收非空中断
    
44.     }
    
45. 
    ( T9 B6 |% J+ D1 j, d! X% D
46.     if(xTxEnable)
    
47.     {
    ' G* T* {% y4 f+ m! X
48.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_TXE);                        // 使能发送为空中断
    
49.     }
    
50.     else
    7 C6 K. A$ T! b4 O
51.     {
    
52.         __HAL_UART_DISABLE_IT(&huart1, UART_IT_TXE);                // 禁能发送为空中断
    
53.     }
    
54. }
    : m/ j  u( o* }) n* R: g' W
55. 
    
56. BOOL
    1 k, q1 p4 g/ y& F3 z  o
57. xMBPortSerialInit( UCHAR ucPORT, ULONG ulBaudRate, UCHAR ucDataBits, eMBParity eParity )
    
58. {
    
59.     huart1.Instance = USART1;
    
60.     huart1.Init.BaudRate = ulBaudRate;
    
61.     huart1.Init.StopBits = UART_STOPBITS_1;
    
62.     huart1.Init.Mode = UART_MODE_TX_RX;
    3 m2 R) d1 g4 X9 E: }' M- z
63.     huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    ; q# w8 N1 q' W% I$ D3 r
64.     huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    
65. 
    
66.     switch(eParity)
    
67.     {
    
68.         // 奇校验
    * B' u2 F6 {& r) G0 h2 w, g
69.     case MB_PAR_ODD:
    # I* ?5 O  k5 V, W! u2 d
70.         huart1.Init.Parity = UART_PARITY_ODD;
    
71.         huart1.Init.WordLength = UART_WORDLENGTH_9B;                        // 带奇偶校验数据位为9bits
    * [  a" R  ^& \! j# M5 e
72.         break;
    . \% X. Z2 L; Z5 _# K2 V1 _
73.         
    
74.         // 偶校验
    1 ^4 K! c' p% [5 d. a% a8 ]3 `
75.     case MB_PAR_EVEN:
    1 H6 z: m7 R5 i/ p: G
76.         huart1.Init.Parity = UART_PARITY_EVEN;
    & }- H7 D, q: d$ h8 F! C
77.         huart1.Init.WordLength = UART_WORDLENGTH_9B;                        // 带奇偶校验数据位为9bits
    
78.         break;
    
79.         
    
80.         // 无校验
    5 i! l- E$ s# }; g) j% u% E
81.     default:
    
82.         huart1.Init.Parity = UART_PARITY_NONE;
    8 ?7 A! j7 R. E( g
83.         huart1.Init.WordLength = UART_WORDLENGTH_8B;                        // 无奇偶校验数据位为8bits
    . Y. U6 V2 W2 Q6 _+ M7 Y& b- N
84.         break;
    
85.     }
    1 _# r$ z; t9 A; z2 Q
86.     return HAL_UART_Init(&huart1) == HAL_OK ? TRUE : FALSE;
    
87. }
    
88. 
    % B0 }0 _4 Z9 c% k8 k
89. BOOL
    
90. xMBPortSerialPutByte( CHAR ucByte )
    
91. {
    . B+ s- g% ~  q" o1 H+ }( i4 a7 g
92.     USART1->DR = ucByte;
    & X. T" A& A. f1 n
93.     return TRUE;
    
94. }
    
95. 
    
96. BOOL
    6 d2 l) G; |* M. [9 K8 M. D, [
97. xMBPortSerialGetByte( CHAR * pucByte )
    $ c/ A* ^# M) ^) W) \7 b. R
98. {
    
99.     *pucByte = (USART1->DR & (uint16_t)0x00FF);
    ! `5 n; j2 u  a* X5 E+ ]
100.         return TRUE;
     
101. }
     
102. 
     : z, _& }4 E! t& x6 K2 ~
103. /* Create an interrupt handler for the transmit buffer empty interrupt
       @. P: R2 ?. S+ T5 V' H7 ]0 F
104. * (or an equivalent) for your target processor. This function should then
     
105. * call pxMBFrameCBTransmitterEmpty( ) which tells the protocol stack that
     3 C7 ?. b* V; d: l* ~6 w6 G1 |( _
106. * a new character can be sent. The protocol stack will then call
     
107. * xMBPortSerialPutByte( ) to send the character.
     / H! X7 [3 i; \; R
108. */
     
109. static void prvvUARTTxReadyISR( void )
     
110. {
     ) a5 i. R9 \# z  e) O
111.     pxMBFrameCBTransmitterEmpty(  );
     6 e( ~( ~( l/ P6 b. ?8 s( e
112. }
     
113. 
     1 z4 V1 P# e5 y' q+ H" @# z( G$ h
114. /* Create an interrupt handler for the receive interrupt for your target
     : I' Z* _8 c1 H' ^
115. * processor. This function should then call pxMBFrameCBByteReceived( ). The
     * @8 |1 Z% Y: C& c2 e9 B
116. * protocol stack will then call xMBPortSerialGetByte( ) to retrieve the
     
117. * character.
     # \) }4 \4 I5 @+ S5 Z& `1 s# w
118. */
     
119. static void prvvUARTRxISR( void )
     
120. {
     ) k$ ~% p4 I5 E) _8 J8 P, o& m1 d
121.     pxMBFrameCBByteReceived(  );
     3 z  y  Q1 ~3 h5 e* k
122. }
     % N+ b* w6 e% E; H* f4 g
123. 
     $ S0 [- c  {5 y& G
124. void USART1_IRQHandler(void)
     
125. {
     
126.     if(__HAL_UART_GET_FLAG(&huart1, UART_FLAG_RXNE))                        // 接收非空中断标记被置位
     
127.     {
     
128.         __HAL_UART_CLEAR_FLAG(&huart1, UART_FLAG_RXNE);                        // 清除中断标记
     
129.         prvvUARTRxISR();                                                                                // 通知modbus有数据到达
     8 V4 [2 I' C( J5 N
130.     }
     
131. 
     & V7 i  h$ U7 Z4 K2 `4 Y
132.     if(__HAL_UART_GET_FLAG(&huart1, UART_FLAG_TXE))                                // 发送为空中断标记被置位
     ! x$ u( ^2 L6 h0 I* W( q( r, M( t
133.     {
     : D$ U6 E9 L/ p* j' {5 i# P5 P
134.         __HAL_UART_CLEAR_FLAG(&huart1, UART_FLAG_TXE);                        // 清除中断标记
     . j% E. u1 T6 |6 u
135.         prvvUARTTxReadyISR();                                                                        // 通知modbus数据可以发松
     % l$ B" @% o; o  ^$ {3 l2 N
136.     }
       b7 R+ n% D5 l" z" s% o( h5 l
137. }

复制代码

* X7 {( P( n6 X# @7 [/ _注意一点，一般如果使用了485芯片的话，那么同一时刻只能接收或者发送，可以将函数vMBPortSerialEnable修改成这样：

1. void
   
2. vMBPortSerialEnable( BOOL xRxEnable, BOOL xTxEnable )
   , l+ m2 _+ v" Q2 A: ]
3. {
   ( {; q% r8 j; W; o* Q4 Q
4.     if(xRxEnable)
   8 k. z# g5 a& s' j& w
5.     {
   6 L: y! z( m, P; N  n' }" J
6.             //
   
7.         // 在此处将485芯片设置为接收模式
   + @7 O# r6 V, ?0 U0 ]5 D: L2 f) ?
8.         //
   6 V* ^" F, O- i) O
9.                 /* do something */
   
10.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_RXNE);                // 使能接收非空中断
    
11.     }
    
12.     else
    
13.     {
    - y0 p2 n% o9 F0 z
14.         __HAL_UART_DISABLE_IT(&huart1, UART_IT_RXNE);                // 禁能接收非空中断
    
15.     }
    3 f( P3 M2 o) F: Z
16. 
    
17.     if(xTxEnable)
    
18.     {
    
19.             //
    " u, k. E& A; a7 K7 ~8 o& G, j
20.         // 在此处将485芯片设置为发送模式
    
21.         //
    * K+ K3 F& h# j+ A; ?5 P
22.         /* do something */
    9 h# i; F/ s7 R: L
23.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_TXE);                        // 使能发送为空中断
    
24.     }
    1 e: E* U) u; Z' ~
25.     else
    
26.     {
    4 ~3 d# T) n5 S7 s: E7 a0 E& F& n
27.         __HAL_UART_DISABLE_IT(&huart1, UART_IT_TXE);                // 禁能发送为空中断
    : W" K& E# X, P; |, _$ |
28.     }
    8 ?+ U* H4 `- w3 \, l
29. }

复制代码

$ B5 ^. r1 g+ L' J8 U  k3 ]编写modbus命令处理回调函数port.c文件
# N( D( ^/ j0 c本例程只实现了读取输入寄存器和保持寄存器的功能，详细代码如下：

& L) }# r# Q0 `9 i. r0 b

1. #include "mb.h"
   7 s2 p# A  S- u' i* ?- T. U- v0 D
2. #include "mbport.h"
   7 y+ q  z# J6 w3 ?6 h( Q/ s7 k
3. 
   1 k. ]' O! r0 u
4. 
   , X3 N( N, [' o
5. // 十路输入寄存器
   - y2 r, C6 {5 M6 l
6. #define REG_INPUT_SIZE  10
   ) n" g" L: q/ B
7. uint16_t REG_INPUT_BUF[REG_INPUT_SIZE];
   
8. 
   0 O2 w" ]3 w! r3 ?
9. 
   
10. // 十路保持寄存器
    
11. #define REG_HOLD_SIZE   10
    6 R3 n2 g- A2 l
12. uint16_t REG_HOLD_BUF[REG_HOLD_SIZE];
    ' T7 u* {6 s$ X5 t, b
13. 
    3 t6 ~& |  G0 d7 L  J* G5 [
14. 
    
15. // 十路线圈
    
16. #define REG_COILS_SIZE 10
    ) i- ^4 v4 k% G) }4 Q1 U7 b6 h
17. uint8_t REG_COILS_BUF[REG_COILS_SIZE];
    5 k% S: _  C* }5 J7 x' G+ H
18. 
    
19. 
    , ?% X1 \- c1 l1 u
20. // 十路离散量
    
21. #define REG_DISC_SIZE  10
    
22. uint8_t REG_DISC_BUF[10];
    
23. 
    
24. 
    + C7 F9 L1 ]) z+ ^' x) K
25. /// CMD4
    
26. eMBErrorCode eMBRegInputCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs )
    
27. {
    . j% G) W. S7 r0 m5 q' ^
28.     USHORT usRegIndex = usAddress - 1;
    
29. 
    
30.     // 非法检测
    : {/ D9 s- n" q- g2 h8 z# B" O
31.     if((usRegIndex + usNRegs) > REG_INPUT_SIZE)
    
32.     {
    
33.         return MB_ENOREG;
    
34.     }
    
35. 
    
36.     // 循环读取
    8 M  q0 ~* |/ V% ^
37.     while( usNRegs > 0 )
    
38.     {
    
39.         *pucRegBuffer++ = ( unsigned char )( REG_INPUT_BUF[usRegIndex] >> 8 );
    
40.         *pucRegBuffer++ = ( unsigned char )( REG_INPUT_BUF[usRegIndex] & 0xFF );
    
41.         usRegIndex++;
    0 S1 [- H' P- J4 {4 t3 o; W
42.         usNRegs--;
    
43.     }
    
44. 
    , o) l' D& n7 n2 G; {2 \
45.     // 模拟输入寄存器被改变
    2 a/ u2 @& ?; Q
46.     for(usRegIndex = 0; usRegIndex < REG_INPUT_SIZE; usRegIndex++)
    0 C  K- R( P4 q, w5 b# K0 D
47.     {
    
48.         REG_INPUT_BUF[usRegIndex]++;
    4 t1 ~4 r" `$ ^0 b' L# d2 a* q
49.     }
    
50. 
    - D( U5 N  O' Q) Z  V0 t
51.     return MB_ENOERR;
    # T( `, B1 v, t* R! \
52. }
    
53. 
    5 D7 e# |$ ^! E( U% L! \  x
54. /// CMD6、3、16
    ; c8 V' H7 ^5 D; W
55. eMBErrorCode eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs, eMBRegisterMode eMode )
    ! T* W7 ~' ^- N' n
56. {
    
57.     USHORT usRegIndex = usAddress - 1;  
    9 P1 L5 _6 f5 A
58. 
    0 q( I0 o# ]/ E5 g& T! ~, Z8 w
59.     // 非法检测
    ) Y( @2 {0 B9 J' K3 U' Q: Q! T
60.     if((usRegIndex + usNRegs) > REG_HOLD_SIZE)
    
61.     {
    * @: ?: A' {% x! {
62.         return MB_ENOREG;
    / q3 q; H1 N7 d, p# O! d, n
63.     }
    7 k" B( Q* \+ Z3 S7 ]& {+ }
64. 
    6 y# t7 k1 C: T
65.         // 写寄存器
    2 C1 F3 n- q+ `: V% m
66.     if(eMode == MB_REG_WRITE)
    
67.     {
    
68.         while( usNRegs > 0 )
    
69.         {
    ! i/ _6 ]5 q4 D4 p/ |4 A2 A
70.                         REG_HOLD_BUF[usRegIndex] = (pucRegBuffer[0] << 8) | pucRegBuffer[1];
    : M% J+ m; J. _/ F* d+ ]; c+ m' @
71.                         pucRegBuffer += 2;
    
72.             usRegIndex++;
    
73.             usNRegs--;
    , a. S2 ?8 R6 \7 I
74.         }
    . t" n* t  c# a, M+ @
75.     }
    
76.         
    : @0 h3 |( a: N# F# U/ E# v
77.         // 读寄存器
    
78.     else
    6 z& E0 L1 w" H) a0 I
79.     {
    ! n4 g: W6 \. T4 `0 O5 h
80.         while( usNRegs > 0 )
    
81.         {
    - t. J/ J6 g3 t: B7 |) ~
82.             *pucRegBuffer++ = ( unsigned char )( REG_HOLD_BUF[usRegIndex] >> 8 );
    + Y7 C! B+ |; M
83.             *pucRegBuffer++ = ( unsigned char )( REG_HOLD_BUF[usRegIndex] & 0xFF );
    / g. q& U# Y1 |, ^2 u7 _& m
84.             usRegIndex++;
    
85.             usNRegs--;
    
86.         }
    
87.     }
    ! ~8 s& ]9 F/ I1 o' _$ k. n
88. 
    ' B( e$ e- ]- G3 D
89.     return MB_ENOERR;
    - G- o5 O* Q& G
90. }
    
91. 
    # T3 p; B4 |6 m, p6 y: i
92. /// CMD1、5、15
    
93. eMBErrorCode eMBRegCoilsCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNCoils, eMBRegisterMode eMode )
    6 b  S1 K- O' G% G% _3 B/ @8 u' Q
94. {
    
95.     USHORT usRegIndex   = usAddress - 1;
    
96.     USHORT usCoilGroups = ((usNCoils - 1) / 8 + 1);
    
97.     UCHAR  ucStatus     = 0;
    
98.     UCHAR  ucBits       = 0;
    
99.     UCHAR  ucDisp       = 0;
    
100. 
     
101.     // 非法检测
     
102.     if((usRegIndex + usNCoils) > REG_COILS_SIZE)
     
103.     {
     
104.         return MB_ENOREG;
     8 X- Z2 e" W5 y1 M
105.     }
       h( s! k7 d' {" g9 k6 y
106. 
     
107.     // 写线圈
     
108.     if(eMode == MB_REG_WRITE)
     6 j" j4 q6 s  y( y
109.     {
     
110.         while(usCoilGroups--)
     . L3 r3 g& |- o
111.         {
     
112.             ucStatus = *pucRegBuffer++;
     
113.             ucBits   = 8;
     0 U- }7 s' d' k2 @; Q% H$ T4 L# {2 b
114.             while((usNCoils--) != 0 && (ucBits--) != 0)
     
115.             {
     ! K6 Z  `0 v- ^, l  S& k
116.                 REG_COILS_BUF[usRegIndex++] = ucStatus & 0X01;
     
117.                 ucStatus >>= 1;
     
118.             }
     , K. h/ z# A6 z) G" p* P
119.         }
     $ U3 M4 z5 Q$ m3 H
120.     }
     
121. 
     
122.     // 读线圈
     
123.     else
     
124.     {
     : b4 t( m; W; n( t+ E
125.         while(usCoilGroups--)
     ! I! t" c# c9 w& p0 D1 C
126.         {
     
127.             ucDisp = 0;
     
128.             ucBits = 8;
     + c$ S4 H- p  D: p
129.             while((usNCoils--) != 0 && (ucBits--) != 0)
     
130.             {
     
131.                 ucStatus |= (REG_COILS_BUF[usRegIndex++] << (ucDisp++));
     
132.             }
     
133.             *pucRegBuffer++ = ucStatus;
     
134.         }
     9 H. \4 h* b" [4 X0 r
135.     }
     
136.     return MB_ENOERR;
     5 l" Q3 q! R* S) ?  ~: u7 L, c' p
137. }
     
138. 
     
139. 
       `) t  C) l/ S! r, w2 _/ b5 ~0 P
140. /// CMD4
     4 g7 w/ @3 h) R
141. eMBErrorCode eMBRegDiscreteCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNDiscrete )
     
142. {
     1 r( E3 g9 h5 \( @4 r  z1 M& z
143.     USHORT usRegIndex   = usAddress - 1;
     
144.     USHORT usCoilGroups = ((usNDiscrete - 1) / 8 + 1);
     
145.     UCHAR  ucStatus     = 0;
     
146.     UCHAR  ucBits       = 0;
     ; \+ `1 E2 w4 h( a
147.     UCHAR  ucDisp       = 0;
     
148. 
     ) o! V- x/ s; t* z3 |: U7 G
149.     // 非法检测
     
150.     if((usRegIndex + usNDiscrete) > REG_DISC_SIZE)
     
151.     {
     + V: P* R3 D% `0 G
152.         return MB_ENOREG;
     
153.     }
     8 K% L8 [/ W6 k" j( C3 E; A# p4 T# O) M
154. 
     
155.         // 读离散输入
     9 z) t# w; K3 Y3 v5 _9 T
156.         while(usCoilGroups--)
     
157.         {
     
158.                 ucDisp = 0;
     + S7 d% K* Z& q9 l( U7 W
159.                 ucBits = 8;
     
160.                 while((usNDiscrete--) != 0 && (ucBits--) != 0)
     
161.                 {
     ) R6 F, [  Q9 {4 m8 q
162.                         if(REG_DISC_BUF[usRegIndex])
     
163.                         {
     / {# b; C! n5 T9 J$ f
164.                                 ucStatus |= (1 << ucDisp);
     . c; N/ S6 L" g
165.                         }
     7 o5 `' C4 p* n1 H& j
166.                         ucDisp++;
     
167.                 }
     % {( \9 j+ N* \/ }
168.                 *pucRegBuffer++ = ucStatus;
     
169.         }
     
170. 
     1 n) ^4 m& B- K  P4 H
171.     // 模拟改变
     + u7 J0 |; L. J, E% H$ z
172.     for(usRegIndex = 0; usRegIndex < REG_DISC_SIZE; usRegIndex++)
     / r: n! G( x1 p) j2 e, o9 b. f% d
173.     {
     : E* l3 d  a" H/ M* [% Z
174.         REG_DISC_BUF[usRegIndex] = !REG_DISC_BUF[usRegIndex];
       Q: ?6 d2 T9 ], I) h
175.     }
     $ Q6 t5 P; }' S" ^
176. 
     - r1 V4 g2 Z7 s; `& O$ x
177.     return MB_ENOERR;
     
178. }

复制代码

6 M4 |. }4 D- U1 ?2 U主函数
( s# ]' f3 T" z

1. int main(void)
   
2. {
   7 y# t  R( Q4 q1 a, ]* y1 Y! \
3.     HAL_Init();
   ; Q1 ^$ r! a* ~2 _3 m( h
4.     SystemClock_Config();
   , P+ B+ C: r( n: H( J" k0 L
5.     MX_GPIO_Init();
   : k. g; F0 v( c" `4 M. q' v" T
6.     eMBInit(MB_RTU, 0x01, 0, 9600, MB_PAR_ODD);                // 初始化modbus为RTU方式，波特率9600，奇校验
   
7.     eMBEnable();                                                                        // 使能modbus协议栈
   6 V, [# k! I' o, T6 t3 l
8. 
   
9.     for( ;; )
   , B* ^8 h# {8 K, @( X5 g
10.     {
    7 ?. F- n+ W* _7 m- C* @
11.         eMBPoll();                                                                        // 轮训查询
    
12.     }
    
13. }

复制代码

" ]1 @$ T: `" L/ q; h# L& Z移植测试



) s+ M. H. J2 E' h9 Y7 vends…
) q) }# s$ [) ]# c) B2 g8 K
$ r4 E3 ~+ Y2 A! P+ D5 ^6 Y

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

使用天空星主板，STM32F407VETR的芯片，配置完成之后，修改USART1为USART3，修改了TIM4的预分频为4199，连接上串口之后，PC发数据没有反馈，这个大概率是什么原因引起的。

Mxn 发表于 2026-6-30 14:14
使用天空星主板，STM32F407VETR的芯片，配置完成之后，修改USART1为USART3，修改了TIM4的预分频为4199 ...

[md]问题找出来了，接收第一个字节正常进入到了中断，但是第二个字节直接进入了

if(__HAL_UART_GET_FLAG(&huart3, UART_FLAG_TXE))// 发送为空中断标记被置位

导致程序认为接收已经结束，然后通知modbus可以发送数据，但是此时的标志位 不是STATE_RX_IDLE，而是STATE_RX_RCV，所以程序被 assert( eRcvState == STATE_RX_IDLE ) 杀死了，

修改：在使用中断的时候，清楚以下标志位

void

vMBPortSerialEnable( BOOL xRxEnable, BOOL xTxEnable )

{

if(xRxEnable)

{

MODBUS_RX_EN();

__HAL_UART_ENABLE_IT(&huart3, UART_IT_RXNE);                // 使能接收非空中断

}

else

{

__HAL_UART_DISABLE_IT(&huart3, UART_IT_RXNE);                // 禁能接收非空中断

}

if(xTxEnable)

{

MODBUS_TX_EN();

__HAL_UART_ENABLE_IT(&huart3, UART_IT_TXE);                  // 使能发送为空中断

}

else

{

__HAL_UART_DISABLE_IT(&huart3, UART_IT_TXE);                // 禁能发送为空中断

__HAL_UART_CLEAR_FLAG(&huart3, UART_FLAG_TXE);              // 新增：清除残留标志

} }

你好，可以分享一下工程源码吗？