modbus命令码表：

) O+ e- n. B% e( A

4 ^$ s4 B( G" y. v2 }FreeModbus文件说明
  N0 O9 j+ k5 f7 w      解压freemodbus文件后打开，我们需要demo目录下的BARE，该目录下的代码是空的，STM32移植工作基本就是修改：portserial.c、porttimer.c、port.h这三个文件。
( m- A7 J. a. _; A
" Z3 Z1 y# E0 q. S; |  @! @2 P
: U, p# o& d0 n( i& L3 k7 ^      mobus文件夹就是完整的源码，包含rtu、ascii、tcp：



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

4 K0 y8 H% N2 I+ E

STM32CUBEMX配置
时钟配置，设置主频工作在72MHz下：



配置串口1，这里随便配置就行，在modbus移植过程中还会对串口重新初始化：
# s5 j# e5 i& r6 _% k) v0 V: n% F


5 E( P) w2 d6 e# m" ?配置定时器4，用于3.5个字符的定时检测，这里随便配置就行，在modbus移植过程中还会对定时器重新初始化：
" f& G" z. b& U
/ ]6 i  s% }$ L/ t! q  P

中断配置，这里注意，串口的优先级是要比定时器优先高的：
( {2 _; r6 Z) v7 t) k
+ ^; ?& l: c9 y+ h6 \) ]
取消掉自动生成中断服务程序，在移植过程中我们要自己编写串口和定时器的中断服务程序：
+ h2 A# R0 c, V


