modbus命令码表：



FreeModbus文件说明
      解压freemodbus文件后打开，我们需要demo目录下的BARE，该目录下的代码是空的，STM32移植工作基本就是修改：portserial.c、porttimer.c、port.h这三个文件。
$ w' u0 g9 g$ _1 [

; l& J% a4 t- {5 T8 T% ?      mobus文件夹就是完整的源码，包含rtu、ascii、tcp：

3 L! s& `$ {& M# j/ Y& O" W5 ?

      我为了移植时在keil添加源文件和头文件方便，就把modbus所有的头文件和源文件放到了一个文件夹下，并创建了一个port.c文件，用于编写modbus所必需的回调处理函数：
5 Y) O, ^+ `! W8 z' x& |
: m% a# o# w7 {1 [
3 h* l; ]. H, ~2 M4 {  K
STM32CUBEMX配置
时钟配置，设置主频工作在72MHz下：

8 b; c9 q  h  A+ Y, e
8 i6 `) `9 R) X, y9 g8 g
$ B) @" @6 N7 E; t# g配置串口1，这里随便配置就行，在modbus移植过程中还会对串口重新初始化：
( b# F7 p$ T) f  O2 S


配置定时器4，用于3.5个字符的定时检测，这里随便配置就行，在modbus移植过程中还会对定时器重新初始化：


7 A6 K5 j1 f2 v( q) V7 c/ l  [& t
7 w8 k/ {$ X$ f中断配置，这里注意，串口的优先级是要比定时器优先高的：
* c+ y% L4 D( E
& c' V# Z2 z( y/ L$ T
% h5 ^8 p* v4 l8 ]2 l取消掉自动生成中断服务程序，在移植过程中我们要自己编写串口和定时器的中断服务程序：
2 z2 }* `3 n- f4 F" {
  S: e" p% A* i5 n

移植代码修改
1 {/ z5 \8 w$ t2 m生成代码后将modbus放到工程目录下：



打开keil工程添加modbus源码：

6 @2 L1 m  T3 E/ g8 m  {
+ v+ w% F8 m' r" @# Q3 }2 z; S
添加包含头文件：


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

3 ^  T2 J0 _) U) o- g

1. BOOL
   " P$ {7 B# K0 j& G) ~' U. ^
2. xMBPortTimersInit( USHORT usTim1Timerout50us )
   
3. {
   0 o. a8 }- p8 t, w/ H" n4 a
4.     TIM_ClockConfigTypeDef sClockSourceConfig = {0};
   
5.     TIM_MasterConfigTypeDef sMasterConfig = {0};
   7 |: K% M  {9 ~, k
6. 
   
7.     htim4.Instance = TIM4;
   
8.     htim4.Init.Prescaler = 3599;                                                                // 50us记一次数
   6 K6 C( Y, G7 T( S; @. N8 l" t
9.     htim4.Init.CounterMode = TIM_COUNTERMODE_UP;
   
10.     htim4.Init.Period = usTim1Timerout50us - 1;                                        // usTim1Timerout50us * 50即为定时器溢出时间
    
11.     htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    
12.     htim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
    
13.     if (HAL_TIM_Base_Init(&htim4) != HAL_OK)
    
14.     {
    
15.         return FALSE;
    
16.     }
    
17.     sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
    % C3 Z4 g0 F, Q$ M8 X3 b: z
18.     if (HAL_TIM_ConfigClockSource(&htim4, &sClockSourceConfig) != HAL_OK)
    , B2 R; d' o6 A# K/ s9 D9 _
19.     {
    
20.         return FALSE;
    , p' Q7 u3 f$ c6 y: q: x) S' t5 ~9 L
21.     }
    2 N/ ?* I- T" L; H
22.     sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
    
23.     sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
    
24.     if (HAL_TIMEx_MasterConfigSynchronization(&htim4, &sMasterConfig) != HAL_OK)
    # ?4 W# N. V( }
25.     {
    
26.         return FALSE;
    
27.     }
    
28. 
    
29.     __HAL_TIM_ENABLE_IT(&htim4, TIM_IT_UPDATE);                                        // 使能定时器更新中断
    " L; i4 [# s) W& U1 o
30.     return TRUE;
    ( B- T2 y- G' H/ k$ H8 F5 q: E
31. }
    
32. 
    
33. inline void
    3 Z; k- I* [! W% d* v
34. vMBPortTimersEnable(  )
    
35. {
    ) P  D0 k, U4 C" f9 D+ ?+ y  b2 v
36.     __HAL_TIM_SET_COUNTER(&htim4, 0);                // 清空计数器
    
37.     __HAL_TIM_ENABLE(&htim4);                                // 使能定时器
    4 U& v- K- t" X4 i# C5 T
38. }
    
39. 
    2 T! \6 d/ E! q2 H4 P0 a+ S/ |/ l
40. inline void
    5 N* Y$ i3 A2 L4 C+ J7 l6 b
41. vMBPortTimersDisable(  )
    
42. {
    + V6 C0 l1 x3 s7 f- W5 q
43.     __HAL_TIM_DISABLE(&htim4);                                // 禁能定时器
    
44. }
    ' d  ~! t4 g. x) s& r" w
45. 
    & }0 m' p( e9 i; K- a, J# M  [
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.
    5 H: t  |  k8 T: M1 \, M
49. */
    
50. static void prvvTIMERExpiredISR( void )
    
51. {
    6 c0 ?: U6 M2 G5 g  d
52.     ( void )pxMBPortCBTimerExpired(  );
    
53. }
    
54. 
    
55. /// 定时器4中断服务程序
    $ Q! B1 ?3 I$ i$ {4 L8 o5 h: l3 ?
56. void TIM4_IRQHandler(void)
    9 W/ u: Y. O' i; N: c: n+ @
57. {
    
58.     if(__HAL_TIM_GET_FLAG(&htim4, TIM_FLAG_UPDATE))                        // 更新中断标记被置位
    
59.     {
    
60.         __HAL_TIM_CLEAR_FLAG(&htim4, TIM_FLAG_UPDATE);                // 清除中断标记
    7 n5 N9 v  a  H, B1 w! @: G( [
61.         prvvTIMERExpiredISR();                                                                // 通知modbus3.5个字符等待时间到
    
62.     }
    
63. }
    
64. 
    
65. 
    ; A% f- B7 ?& P  H3 V% [& |

复制代码

修改modbus串口初始化源代码portserial.c文件
) X7 A: X* j; J: l4 r         ~~~~~~~~        在该文件中实现串口1的中断服务程序，prvvUARTTxReadyISR和prvvUARTRxISR函数需要填写进中断服务程序，前者得到作用为通知modbus协议栈串口已经空闲可以发送数据了，后者的作用为通知modbus串口1有数据到达，修改后的代码如下：

1. /*
   1 Y0 j7 t; E, Z
2. * FreeModbus Libary: BARE Port
   + Q; J( A- x! \$ i
3. * Copyright (C) 2006 Christian Walter <<a href="mailto:wolti@sil.at">wolti@sil.at</a>>
   
4. *
   & Q6 [3 ~& C0 N* v- r& }: V
5. * This library is free software; you can redistribute it and/or
   
6. * modify it under the terms of the GNU Lesser General Public
   
7. * License as published by the Free Software Foundation; either
   2 k! y! g/ v& D. m9 ?
8. * version 2.1 of the License, or (at your option) any later version.
   
9. *
   
10. * This library is distributed in the hope that it will be useful,
    0 X4 G& X! F- B1 z
11. * but WITHOUT ANY WARRANTY; without even the implied warranty of
    2 a; b9 ~/ [' E/ u! b9 a! F: t
12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    
13. * Lesser General Public License for more details.
    & m) R1 b( P* U1 k& E
14. *
    
15. * You should have received a copy of the GNU Lesser General Public
    : P2 ~9 G- |9 }7 a+ k5 s$ B
16. * License along with this library; if not, write to the Free Software
    
17. * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
    
18. *
    
19. * File: $Id$
    / ^3 [& H3 Z5 w, {
20. */
    1 H! n7 w; \9 A- f# @( P
21. 
    
22. #include "port.h"
    
23. #include "usart.h"
    
24. 
    
25. /* ----------------------- Modbus includes ----------------------------------*/
    
26. #include "mb.h"
    - ^9 u# j' }8 S: {) g
27. #include "mbport.h"
    3 k; b' Q5 C6 P( Y0 w
28. 
    6 E0 P; \$ l2 Z4 o& ?9 f. D2 n: ^/ k
29. /* ----------------------- static functions ---------------------------------*/
    6 C7 e# p2 q( @3 z' [9 i
30. static void prvvUARTTxReadyISR( void );
    
31. static void prvvUARTRxISR( void );
    . ]0 V; j) R; l; R5 c
32. 
    
33. /* ----------------------- Start implementation -----------------------------*/
    * }0 G* a5 \. _& k+ O0 q. S
34. void
    
35. vMBPortSerialEnable( BOOL xRxEnable, BOOL xTxEnable )
    8 o* F% m+ q9 {5 K0 J- X1 k5 |# ~) V
36. {
    . s$ i9 B, Q; J9 f: i
37.     if(xRxEnable)
    1 d# b; l9 f/ ?3 G
38.     {
    
39.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_RXNE);                // 使能接收非空中断
    
40.     }
    / b& i4 a. e) e" H( f$ w! K
41.     else
    * |& N4 C/ m4 k! x. y. C1 C% A
42.     {
    / G1 S' x. C( J% w  N: u/ m8 o) f
43.         __HAL_UART_DISABLE_IT(&huart1, UART_IT_RXNE);                // 禁能接收非空中断
    
44.     }
    
45. 
    
46.     if(xTxEnable)
    5 ^1 ?7 I7 {% `4 v2 T: ^% T' j
47.     {
    
48.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_TXE);                        // 使能发送为空中断
    1 a. s9 A" e4 q3 P3 V4 W! ]
49.     }
    ; r, I  D% \! j" T/ V0 O& @# Z
50.     else
    
51.     {
    
52.         __HAL_UART_DISABLE_IT(&huart1, UART_IT_TXE);                // 禁能发送为空中断
    # K+ ]& O: C& Y% B0 l- h
53.     }
    ! `& h9 g$ P. u9 M8 |# J
54. }
    
55. 
    4 K  E9 J* T) ?5 V& `2 J
56. BOOL
    7 ~" t7 S. k- K: Z, H1 k, |
57. xMBPortSerialInit( UCHAR ucPORT, ULONG ulBaudRate, UCHAR ucDataBits, eMBParity eParity )
    $ \, K5 q6 ?* T& f
58. {
    
59.     huart1.Instance = USART1;
    
60.     huart1.Init.BaudRate = ulBaudRate;
    - S" ]: B$ F1 o9 \( G
61.     huart1.Init.StopBits = UART_STOPBITS_1;
    
62.     huart1.Init.Mode = UART_MODE_TX_RX;
    9 m* Y2 w5 e; V3 \
63.     huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    
64.     huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    
65. 
    $ w, v1 x0 x9 h  ]3 {# h6 S8 n
66.     switch(eParity)
    
67.     {
    # _9 U* v$ A; M  p9 k2 e# I
68.         // 奇校验
    
69.     case MB_PAR_ODD:
    / e/ n5 H3 f" S, S, |4 W* P3 s: T
70.         huart1.Init.Parity = UART_PARITY_ODD;
    
71.         huart1.Init.WordLength = UART_WORDLENGTH_9B;                        // 带奇偶校验数据位为9bits
    
72.         break;
    . z: C, G6 d. Q" ?* a( ]( I4 b
73.         
      |* p0 V/ m% n. r
74.         // 偶校验
    ( G1 f/ N6 O* Q& d* ]
75.     case MB_PAR_EVEN:
    # N) Y6 j2 h1 l3 S+ z/ N, Z2 k
76.         huart1.Init.Parity = UART_PARITY_EVEN;
    
77.         huart1.Init.WordLength = UART_WORDLENGTH_9B;                        // 带奇偶校验数据位为9bits
    3 s" K. z$ _; R8 {* L9 R. A
78.         break;
    
79.         
    3 P$ E& r: Z1 r& [0 P8 s4 p  ?8 {
80.         // 无校验
    
81.     default:
    
82.         huart1.Init.Parity = UART_PARITY_NONE;
    
83.         huart1.Init.WordLength = UART_WORDLENGTH_8B;                        // 无奇偶校验数据位为8bits
    
84.         break;
    + j! I+ e( s- n
85.     }
    5 n5 R; d7 @( D! z, g, P( ]( b# F' V
86.     return HAL_UART_Init(&huart1) == HAL_OK ? TRUE : FALSE;
    
87. }
    . r: r7 L% N# K3 c
88. 
    
89. BOOL
    4 Q% o# @" N& q) p8 Q
90. xMBPortSerialPutByte( CHAR ucByte )
    
91. {
    ! j' m, R% O! B7 z' ~7 `
92.     USART1->DR = ucByte;
    
93.     return TRUE;
    2 ^* J; |# I- ?# o8 }' L
94. }
    
95. 
    * Z- u: N) A9 j3 V* A
96. BOOL
    6 g1 e! u/ Q* s; w
97. xMBPortSerialGetByte( CHAR * pucByte )
    + d3 y* h- \* a8 Z, I) ?
98. {
    * W0 ?. u& |9 W' a# R0 g
99.     *pucByte = (USART1->DR & (uint16_t)0x00FF);
    + V* r- E4 k2 s
100.         return TRUE;
     
101. }
     
102. 
       y7 R9 r! z4 H0 X3 v7 @8 y& C
103. /* Create an interrupt handler for the transmit buffer empty interrupt
     1 Y. S4 e5 x: a+ W
104. * (or an equivalent) for your target processor. This function should then
       z1 l( j0 v9 m( B$ A1 A4 j+ E+ V: S3 b1 C
105. * call pxMBFrameCBTransmitterEmpty( ) which tells the protocol stack that
     " |5 ?  O6 P% o" ]# t7 w: b
106. * a new character can be sent. The protocol stack will then call
     
107. * xMBPortSerialPutByte( ) to send the character.
     
108. */
     
109. static void prvvUARTTxReadyISR( void )
     
110. {
     
111.     pxMBFrameCBTransmitterEmpty(  );
     
112. }
     
113. 
     ! n; x4 l( N# S2 t" _
114. /* Create an interrupt handler for the receive interrupt for your target
     
115. * processor. This function should then call pxMBFrameCBByteReceived( ). The
     6 C% x+ {. x7 G: J6 ~5 c+ u% u$ s
116. * protocol stack will then call xMBPortSerialGetByte( ) to retrieve the
     , r* ]& g7 S& b* J% R7 o) f
117. * character.
     + e! }5 J1 w# x* Z! U
118. */
     
119. static void prvvUARTRxISR( void )
     - U8 d% P5 D3 w, o
120. {
     1 W9 [' A9 u- Z/ ]' ~5 t
121.     pxMBFrameCBByteReceived(  );
     ) t  i% \+ B1 {; H2 f& o, S
122. }
     " Z5 d& Z% h' M$ Q' a2 ~* p" u
123. 
     % R! w( @, [- @' e9 O! z/ w
124. void USART1_IRQHandler(void)
     9 k) {9 r* H: k  C- }7 H3 Q
125. {
     9 i0 c, r3 A* h8 a4 o
126.     if(__HAL_UART_GET_FLAG(&huart1, UART_FLAG_RXNE))                        // 接收非空中断标记被置位
     
127.     {
       L! d  u/ g9 a) F  D$ A+ ]# j
128.         __HAL_UART_CLEAR_FLAG(&huart1, UART_FLAG_RXNE);                        // 清除中断标记
     + a# r& y  O3 [0 I7 n
129.         prvvUARTRxISR();                                                                                // 通知modbus有数据到达
     ) O5 _- w" M* C! s  M) |
130.     }
     
131. 
     ; B, K4 W4 f1 s# }+ T2 c
132.     if(__HAL_UART_GET_FLAG(&huart1, UART_FLAG_TXE))                                // 发送为空中断标记被置位
     
133.     {
     
134.         __HAL_UART_CLEAR_FLAG(&huart1, UART_FLAG_TXE);                        // 清除中断标记
     
135.         prvvUARTTxReadyISR();                                                                        // 通知modbus数据可以发松
       Q9 J! k6 M! c9 B
136.     }
     
137. }

复制代码

) P6 G2 b9 \/ X注意一点，一般如果使用了485芯片的话，那么同一时刻只能接收或者发送，可以将函数vMBPortSerialEnable修改成这样：
  e* N+ q* Z  I2 u2 z

1. void
   
2. vMBPortSerialEnable( BOOL xRxEnable, BOOL xTxEnable )
   
3. {
   , j( ]* p% |4 N0 \1 S3 b! Y( M
4.     if(xRxEnable)
   ( U6 F: W# c2 U6 Q* [: u
5.     {
   ; G" {# D  ~7 _+ n* [
6.             //
   - a% }! u7 ~8 o* }  _
7.         // 在此处将485芯片设置为接收模式
   ) _# E* y5 w# |- J& r2 V
8.         //
     O+ c, U7 p3 W* E
9.                 /* do something */
   
10.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_RXNE);                // 使能接收非空中断
    
11.     }
    3 X7 \% e6 v1 _, {
12.     else
    
13.     {
    , T& r0 w# d$ L) o- ~( x
14.         __HAL_UART_DISABLE_IT(&huart1, UART_IT_RXNE);                // 禁能接收非空中断
    
15.     }
    4 _/ A5 a" s/ }$ e5 M/ b
16. 
    # n, Y1 X- Q5 s! Y1 S
17.     if(xTxEnable)
    - t6 U' W2 K* N3 j7 t
18.     {
    " ~- o* N; b/ q# n6 ?. K' @
19.             //
    
20.         // 在此处将485芯片设置为发送模式
    
21.         //
    
22.         /* do something */
    " [: Y, f  s7 v* z/ Y
23.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_TXE);                        // 使能发送为空中断
    " b( t# p  e, d
24.     }
    
25.     else
    8 ^! U" w2 l2 ~/ T9 u8 g8 p
26.     {
    , ^# F9 I0 Y9 N" N3 Y( W) n# B
27.         __HAL_UART_DISABLE_IT(&huart1, UART_IT_TXE);                // 禁能发送为空中断
    
28.     }
    + e& \# {( Y; _" d
29. }

复制代码

7 S% P  G) C0 F* M8 r7 \编写modbus命令处理回调函数port.c文件
本例程只实现了读取输入寄存器和保持寄存器的功能，详细代码如下：

- K- \3 U# X& w& A, P2 o: n! I0 Y

1. #include "mb.h"
   $ ]% x' C: ^! b
2. #include "mbport.h"
   2 Y6 i2 q) i: R+ o3 Y
3. 
   ( _/ t( y& K$ ~1 a
4. 
   
5. // 十路输入寄存器
   ! P5 w+ a2 A4 {: z% [
6. #define REG_INPUT_SIZE  10
   8 b& n8 I# r; }  e
7. uint16_t REG_INPUT_BUF[REG_INPUT_SIZE];
   2 e( A. m- ~4 H) K7 D' D& ^, ]
8. 
     W) L  Z' |6 L
9. 
   
10. // 十路保持寄存器
    ' Q: U0 R+ l0 l2 l$ \. p
11. #define REG_HOLD_SIZE   10
    1 U* |. |( g' b* J$ F8 q
12. uint16_t REG_HOLD_BUF[REG_HOLD_SIZE];
    ; T' @3 {! a. i0 H
13. 
    
14. 
    
15. // 十路线圈
    
16. #define REG_COILS_SIZE 10
    8 c4 s. `( N3 q! \8 S
17. uint8_t REG_COILS_BUF[REG_COILS_SIZE];
    
18. 
    
19. 
    7 Z, `+ H2 ^" A" H3 }) Z$ Z2 @" j
20. // 十路离散量
    ' Q  ]9 ]9 p% q; e, x
21. #define REG_DISC_SIZE  10
    
22. uint8_t REG_DISC_BUF[10];
    
23. 
    . d2 n: E6 Z6 ?% g6 G9 w* k8 C
24. 
    
25. /// CMD4
    9 T6 B" S& Q2 l0 K
26. eMBErrorCode eMBRegInputCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs )
    & z+ |; t- X6 u7 ?  z  i
27. {
    
28.     USHORT usRegIndex = usAddress - 1;
    0 d+ H' G, ^1 ^6 A1 ~
29. 
    ) ^' q1 ~2 Y3 t# Q; g9 b1 e
30.     // 非法检测
    : i  A" _2 }* a; t  L
31.     if((usRegIndex + usNRegs) > REG_INPUT_SIZE)
    
32.     {
    % V3 s9 v& N% w5 B
33.         return MB_ENOREG;
      g  M) ?6 J2 u6 q
34.     }
    
35. 
    / p% f. v6 w5 q9 |4 b; y
36.     // 循环读取
    0 b- l& I) ?6 \! f; S+ i) a  T8 z
37.     while( usNRegs > 0 )
    
38.     {
    
39.         *pucRegBuffer++ = ( unsigned char )( REG_INPUT_BUF[usRegIndex] >> 8 );
    8 c' p! b- L) T5 z* j
40.         *pucRegBuffer++ = ( unsigned char )( REG_INPUT_BUF[usRegIndex] & 0xFF );
    
41.         usRegIndex++;
    
42.         usNRegs--;
    % p" u' V6 W, t1 b5 f- ~3 g
43.     }
    
44. 
    
45.     // 模拟输入寄存器被改变
    
46.     for(usRegIndex = 0; usRegIndex < REG_INPUT_SIZE; usRegIndex++)
    " _& w4 t- {" |, M& b4 o  M
47.     {
    - Z3 q+ \8 g6 t3 H' A
48.         REG_INPUT_BUF[usRegIndex]++;
    1 u) S# w1 ]; Q- X" b
49.     }
    0 C0 p' H: M, R
50. 
    
51.     return MB_ENOERR;
    
52. }
    
53. 
      A& ^! j4 C+ f  n0 P; t( a: I
54. /// CMD6、3、16
    
55. eMBErrorCode eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs, eMBRegisterMode eMode )
    5 p# S# p" S3 Q  v5 Q
56. {
    
57.     USHORT usRegIndex = usAddress - 1;  
    " K: o. t; {( v( |& i; L
58. 
    . O. m$ c9 W; T! z
59.     // 非法检测
    # n# p2 z: l* }; M0 U/ F, e- P
60.     if((usRegIndex + usNRegs) > REG_HOLD_SIZE)
    6 t0 Q: q6 h' |6 z' s+ ^
61.     {
    
62.         return MB_ENOREG;
    * U7 D4 ~* [0 V- R* R
63.     }
    
64. 
    
65.         // 写寄存器
    
66.     if(eMode == MB_REG_WRITE)
    
67.     {
    
68.         while( usNRegs > 0 )
    
69.         {
    
70.                         REG_HOLD_BUF[usRegIndex] = (pucRegBuffer[0] << 8) | pucRegBuffer[1];
    , w3 o( a0 M3 M) ~& h
71.                         pucRegBuffer += 2;
    9 d' M3 L. L6 _* l+ m7 e
72.             usRegIndex++;
    7 C8 Q3 A7 @4 o4 z
73.             usNRegs--;
    
74.         }
    / j  A/ v8 L7 ]9 W3 H# k; o
75.     }
    
76.         
    7 B; a$ y$ G3 M7 K4 x4 G. V* Z. m, @
77.         // 读寄存器
    
78.     else
    
79.     {
    ' A7 \+ ~- }- b( Z, u* T8 g
80.         while( usNRegs > 0 )
    - m( p9 l  n! y  ]3 w6 D4 w% o
81.         {
    
82.             *pucRegBuffer++ = ( unsigned char )( REG_HOLD_BUF[usRegIndex] >> 8 );
    
83.             *pucRegBuffer++ = ( unsigned char )( REG_HOLD_BUF[usRegIndex] & 0xFF );
    
84.             usRegIndex++;
    
85.             usNRegs--;
    
86.         }
    
87.     }
    
88. 
    
89.     return MB_ENOERR;
    
90. }
    
91. 
    8 u/ S  s3 c% K- P3 o7 N
92. /// CMD1、5、15
    & F6 B, Y/ }0 l- \" c( [4 R; R
93. eMBErrorCode eMBRegCoilsCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNCoils, eMBRegisterMode eMode )
    5 F' i, l9 w2 D% J1 l, n# D3 f
94. {
    # W0 s" U0 }  q
95.     USHORT usRegIndex   = usAddress - 1;
    0 p% ]' F' P2 X
96.     USHORT usCoilGroups = ((usNCoils - 1) / 8 + 1);
    
97.     UCHAR  ucStatus     = 0;
    0 A, v/ S1 {2 ]% d
98.     UCHAR  ucBits       = 0;
    # T4 g2 p9 B) ~0 c8 X# W% }9 b
99.     UCHAR  ucDisp       = 0;
    
100. 
     & z1 S9 {) W4 ?# A  i0 s
101.     // 非法检测
     
102.     if((usRegIndex + usNCoils) > REG_COILS_SIZE)
     5 \* d, g$ N4 o  g- U
103.     {
     
104.         return MB_ENOREG;
     + Z  x) H: y8 ]& P# m$ u5 O4 a& M  b: l
105.     }
     
106. 
     7 P5 e8 h# w0 S: E
107.     // 写线圈
     
108.     if(eMode == MB_REG_WRITE)
     , L' G  A9 T- H# K
109.     {
     , b. b$ g# r( Z+ l$ V
110.         while(usCoilGroups--)
     + ^- k1 i& @$ t- g2 n- L% _
111.         {
     
112.             ucStatus = *pucRegBuffer++;
     
113.             ucBits   = 8;
     ) ]. T6 J0 C) C4 P( _( u; v9 R
114.             while((usNCoils--) != 0 && (ucBits--) != 0)
     ! n: s7 B0 A  C" g( P. k
115.             {
     8 `; V  I( Q, S/ M
116.                 REG_COILS_BUF[usRegIndex++] = ucStatus & 0X01;
     ! q. g6 W/ r& d7 n
117.                 ucStatus >>= 1;
     ; ~7 v+ f1 }4 t/ U+ B8 f$ W
118.             }
     
119.         }
     
120.     }
     
121. 
     
122.     // 读线圈
     2 z% U% b9 T! K2 R9 k- k' G# m
123.     else
     ! C; }4 P5 X' L0 @
124.     {
     : a: [& P8 ]& B
125.         while(usCoilGroups--)
     
126.         {
     7 N- M  h' k3 r8 K! h* `
127.             ucDisp = 0;
     
128.             ucBits = 8;
     0 ]% P9 |$ c' h2 D2 o! I7 s
129.             while((usNCoils--) != 0 && (ucBits--) != 0)
     # b$ g4 ?0 {( z
130.             {
     
131.                 ucStatus |= (REG_COILS_BUF[usRegIndex++] << (ucDisp++));
     8 X/ C! y- }; w; I/ G$ M
132.             }
     " }) ~- S  M" y  a4 l2 e
133.             *pucRegBuffer++ = ucStatus;
     ! v4 K1 w0 e. `' d/ y# H' d$ K
134.         }
     
135.     }
     4 q# o; G0 I3 I' g9 x
136.     return MB_ENOERR;
     
137. }
     
138. 
     
139. 
     & s) \6 g8 }6 Z; Y
140. /// CMD4
     8 u5 f/ L0 W6 ?. ~8 O' z
141. eMBErrorCode eMBRegDiscreteCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNDiscrete )
     
142. {
     6 O! v- W$ a$ j; k; e7 o( w! q( a" i
143.     USHORT usRegIndex   = usAddress - 1;
     
144.     USHORT usCoilGroups = ((usNDiscrete - 1) / 8 + 1);
     
145.     UCHAR  ucStatus     = 0;
     % ~9 r  [$ E/ j7 U, ?
146.     UCHAR  ucBits       = 0;
     
147.     UCHAR  ucDisp       = 0;
     
148. 
     
149.     // 非法检测
     
150.     if((usRegIndex + usNDiscrete) > REG_DISC_SIZE)
     
151.     {
     
152.         return MB_ENOREG;
     
153.     }
     & Q/ u+ D) Q" m0 E6 O  B
154. 
     
155.         // 读离散输入
     ; E# [' {" V0 [7 E
156.         while(usCoilGroups--)
     7 M. z# D1 C7 |, l* E" c
157.         {
     7 r( S# E4 W1 O" N0 n
158.                 ucDisp = 0;
     
159.                 ucBits = 8;
     
160.                 while((usNDiscrete--) != 0 && (ucBits--) != 0)
     
161.                 {
     5 r1 J5 F) e& J/ {0 Q+ r6 g
162.                         if(REG_DISC_BUF[usRegIndex])
     5 c6 f% K8 y2 A0 i
163.                         {
     
164.                                 ucStatus |= (1 << ucDisp);
     ( E5 Y, W* A; ~% q
165.                         }
     & A8 j2 p2 l: y4 X0 \7 F. W
166.                         ucDisp++;
     
167.                 }
     + @2 r5 o0 ?1 p9 }; t
168.                 *pucRegBuffer++ = ucStatus;
     
169.         }
     
170. 
     
171.     // 模拟改变
     - U! R* G& P- t5 C6 j9 m
172.     for(usRegIndex = 0; usRegIndex < REG_DISC_SIZE; usRegIndex++)
     5 U  W" q- X9 f  C$ [
173.     {
     & e  \9 I, M  O& n- s, {* y
174.         REG_DISC_BUF[usRegIndex] = !REG_DISC_BUF[usRegIndex];
     
175.     }
     ' V! `% \4 L" c+ I0 [3 ^  W3 h
176. 
     , M& W* z: C( Y6 f5 H
177.     return MB_ENOERR;
     
178. }

复制代码

0 v4 H: N& d$ U- ]: Z. o主函数
  z$ i5 e: T5 U$ v: Y

1. int main(void)
   
2. {
   $ o" A: X& z: ?: l+ K  i
3.     HAL_Init();
   9 _* n. m: H7 {; k8 K0 ?& o7 g1 X
4.     SystemClock_Config();
   0 t. j5 ]& |! P: F$ m, i
5.     MX_GPIO_Init();
   % _0 J8 I  K' d% X5 v
6.     eMBInit(MB_RTU, 0x01, 0, 9600, MB_PAR_ODD);                // 初始化modbus为RTU方式，波特率9600，奇校验
   
7.     eMBEnable();                                                                        // 使能modbus协议栈
   
8. 
   
9.     for( ;; )
   
10.     {
    
11.         eMBPoll();                                                                        // 轮训查询
    
12.     }
    0 Z5 V/ s9 U0 i& L! m5 U0 P
13. }

复制代码

* j' r: y3 e6 R% j- K: {移植测试
" n' L- r& j; a; K3 \2 j, i5 B
% M4 w4 n* _$ I/ r% a; @! V/ J$ w
, e; G1 \, n0 M- R% R7 c$ O# Z
2 K: u/ D" f" R: ]5 H6 sends…
9 [3 k. h4 O' P6 |3 O" U( o+ ~  I

我的是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);              // 新增：清除残留标志

} }

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