移植代码修改
1 E: n1 T  O9 K1 ~) A* \* C- q/ W2 s生成代码后将modbus放到工程目录下：
& k' {' m( K+ E& _) V5 k
: Z/ }2 B' n! O6 t% c8 i
* q. r/ m5 ]( E4 l- f
打开keil工程添加modbus源码：

7 _6 e# p; Z( d3 j

* C* _! d/ N/ E( S: K& d添加包含头文件：
( ?: u7 g9 ]. f6 l6 J! W6 ^

1 g( X+ S9 U$ N
, L/ K! E0 K6 K2 D( I$ _修改modbus定时器初始化源代码porttimer.c文件
       定时器的修改比较容易，将定时器设置为每50us的时长记一个数，传入的usTim1Timerout50us变量给自动装载即可，prvvTIMERExpiredISR函数需要在定时器中断服务函数中调用，它的作用是用于通知modbus协议栈3.5个字符的等待时间已经到达；由于我们在STM32CUBEMX中取消掉了定时器和串口的中断服务函数程序，所以我们在该文件中添加定时器的中断服务程序，修改后的代码如下：
1 p! }0 ~/ x7 h8 x* X' c* H

1. BOOL
   - x% q6 Z: g3 `: b* u1 L4 A0 `8 _
2. xMBPortTimersInit( USHORT usTim1Timerout50us )
   & u& }0 A9 N: s1 ?' M& T( d" p
3. {
   
4.     TIM_ClockConfigTypeDef sClockSourceConfig = {0};
   
5.     TIM_MasterConfigTypeDef sMasterConfig = {0};
   . X/ N* \, @- |; ^7 [, H
6. 
   
7.     htim4.Instance = TIM4;
   2 O1 _! W2 ]5 F0 f9 s0 V7 H
8.     htim4.Init.Prescaler = 3599;                                                                // 50us记一次数
   / E3 Z; x( n' N9 S4 q4 D+ r6 M: c
9.     htim4.Init.CounterMode = TIM_COUNTERMODE_UP;
   
10.     htim4.Init.Period = usTim1Timerout50us - 1;                                        // usTim1Timerout50us * 50即为定时器溢出时间
    % m/ V7 _4 }6 V' e; `
11.     htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    
12.     htim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
    5 ?- @- u' o2 d2 ^5 V4 n6 h9 q
13.     if (HAL_TIM_Base_Init(&htim4) != HAL_OK)
    , @0 o4 }7 W9 Q7 C4 B; Q
14.     {
    1 G9 b6 [. s6 o( E8 @
15.         return FALSE;
    
16.     }
    ( v9 `0 I( e% A) f% w
17.     sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
    
18.     if (HAL_TIM_ConfigClockSource(&htim4, &sClockSourceConfig) != HAL_OK)
    , y4 _1 d$ h2 i2 Y' R0 _
19.     {
    
20.         return FALSE;
    
21.     }
    0 t) T$ _  y5 o( f- ^* H
22.     sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
    
23.     sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
    
24.     if (HAL_TIMEx_MasterConfigSynchronization(&htim4, &sMasterConfig) != HAL_OK)
    
25.     {
    
26.         return FALSE;
    5 R3 [- N3 S% [: Z% P
27.     }
    
28. 
    ; k% N. P% u  }! i* c' b; l6 a
29.     __HAL_TIM_ENABLE_IT(&htim4, TIM_IT_UPDATE);                                        // 使能定时器更新中断
    
30.     return TRUE;
    9 L/ v: B( [; V0 _
31. }
    
32. 
    
33. inline void
    * W) d9 t% u2 f! s$ R- M3 N0 E
34. vMBPortTimersEnable(  )
    2 e* `( J, b2 K  B2 j6 A- t" ]
35. {
    
36.     __HAL_TIM_SET_COUNTER(&htim4, 0);                // 清空计数器
    
37.     __HAL_TIM_ENABLE(&htim4);                                // 使能定时器
    
38. }
    $ w: i0 j' o6 [  T' O
39. 
    
40. inline void
    & ~4 u# h3 f$ W# [9 Y% ]
41. vMBPortTimersDisable(  )
    . i& p$ G* \3 `, a# g) f1 N
42. {
      h- x1 ?& s3 e$ ^
43.     __HAL_TIM_DISABLE(&htim4);                                // 禁能定时器
    
44. }
    
45. 
    
46. /* Create an ISR which is called whenever the timer has expired. This function
    2 m& O. A" L& R3 ~( o: E& _( b' i' x
47. * must then call pxMBPortCBTimerExpired( ) to notify the protocol stack that
    
48. * the timer has expired.
    
49. */
    
50. static void prvvTIMERExpiredISR( void )
    ( H5 E6 ]; F) M4 Q  K
51. {
    
52.     ( void )pxMBPortCBTimerExpired(  );
    
53. }
    
54. 
    + W7 \! L! f, W$ H
55. /// 定时器4中断服务程序
    
56. void TIM4_IRQHandler(void)
    
57. {
    
58.     if(__HAL_TIM_GET_FLAG(&htim4, TIM_FLAG_UPDATE))                        // 更新中断标记被置位
    2 l- E) D- C+ n9 W8 B% C
59.     {
    
60.         __HAL_TIM_CLEAR_FLAG(&htim4, TIM_FLAG_UPDATE);                // 清除中断标记
    
61.         prvvTIMERExpiredISR();                                                                // 通知modbus3.5个字符等待时间到
    . X' Z: {7 a. w# ^2 ]( ^& ^
62.     }
    $ R# i5 i; U% i$ h% ~
63. }
    
64. 
    1 f( q1 M/ d  E  B: N/ K& t5 G
65. 
    

复制代码

  H4 b" u4 R1 i1 f2 d, ?修改modbus串口初始化源代码portserial.c文件
% B6 I9 z$ o- `/ \         ~~~~~~~~        在该文件中实现串口1的中断服务程序，prvvUARTTxReadyISR和prvvUARTRxISR函数需要填写进中断服务程序，前者得到作用为通知modbus协议栈串口已经空闲可以发送数据了，后者的作用为通知modbus串口1有数据到达，修改后的代码如下：
8 n9 n0 m/ X) V

1. /*
   
2. * FreeModbus Libary: BARE Port
   
3. * Copyright (C) 2006 Christian Walter <<a href="mailto:wolti@sil.at">wolti@sil.at</a>>
   
4. *
   
5. * This library is free software; you can redistribute it and/or
   9 W/ s! y  B3 u' M! ~" i
6. * modify it under the terms of the GNU Lesser General Public
   , w$ O/ K4 e( y+ e# L) V+ f! k
7. * License as published by the Free Software Foundation; either
   
8. * version 2.1 of the License, or (at your option) any later version.
   $ P* e8 F3 [' i4 U  S! S. _8 {
9. *
   7 v  D& B* c2 M0 p* u0 R
10. * This library is distributed in the hope that it will be useful,
    " M0 @& {/ k; M- U: ?1 ]9 L
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.
    / {9 `4 C  r4 F2 J3 A9 ?. m
14. *
    6 E) B; q: H1 ~2 |) v. C# z* X6 c* O% H0 ^
15. * You should have received a copy of the GNU Lesser General Public
      L2 t/ S) o7 u, Z) O7 K6 |8 r( I
16. * License along with this library; if not, write to the Free Software
    ; E6 d' B$ r! Y5 g& }) @5 f
17. * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
    ) g, X1 [) t8 B1 N* ^3 K
18. *
    
19. * File: $Id$
    
20. */
    
21. 
    
22. #include "port.h"
    
23. #include "usart.h"
    
24. 
    
25. /* ----------------------- Modbus includes ----------------------------------*/
    
26. #include "mb.h"
    
27. #include "mbport.h"
    
28. 
    
29. /* ----------------------- static functions ---------------------------------*/
    : e+ ^9 V8 _5 f
30. static void prvvUARTTxReadyISR( void );
    1 d8 j" e6 z; b
31. static void prvvUARTRxISR( void );
    
32. 
    # r5 I3 l5 g/ s4 r2 }/ f" {& V
33. /* ----------------------- Start implementation -----------------------------*/
    
34. void
    
35. vMBPortSerialEnable( BOOL xRxEnable, BOOL xTxEnable )
    
36. {
    
37.     if(xRxEnable)
    
38.     {
    7 X* }$ C8 Z; S7 `0 _( H
39.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_RXNE);                // 使能接收非空中断
    
40.     }
    
41.     else
    ) ?0 S0 j" c9 c6 s( a6 u1 @
42.     {
    2 @+ h# U& F+ g( [
43.         __HAL_UART_DISABLE_IT(&huart1, UART_IT_RXNE);                // 禁能接收非空中断
    
44.     }
    4 \; f% P2 O. t
45. 
    
46.     if(xTxEnable)
    # _" l& U& n' l6 I
47.     {
    ' x) F/ t2 Y: V  ?0 [# O
48.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_TXE);                        // 使能发送为空中断
    
49.     }
    ' ~/ Z4 n9 S$ Z5 s
50.     else
    
51.     {
    
52.         __HAL_UART_DISABLE_IT(&huart1, UART_IT_TXE);                // 禁能发送为空中断
    
53.     }
    
54. }
    
55. 
    ( L9 T7 I1 ^- M0 o4 N1 y( |
56. BOOL
    
57. xMBPortSerialInit( UCHAR ucPORT, ULONG ulBaudRate, UCHAR ucDataBits, eMBParity eParity )
    
58. {
    9 a, h2 H7 Y  o/ s) A
59.     huart1.Instance = USART1;
    
60.     huart1.Init.BaudRate = ulBaudRate;
    0 `& D+ d8 W; G
61.     huart1.Init.StopBits = UART_STOPBITS_1;
    5 ^8 J- V/ e) Q: w9 ~% M
62.     huart1.Init.Mode = UART_MODE_TX_RX;
    
63.     huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    
64.     huart1.Init.OverSampling = UART_OVERSAMPLING_16;
      e% ~8 m: \/ f/ j* N4 x5 \& f
65. 
    
66.     switch(eParity)
    0 q1 f+ ]& @( H- W8 \
67.     {
    
68.         // 奇校验
    * W% G/ \5 ]% ]. T- I
69.     case MB_PAR_ODD:
    
70.         huart1.Init.Parity = UART_PARITY_ODD;
    0 F8 i( V* a5 f+ F
71.         huart1.Init.WordLength = UART_WORDLENGTH_9B;                        // 带奇偶校验数据位为9bits
    
72.         break;
    : S& Y2 s5 K# C" Q: A; q4 ]3 y
73.         
    ! T* w  O3 p/ v; K# F: @
74.         // 偶校验
    3 R3 h" W) w3 g$ g4 }
75.     case MB_PAR_EVEN:
    % j2 g* `# a* {3 A2 n! l' E: X
76.         huart1.Init.Parity = UART_PARITY_EVEN;
    - W8 a' l. z: u8 n( a( {
77.         huart1.Init.WordLength = UART_WORDLENGTH_9B;                        // 带奇偶校验数据位为9bits
    
78.         break;
    
79.         
    
80.         // 无校验
    1 y3 {' N& B3 p1 v3 l' R1 T! h
81.     default:
    * @3 f  g& ?5 z2 P
82.         huart1.Init.Parity = UART_PARITY_NONE;
    
83.         huart1.Init.WordLength = UART_WORDLENGTH_8B;                        // 无奇偶校验数据位为8bits
    
84.         break;
    1 |3 g3 B5 |  D: K1 t
85.     }
    
86.     return HAL_UART_Init(&huart1) == HAL_OK ? TRUE : FALSE;
    
87. }
    
88. 
    9 m8 Z* ?! `/ C. `$ B
89. BOOL
    ' X# o5 A& s- y' V
90. xMBPortSerialPutByte( CHAR ucByte )
    : I( Z2 w' n  g: C7 k) {
91. {
    2 f7 P' ^: N' {( l5 s
92.     USART1->DR = ucByte;
    
93.     return TRUE;
    
94. }
    : C/ ?( M1 G$ W1 ~( ]- y8 y& Y: _
95. 
    ( A3 Q3 ^3 ~7 a) E- v
96. BOOL
    
97. xMBPortSerialGetByte( CHAR * pucByte )
    
98. {
    # A5 v( n$ r3 t2 t# _1 J/ j9 M) ]
99.     *pucByte = (USART1->DR & (uint16_t)0x00FF);
    
100.         return TRUE;
     ; s+ y1 j2 ?5 X* L( I4 [
101. }
     
102. 
     
103. /* Create an interrupt handler for the transmit buffer empty interrupt
     ' z$ I3 W* D4 M- ~' G8 X- P7 g
104. * (or an equivalent) for your target processor. This function should then
     
105. * call pxMBFrameCBTransmitterEmpty( ) which tells the protocol stack that
     6 c" V/ ~5 U# X  B
106. * a new character can be sent. The protocol stack will then call
     1 K- ^" z6 H2 A) Y4 [- S
107. * xMBPortSerialPutByte( ) to send the character.
     
108. */
     / p: R  ]# _' N1 O- h. T/ F  U( J
109. static void prvvUARTTxReadyISR( void )
     
110. {
     
111.     pxMBFrameCBTransmitterEmpty(  );
     
112. }
     * ~, \8 E- b' M
113. 
     7 a. g# ?0 ~# ]& R) t
114. /* Create an interrupt handler for the receive interrupt for your target
     9 {! {& L6 m0 `$ G3 y
115. * processor. This function should then call pxMBFrameCBByteReceived( ). The
     
116. * protocol stack will then call xMBPortSerialGetByte( ) to retrieve the
     
117. * character.
     : N1 Y) U+ Y* y+ S
118. */
     # O) X6 A% W' W7 r2 _% c
119. static void prvvUARTRxISR( void )
     
120. {
     
121.     pxMBFrameCBByteReceived(  );
     
122. }
     
123. 
     ! t+ g, j( b1 t( E  ^
124. void USART1_IRQHandler(void)
     ! y* n9 g  n, }7 M  h# l2 `. |/ c9 Y
125. {
     9 t" j3 W+ s" s  C5 K7 c# Y2 R
126.     if(__HAL_UART_GET_FLAG(&huart1, UART_FLAG_RXNE))                        // 接收非空中断标记被置位
     
127.     {
     
128.         __HAL_UART_CLEAR_FLAG(&huart1, UART_FLAG_RXNE);                        // 清除中断标记
     ' y* G$ y4 F2 y4 @' k
129.         prvvUARTRxISR();                                                                                // 通知modbus有数据到达
     
130.     }
     
131. 
     " J% b, S; y4 ^; D3 ]
132.     if(__HAL_UART_GET_FLAG(&huart1, UART_FLAG_TXE))                                // 发送为空中断标记被置位
     8 k6 _5 I* ~! H5 u; F; E
133.     {
     
134.         __HAL_UART_CLEAR_FLAG(&huart1, UART_FLAG_TXE);                        // 清除中断标记
     * k1 p0 Q6 w8 x8 c6 E2 ]& V
135.         prvvUARTTxReadyISR();                                                                        // 通知modbus数据可以发松
     
136.     }
     ( a& y8 s/ z# x: @' `) @
137. }

复制代码

注意一点，一般如果使用了485芯片的话，那么同一时刻只能接收或者发送，可以将函数vMBPortSerialEnable修改成这样：
# j% ]  o1 d. }5 b" p& e# v

1. void
   
2. vMBPortSerialEnable( BOOL xRxEnable, BOOL xTxEnable )
   
3. {
   
4.     if(xRxEnable)
   ' w7 S' C% F. U9 H. V3 L
5.     {
   " q% e# Y4 k2 T$ m) k* i  H8 |
6.             //
   
7.         // 在此处将485芯片设置为接收模式
   
8.         //
   / I* I9 v- G& I# O  w
9.                 /* do something */
   9 x8 |6 S; g2 A* m; ]" U9 X" |
10.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_RXNE);                // 使能接收非空中断
    
11.     }
    
12.     else
    
13.     {
    
14.         __HAL_UART_DISABLE_IT(&huart1, UART_IT_RXNE);                // 禁能接收非空中断
    & C! V8 U  y3 A& \% ]
15.     }
    
16. 
    
17.     if(xTxEnable)
    
18.     {
    
19.             //
    
20.         // 在此处将485芯片设置为发送模式
    5 W) D' D' u% w1 u3 J- ~" m
21.         //
    - ]! g* d2 G6 F, S/ z/ Q5 h  V$ G
22.         /* do something */
    
23.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_TXE);                        // 使能发送为空中断
    / g+ B; e: {$ t& P
24.     }
    
25.     else
    
26.     {
    * Y% Y$ X' l) t2 N& l+ M5 q
27.         __HAL_UART_DISABLE_IT(&huart1, UART_IT_TXE);                // 禁能发送为空中断
    - ]: v- Z' ]2 ]. v
28.     }
    
29. }

复制代码

编写modbus命令处理回调函数port.c文件
/ o1 Z9 P6 E4 }* v; Q本例程只实现了读取输入寄存器和保持寄存器的功能，详细代码如下：
; V( y0 E0 E4 |  K; E- j* N
& g6 L+ A6 p1 p/ a& j; x# j: [

1. #include "mb.h"
   
2. #include "mbport.h"
   
3. 
   
4. 
   
5. // 十路输入寄存器
   
6. #define REG_INPUT_SIZE  10
   
7. uint16_t REG_INPUT_BUF[REG_INPUT_SIZE];
   
8. 
   # d' b+ L- Q. Z5 O! h- K: V
9. 
   ! ^  e( m1 u, n/ b% n
10. // 十路保持寄存器
    5 W$ L# \/ h& C: |8 C
11. #define REG_HOLD_SIZE   10
    0 S. j) w) @' t! k7 F0 Q4 N7 V
12. uint16_t REG_HOLD_BUF[REG_HOLD_SIZE];
    + q# S) r- b" g4 Z1 k, ^1 h* `% \: D
13. 
    
14. 
    + q. s" Y% |4 V/ z$ V
15. // 十路线圈
    
16. #define REG_COILS_SIZE 10
    
17. uint8_t REG_COILS_BUF[REG_COILS_SIZE];
    
18. 
    
19. 
    
20. // 十路离散量
    % U) `" f3 A6 F8 B1 r
21. #define REG_DISC_SIZE  10
    
22. uint8_t REG_DISC_BUF[10];
    
23. 
    ; V1 Q0 Q1 @3 c- g
24. 
    ; G: L; B, f/ ^( Q0 n* R# a" Z
25. /// CMD4
    $ f0 R' `, D9 q
26. eMBErrorCode eMBRegInputCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs )
    
27. {
    2 j; X( y2 m! |4 x* l9 A# K
28.     USHORT usRegIndex = usAddress - 1;
    
29. 
    
30.     // 非法检测
    ' A+ P0 N# |% ]* p/ }) ^
31.     if((usRegIndex + usNRegs) > REG_INPUT_SIZE)
    
32.     {
    $ i0 H2 [6 b  u: ^3 e! o2 p" D
33.         return MB_ENOREG;
    
34.     }
    
35. 
    4 [+ i# j+ j: d
36.     // 循环读取
    
37.     while( usNRegs > 0 )
    
38.     {
    3 t- j$ }6 J' H/ b9 [6 u" I9 G
39.         *pucRegBuffer++ = ( unsigned char )( REG_INPUT_BUF[usRegIndex] >> 8 );
    3 l1 J% i* N, F
40.         *pucRegBuffer++ = ( unsigned char )( REG_INPUT_BUF[usRegIndex] & 0xFF );
    
41.         usRegIndex++;
    
42.         usNRegs--;
    
43.     }
    + p; T5 ?( B, e1 }" o  }- ?6 ~- `
44. 
    , h4 V7 c, ~3 t
45.     // 模拟输入寄存器被改变
    
46.     for(usRegIndex = 0; usRegIndex < REG_INPUT_SIZE; usRegIndex++)
    
47.     {
    & [$ ^3 V  B8 P' |* T9 n
48.         REG_INPUT_BUF[usRegIndex]++;
    0 s% y1 L7 Y- C
49.     }
    
50. 
    7 n2 T7 i' ~8 y
51.     return MB_ENOERR;
    
52. }
    # P  [" d; T; A, ?9 P( P3 H1 F7 Q
53. 
    
54. /// CMD6、3、16
    
55. eMBErrorCode eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs, eMBRegisterMode eMode )
    
56. {
    
57.     USHORT usRegIndex = usAddress - 1;  
    
58. 
    ; E: n2 ]8 t5 F* u# k
59.     // 非法检测
    ) P; S# M* J% }: R7 E
60.     if((usRegIndex + usNRegs) > REG_HOLD_SIZE)
    
61.     {
    
62.         return MB_ENOREG;
    
63.     }
    
64. 
    
65.         // 写寄存器
    / B! o. [4 z/ ?5 V2 n: C% ?; z
66.     if(eMode == MB_REG_WRITE)
    
67.     {
    7 B% E5 d$ B6 C/ g
68.         while( usNRegs > 0 )
      L, y0 @  ^, b8 {& I$ g
69.         {
    ! ~# @" \1 n. |
70.                         REG_HOLD_BUF[usRegIndex] = (pucRegBuffer[0] << 8) | pucRegBuffer[1];
    
71.                         pucRegBuffer += 2;
    
72.             usRegIndex++;
    
73.             usNRegs--;
    : r( {2 o! A0 {
74.         }
    
75.     }
    
76.         
    
77.         // 读寄存器
    
78.     else
    2 t. y+ P! O1 y8 x, O' n) f2 o* s
79.     {
    
80.         while( usNRegs > 0 )
    
81.         {
    7 g5 ^, A* ?6 f- E* k2 H& K
82.             *pucRegBuffer++ = ( unsigned char )( REG_HOLD_BUF[usRegIndex] >> 8 );
    + [. }7 p5 }! W/ }$ o5 S
83.             *pucRegBuffer++ = ( unsigned char )( REG_HOLD_BUF[usRegIndex] & 0xFF );
    : ?+ E0 u8 ]* l. Q4 i, T. u* k( y% J
84.             usRegIndex++;
    % I1 l# B& i4 _. {/ |9 F
85.             usNRegs--;
    
86.         }
    . Q6 z" T4 f; l  W, P
87.     }
    " H  {3 n' }  D! T" `* s1 z) M
88. 
    . O) h0 Y6 p2 V# j
89.     return MB_ENOERR;
    + v# R# i+ D$ Z3 O* \
90. }
    
91. 
    
92. /// CMD1、5、15
    / a  W- ?2 L8 C) Y
93. eMBErrorCode eMBRegCoilsCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNCoils, eMBRegisterMode eMode )
    + B1 @* S4 l# K+ }5 H& ~7 H- L
94. {
    
95.     USHORT usRegIndex   = usAddress - 1;
    
96.     USHORT usCoilGroups = ((usNCoils - 1) / 8 + 1);
    & v: n" Z$ J9 f8 r! o
97.     UCHAR  ucStatus     = 0;
    
98.     UCHAR  ucBits       = 0;
    " A" P, G6 d) J* a2 A3 v5 @
99.     UCHAR  ucDisp       = 0;
    
100. 
     ! O  ^! W  B8 M1 w+ L* L
101.     // 非法检测
     5 e: L/ ?% a$ g0 s' s% [% `$ W
102.     if((usRegIndex + usNCoils) > REG_COILS_SIZE)
     
103.     {
     % ^" n$ q* N, F1 |9 O
104.         return MB_ENOREG;
     
105.     }
     1 ~: F) E) ~) b# D* N9 Y5 Z
106. 
     % Z  X7 w7 \9 [  E3 i! X" K9 I% b/ m+ n
107.     // 写线圈
     
108.     if(eMode == MB_REG_WRITE)
     
109.     {
     
110.         while(usCoilGroups--)
     , ~6 ~3 f+ ~9 v+ m
111.         {
     
112.             ucStatus = *pucRegBuffer++;
     ' o7 @; I, o! h
113.             ucBits   = 8;
     
114.             while((usNCoils--) != 0 && (ucBits--) != 0)
     
115.             {
     
116.                 REG_COILS_BUF[usRegIndex++] = ucStatus & 0X01;
     
117.                 ucStatus >>= 1;
     - E. P! a" \# E, N& Y9 N
118.             }
     . i9 t' Y/ t- [# I
119.         }
     ( |7 X- Z4 N, m, R* l6 H; d
120.     }
     # m( ~7 R, I. Q. X8 T' y4 J$ V
121. 
     
122.     // 读线圈
     ) D9 E6 @: Y! H9 {6 K5 N3 l
123.     else
     ( C9 l4 `3 f9 I! Q3 w7 a% g+ H5 }0 X
124.     {
     
125.         while(usCoilGroups--)
     
126.         {
     6 \0 J" Y) i" u7 g
127.             ucDisp = 0;
     # r* B9 ~' S- Q: U3 O
128.             ucBits = 8;
     6 x6 I2 ^& c) Y2 j$ p) L
129.             while((usNCoils--) != 0 && (ucBits--) != 0)
     
130.             {
     ; @! x7 a2 B/ s" e% O& i
131.                 ucStatus |= (REG_COILS_BUF[usRegIndex++] << (ucDisp++));
     
132.             }
     2 O9 k3 m# ~$ ~2 n" d
133.             *pucRegBuffer++ = ucStatus;
     
134.         }
     $ Z  T7 p. `6 V7 ]& j
135.     }
     
136.     return MB_ENOERR;
     
137. }
     * W8 L! }. Y* H# T4 x: f
138. 
     
139. 
     4 C9 z  Y/ Y, J* Q7 a2 u+ f
140. /// CMD4
     
141. eMBErrorCode eMBRegDiscreteCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNDiscrete )
     & v4 T2 g1 b% |& [7 f  p
142. {
     
143.     USHORT usRegIndex   = usAddress - 1;
     ) u- O' H7 D, |9 m8 {. M
144.     USHORT usCoilGroups = ((usNDiscrete - 1) / 8 + 1);
     
145.     UCHAR  ucStatus     = 0;
     
146.     UCHAR  ucBits       = 0;
     7 z$ S: b: b1 Q: R' W' p# A
147.     UCHAR  ucDisp       = 0;
     & c3 C" @# y' f5 V
148. 
     + e& ~9 Y6 ^; [7 J
149.     // 非法检测
     5 ^: y* x# O9 k+ @& n9 n. K
150.     if((usRegIndex + usNDiscrete) > REG_DISC_SIZE)
     
151.     {
     - y* t4 E9 h* D: R4 m
152.         return MB_ENOREG;
     7 V3 s8 K0 k' {9 W, O: e9 C# [
153.     }
     5 M/ f0 e# R9 \" Y7 J
154. 
     - y. O5 a9 w% \0 L- y
155.         // 读离散输入
     . @! M5 |- M9 m+ w, T2 E9 G
156.         while(usCoilGroups--)
     
157.         {
     
158.                 ucDisp = 0;
     : G8 g" S, P& f; s
159.                 ucBits = 8;
     
160.                 while((usNDiscrete--) != 0 && (ucBits--) != 0)
     ' T8 W0 ?1 ~  ]( q# C
161.                 {
     / o; W' P, f1 s* T
162.                         if(REG_DISC_BUF[usRegIndex])
     : y- M8 I% ]" @. n" Y
163.                         {
     
164.                                 ucStatus |= (1 << ucDisp);
     : C; w9 `; B5 g. T  y
165.                         }
     9 S* D2 ]* z1 Q/ k
166.                         ucDisp++;
     4 t- \" ~7 c7 \8 F) j
167.                 }
     3 \0 F. F. ^7 C) e6 g" P
168.                 *pucRegBuffer++ = ucStatus;
     9 a7 P/ B. f. F
169.         }
     3 G* |4 D" s6 {5 ~
170. 
     / e/ X) t5 C7 L: \: q9 m
171.     // 模拟改变
     
172.     for(usRegIndex = 0; usRegIndex < REG_DISC_SIZE; usRegIndex++)
     
173.     {
     
174.         REG_DISC_BUF[usRegIndex] = !REG_DISC_BUF[usRegIndex];
     
175.     }
     
176. 
     ; o0 `0 U# |/ e
177.     return MB_ENOERR;
     7 T- U9 M0 @, Y* z8 P! z
178. }

复制代码

主函数
* S' w0 g- u% ?

1. int main(void)
   8 W. ?/ G' a2 ], `, {
2. {
   
3.     HAL_Init();
   ; G+ w7 T4 Q6 N5 g# p
4.     SystemClock_Config();
   : @9 Z& y" X. d8 q! g5 D" z' ]/ [
5.     MX_GPIO_Init();
   
6.     eMBInit(MB_RTU, 0x01, 0, 9600, MB_PAR_ODD);                // 初始化modbus为RTU方式，波特率9600，奇校验
   
7.     eMBEnable();                                                                        // 使能modbus协议栈
   
8. 
   1 C. u  J1 g0 g7 G: C
9.     for( ;; )
   
10.     {
    
11.         eMBPoll();                                                                        // 轮训查询
    
12.     }
    
13. }

复制代码

移植测试
& m6 q$ Z' y2 L
( X' D& O* r1 t9 N6 k' L! z

ends…



. }) F3 f2 E& W3 L7 E

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

} }

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