modbus命令码表：

) e+ d; G* W, v8 v+ I9 L/ ~2 t
7 p+ _3 E3 s1 U5 I- d' C9 L9 K
2 ~5 \. U0 |/ K, m7 o( b4 ^( eFreeModbus文件说明
      解压freemodbus文件后打开，我们需要demo目录下的BARE，该目录下的代码是空的，STM32移植工作基本就是修改：portserial.c、porttimer.c、port.h这三个文件。
$ K% S9 h; s/ H0 J

      mobus文件夹就是完整的源码，包含rtu、ascii、tcp：

$ ?( c) j4 J- y, h

1 A" ^8 `# Q: v, r" l+ y. l2 G/ W- V      我为了移植时在keil添加源文件和头文件方便，就把modbus所有的头文件和源文件放到了一个文件夹下，并创建了一个port.c文件，用于编写modbus所必需的回调处理函数：


' u8 q- a( B  x( d
$ |2 y8 ]2 M! e! r* t: S' a: iSTM32CUBEMX配置
时钟配置，设置主频工作在72MHz下：


( c3 ^( k* e  d% X' f) N1 {$ D: ^
配置串口1，这里随便配置就行，在modbus移植过程中还会对串口重新初始化：


0 W: j: u( E1 i3 S) R7 @0 n
配置定时器4，用于3.5个字符的定时检测，这里随便配置就行，在modbus移植过程中还会对定时器重新初始化：
9 o3 f9 C" y' x6 A0 o6 ?! t
+ Y2 [: o7 u; ]- T% F2 m3 ^
/ w3 y( d% p4 ?; [
中断配置，这里注意，串口的优先级是要比定时器优先高的：
2 R, w6 e3 A  d9 {, t- v
' N* v6 U) d1 B, ^4 O3 z/ ~4 k8 D
取消掉自动生成中断服务程序，在移植过程中我们要自己编写串口和定时器的中断服务程序：


. \8 Y  g% m; p  t
移植代码修改
生成代码后将modbus放到工程目录下：
; z, l" J; L/ e" `& l. ~3 K$ }, N


打开keil工程添加modbus源码：
, |, r1 M$ Y, b& L- ]9 s+ A, j

* m' s6 s; K0 q3 B% u9 v) |7 X
2 h, ^* A+ H& p添加包含头文件：



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

1. BOOL
   6 N) _7 S2 F) U- u
2. xMBPortTimersInit( USHORT usTim1Timerout50us )
   
3. {
   
4.     TIM_ClockConfigTypeDef sClockSourceConfig = {0};
   1 ~2 ~& V/ @2 i/ Q) U" M, L7 l2 v, Q, U
5.     TIM_MasterConfigTypeDef sMasterConfig = {0};
   : }7 ?( T0 J6 J; c
6. 
   % l" h% l- V4 b0 d' z, C, f, C5 u
7.     htim4.Instance = TIM4;
   
8.     htim4.Init.Prescaler = 3599;                                                                // 50us记一次数
     F# ~( V' i; a. H4 Z2 P
9.     htim4.Init.CounterMode = TIM_COUNTERMODE_UP;
   ) l: q, \1 S$ x( |0 o% j- {
10.     htim4.Init.Period = usTim1Timerout50us - 1;                                        // usTim1Timerout50us * 50即为定时器溢出时间
    + c6 \! R: Q( r4 ~1 s
11.     htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    2 q4 ]9 `% b9 R7 m- U1 ]
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;
      Z4 G! n! d$ ~9 w# C
18.     if (HAL_TIM_ConfigClockSource(&htim4, &sClockSourceConfig) != HAL_OK)
    + f' k3 @! d. m
19.     {
    
20.         return FALSE;
    , o# `2 _; Q0 A" d- l7 G0 T! x
21.     }
    - c& w8 u9 [; m# S
22.     sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
    
23.     sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
    
24.     if (HAL_TIMEx_MasterConfigSynchronization(&htim4, &sMasterConfig) != HAL_OK)
    
25.     {
    8 V+ d% c9 R' n) e
26.         return FALSE;
    
27.     }
    2 m9 _9 s5 {2 N+ T
28. 
    
29.     __HAL_TIM_ENABLE_IT(&htim4, TIM_IT_UPDATE);                                        // 使能定时器更新中断
    - e. _- T; U" d( V! L
30.     return TRUE;
    
31. }
      I% }% q9 c' Z5 V* x
32. 
    
33. inline void
    
34. vMBPortTimersEnable(  )
    
35. {
    
36.     __HAL_TIM_SET_COUNTER(&htim4, 0);                // 清空计数器
    + c' p4 Z2 e% ?( X- e
37.     __HAL_TIM_ENABLE(&htim4);                                // 使能定时器
    
38. }
    ; z) k& o; k* j, s0 ]8 }
39. 
    # e& k9 d/ Q9 @: Z/ |- E4 _
40. inline void
    & X' Q$ A* t4 e! h  Z( Q5 S
41. vMBPortTimersDisable(  )
    
42. {
    # L; D9 L' ?  e. Q6 }- z5 r2 g
43.     __HAL_TIM_DISABLE(&htim4);                                // 禁能定时器
    
44. }
    
45. 
    4 O) o; i: y/ A
46. /* Create an ISR which is called whenever the timer has expired. This function
    ' _6 E! n) U* \' U3 E- F
47. * must then call pxMBPortCBTimerExpired( ) to notify the protocol stack that
    1 |- A: {) g4 O
48. * the timer has expired.
    
49. */
    ) y/ T( w$ \6 Z7 E' h' F8 R( Q
50. static void prvvTIMERExpiredISR( void )
    ! O4 G) `& d4 l# g( u+ x! L7 y
51. {
    
52.     ( void )pxMBPortCBTimerExpired(  );
    ; l- U% Z  v- a5 |! L* D% `
53. }
    ' T4 U) a" k  I/ Y, v( O
54. 
    - D' w, h  p: E0 T
55. /// 定时器4中断服务程序
    7 L# m% L* I/ p) I$ s
56. void TIM4_IRQHandler(void)
    
57. {
    
58.     if(__HAL_TIM_GET_FLAG(&htim4, TIM_FLAG_UPDATE))                        // 更新中断标记被置位
    0 u9 B3 R" o. }7 b7 E' M/ D/ w  O
59.     {
    5 T% q! X) l/ E
60.         __HAL_TIM_CLEAR_FLAG(&htim4, TIM_FLAG_UPDATE);                // 清除中断标记
    + s3 N( b4 K4 A- [' Z
61.         prvvTIMERExpiredISR();                                                                // 通知modbus3.5个字符等待时间到
    , T7 b4 B: U( h: M' {+ d- \8 A0 |
62.     }
    
63. }
    * y! _, f) D  d: B
64. 
    
65. 
    - g+ K- T) t+ a" Z5 N: i! `3 k

复制代码

修改modbus串口初始化源代码portserial.c文件
8 G* ?+ }$ ~- V* x1 z9 I         ~~~~~~~~        在该文件中实现串口1的中断服务程序，prvvUARTTxReadyISR和prvvUARTRxISR函数需要填写进中断服务程序，前者得到作用为通知modbus协议栈串口已经空闲可以发送数据了，后者的作用为通知modbus串口1有数据到达，修改后的代码如下：

1. /*
   1 x  M6 w7 x: D  }( F) ]6 E& B, z) O
2. * FreeModbus Libary: BARE Port
   0 [  L' M- T+ l. ~5 G
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
   
6. * modify it under the terms of the GNU Lesser General Public
   
7. * License as published by the Free Software Foundation; either
     m7 |0 C9 V! ?% r8 j
8. * version 2.1 of the License, or (at your option) any later version.
   : y$ g' t6 k$ }# k) o# [
9. *
   
10. * This library is distributed in the hope that it will be useful,
    1 T% C$ y1 ]! l; p1 z
11. * but WITHOUT ANY WARRANTY; without even the implied warranty of
    : ?: C+ J2 Y  s( b! P0 \' x% |2 n
12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    
13. * Lesser General Public License for more details.
    
14. *
    9 E' t+ B5 n1 P- j
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
    $ p0 u. H( ]4 d
17. * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
    # E, g+ L0 q- e6 i
18. *
    
19. * File: $Id$
    
20. */
    + i9 K+ _" Z" p$ j5 g
21. 
    1 P! l. L+ b2 a  Q) y: \: j; w: n  h
22. #include "port.h"
    & H) O, {$ p- d4 g/ w3 [, [
23. #include "usart.h"
    
24. 
    7 c2 {1 K- O; g
25. /* ----------------------- Modbus includes ----------------------------------*/
    
26. #include "mb.h"
    + |% o2 k! E7 y# ]: z
27. #include "mbport.h"
    : b" ~) [* k0 O' V  d
28. 
    $ L: K# I9 f8 p, s
29. /* ----------------------- static functions ---------------------------------*/
    
30. static void prvvUARTTxReadyISR( void );
    1 s3 |  U: I% E! D6 d
31. static void prvvUARTRxISR( void );
    
32. 
    9 b/ p3 d/ E& c+ I- m
33. /* ----------------------- Start implementation -----------------------------*/
    8 S1 {2 _- Y# h2 m" q5 w0 [
34. void
    
35. vMBPortSerialEnable( BOOL xRxEnable, BOOL xTxEnable )
    
36. {
    
37.     if(xRxEnable)
    9 u' M) `) ]8 v3 v6 P! O) ?: r
38.     {
    ; H: E6 A6 \- A5 P
39.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_RXNE);                // 使能接收非空中断
    
40.     }
    : a; L- q+ l$ C, k
41.     else
    
42.     {
    
43.         __HAL_UART_DISABLE_IT(&huart1, UART_IT_RXNE);                // 禁能接收非空中断
    , X) j' Z+ z$ }. x7 w& O
44.     }
    
45. 
    
46.     if(xTxEnable)
    ) ?' H+ k. `" L9 T+ Y4 `
47.     {
    ; P) t6 T  }* b; g, D1 s
48.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_TXE);                        // 使能发送为空中断
    4 \" g6 p& A7 Q1 ^) q7 {
49.     }
    5 _4 w' [' @' f  `* G8 D% ~
50.     else
    
51.     {
    
52.         __HAL_UART_DISABLE_IT(&huart1, UART_IT_TXE);                // 禁能发送为空中断
    
53.     }
    3 L7 i6 e/ Q. y, P/ \/ H. Q. w# ?
54. }
    
55. 
    
56. BOOL
    - n4 l9 U! F" c/ g, h5 N
57. xMBPortSerialInit( UCHAR ucPORT, ULONG ulBaudRate, UCHAR ucDataBits, eMBParity eParity )
    
58. {
    1 A' q6 T6 f% c8 I
59.     huart1.Instance = USART1;
    
60.     huart1.Init.BaudRate = ulBaudRate;
    
61.     huart1.Init.StopBits = UART_STOPBITS_1;
    
62.     huart1.Init.Mode = UART_MODE_TX_RX;
    
63.     huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    3 _4 j; \! M% ~; c1 ]& @
64.     huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    
65. 
    1 ?" A/ f! g& o0 @" h' n. K% R: C" a
66.     switch(eParity)
    3 S( i- \1 L9 e9 |0 m( {: V: L, U
67.     {
    + t+ a5 x/ V8 Z: c  `8 w
68.         // 奇校验
    
69.     case MB_PAR_ODD:
    
70.         huart1.Init.Parity = UART_PARITY_ODD;
    
71.         huart1.Init.WordLength = UART_WORDLENGTH_9B;                        // 带奇偶校验数据位为9bits
    
72.         break;
    $ l- \8 `( ]3 x- ~) [
73.         
    ) g' I) b( c" f! \( ]( b+ M- C. [
74.         // 偶校验
    + g+ ]0 b/ e1 W+ k/ E
75.     case MB_PAR_EVEN:
    
76.         huart1.Init.Parity = UART_PARITY_EVEN;
    
77.         huart1.Init.WordLength = UART_WORDLENGTH_9B;                        // 带奇偶校验数据位为9bits
    & L8 j- `* c* Y- v( H9 C
78.         break;
    4 C0 {6 [; p' e+ v& ~6 A. n" Q; @  t
79.         
    
80.         // 无校验
    ( V( O: _% P# z' l, a: D2 w1 h
81.     default:
    ! [1 @( X1 N: q% ~; h$ N
82.         huart1.Init.Parity = UART_PARITY_NONE;
    * k( S9 d  H. K
83.         huart1.Init.WordLength = UART_WORDLENGTH_8B;                        // 无奇偶校验数据位为8bits
    
84.         break;
    2 H* F; x5 l% s6 t9 \5 K
85.     }
    
86.     return HAL_UART_Init(&huart1) == HAL_OK ? TRUE : FALSE;
    . s1 A, t6 w0 \4 J
87. }
    1 F6 i; i6 M2 j7 w, i
88. 
    * L3 Z; J3 l* X
89. BOOL
    
90. xMBPortSerialPutByte( CHAR ucByte )
    7 k4 h- Y) n/ d- U1 f4 U
91. {
    * q# h5 _; h2 ?8 g' W
92.     USART1->DR = ucByte;
    , ?5 ^# Q: p/ C9 Q* O
93.     return TRUE;
    
94. }
    
95. 
    * f6 o* L$ Z0 h3 \$ s' N: B
96. BOOL
    
97. xMBPortSerialGetByte( CHAR * pucByte )
    % `( N, T/ Q8 y: `; a. t
98. {
    ! |& f3 d. v0 i. `% l9 N8 D: y* W
99.     *pucByte = (USART1->DR & (uint16_t)0x00FF);
    2 S  k# _: v6 v) T/ X5 K8 @8 ]% \
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.
     
108. */
     
109. static void prvvUARTTxReadyISR( void )
     2 a  w3 D7 }0 A
110. {
     ; e' }$ b+ t% C
111.     pxMBFrameCBTransmitterEmpty(  );
     ; p8 S. D& i+ \, D# d
112. }
     
113. 
     
114. /* Create an interrupt handler for the receive interrupt for your target
     ' I6 X1 U1 c+ T7 u3 m
115. * processor. This function should then call pxMBFrameCBByteReceived( ). The
     
116. * protocol stack will then call xMBPortSerialGetByte( ) to retrieve the
     0 F* g* y( G. w$ ]$ L# _# J5 f
117. * character.
     
118. */
     
119. static void prvvUARTRxISR( void )
     
120. {
     
121.     pxMBFrameCBByteReceived(  );
     5 z4 q6 R5 m. y
122. }
     
123. 
     
124. void USART1_IRQHandler(void)
     - y2 H% p0 o: Q6 t1 W: T. Z
125. {
     
126.     if(__HAL_UART_GET_FLAG(&huart1, UART_FLAG_RXNE))                        // 接收非空中断标记被置位
     
127.     {
     
128.         __HAL_UART_CLEAR_FLAG(&huart1, UART_FLAG_RXNE);                        // 清除中断标记
     ) o) a! M, E& o% a# O
129.         prvvUARTRxISR();                                                                                // 通知modbus有数据到达
     % R  i% T! w( v. u) Q
130.     }
     $ J3 P" g9 Z* V8 H5 h
131. 
     
132.     if(__HAL_UART_GET_FLAG(&huart1, UART_FLAG_TXE))                                // 发送为空中断标记被置位
     
133.     {
     
134.         __HAL_UART_CLEAR_FLAG(&huart1, UART_FLAG_TXE);                        // 清除中断标记
     ( z7 H5 H4 {; S" h
135.         prvvUARTTxReadyISR();                                                                        // 通知modbus数据可以发松
     + E9 x3 p7 s& W7 E0 J/ T$ o# {7 p
136.     }
     
137. }

复制代码

6 D. Q9 {* E- H* s* m注意一点，一般如果使用了485芯片的话，那么同一时刻只能接收或者发送，可以将函数vMBPortSerialEnable修改成这样：
$ K# `; |; K9 b7 c) h
8 H. Q) r2 v9 @3 U, }- n2 w4 d

1. void
   
2. vMBPortSerialEnable( BOOL xRxEnable, BOOL xTxEnable )
   6 C% H4 C, P  e
3. {
   $ U1 M* |0 H$ r: T
4.     if(xRxEnable)
   * q+ L# O+ L+ s
5.     {
   
6.             //
   ( X# ?; l0 ~% n% H7 u3 E
7.         // 在此处将485芯片设置为接收模式
   0 ~# ?2 ~" j/ g% t' a& R0 I
8.         //
   / a; J: q$ ?; S$ _- l$ V
9.                 /* do something */
   
10.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_RXNE);                // 使能接收非空中断
    
11.     }
    
12.     else
    
13.     {
    
14.         __HAL_UART_DISABLE_IT(&huart1, UART_IT_RXNE);                // 禁能接收非空中断
    0 W% A, d( \& A  n
15.     }
    
16. 
    0 v* s; [4 ]$ @5 z( L* r
17.     if(xTxEnable)
    4 _7 u0 g! N+ N2 e( s$ I
18.     {
    
19.             //
    
20.         // 在此处将485芯片设置为发送模式
    
21.         //
    4 k$ \8 f8 e. p* i  j% u4 f
22.         /* do something */
    
23.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_TXE);                        // 使能发送为空中断
    
24.     }
    
25.     else
    
26.     {
    
27.         __HAL_UART_DISABLE_IT(&huart1, UART_IT_TXE);                // 禁能发送为空中断
    
28.     }
    
29. }

复制代码

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

1. #include "mb.h"
   
2. #include "mbport.h"
   0 p% B5 e3 t$ c3 f' g9 {
3. 
   
4. 
   
5. // 十路输入寄存器
   
6. #define REG_INPUT_SIZE  10
   3 \# [# }0 A6 Q5 ^
7. uint16_t REG_INPUT_BUF[REG_INPUT_SIZE];
   
8. 
   
9. 
   ' b; s. x$ s5 ?  v: ?8 N! h' }
10. // 十路保持寄存器
    + F: `1 Q! e' b1 W4 h
11. #define REG_HOLD_SIZE   10
    ' H( J; `  Z- Q1 |, z' ]+ E2 l9 A
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];
    ' s+ ~8 R) V7 @2 H8 F3 _( `2 t9 r  M
18. 
    
19. 
    3 R5 C. o+ P: v: ]$ K( ~8 q# b
20. // 十路离散量
    
21. #define REG_DISC_SIZE  10
    
22. uint8_t REG_DISC_BUF[10];
    $ G4 T1 ~1 d& Z9 W& j$ g" q5 R; q
23. 
    3 h2 N8 i7 L3 I
24. 
    & L, u9 n5 H6 o$ o6 Z+ Y
25. /// CMD4
    . h" b$ p' L# w4 n( g5 n
26. eMBErrorCode eMBRegInputCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs )
    
27. {
    
28.     USHORT usRegIndex = usAddress - 1;
    
29. 
    ; K  H! @6 s: u( e- l3 V; t- N
30.     // 非法检测
    4 @+ W; Y- C9 h4 j" S& K$ I! p
31.     if((usRegIndex + usNRegs) > REG_INPUT_SIZE)
    9 r8 ^/ v' b  c2 i
32.     {
    
33.         return MB_ENOREG;
    / w1 m* h% w# l0 o0 Y! x  d
34.     }
    2 ~( G. |) H% x' I# g
35. 
      t( U4 q: F* g0 d2 N& n
36.     // 循环读取
    
37.     while( usNRegs > 0 )
    
38.     {
    
39.         *pucRegBuffer++ = ( unsigned char )( REG_INPUT_BUF[usRegIndex] >> 8 );
    
40.         *pucRegBuffer++ = ( unsigned char )( REG_INPUT_BUF[usRegIndex] & 0xFF );
    " j! B  G) F6 e* }5 E0 \2 r$ y
41.         usRegIndex++;
    
42.         usNRegs--;
    " O7 T0 }5 |5 b9 `: j; y  E3 f
43.     }
    - T% l# ~. x/ c7 s1 i0 c
44. 
    
45.     // 模拟输入寄存器被改变
    
46.     for(usRegIndex = 0; usRegIndex < REG_INPUT_SIZE; usRegIndex++)
    
47.     {
    
48.         REG_INPUT_BUF[usRegIndex]++;
    $ `/ m9 d6 @0 O* V: E
49.     }
    
50. 
    4 y4 X. v+ P) p# D& d2 u/ @- ^" n
51.     return MB_ENOERR;
    
52. }
    
53. 
    
54. /// CMD6、3、16
    
55. eMBErrorCode eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs, eMBRegisterMode eMode )
    
56. {
    5 }* H: ], R2 q% c  d% X
57.     USHORT usRegIndex = usAddress - 1;  
    * t* K4 G# H8 [  g4 e) R. ?
58. 
    2 [: K8 S8 ?* {! W' A3 T
59.     // 非法检测
    
60.     if((usRegIndex + usNRegs) > REG_HOLD_SIZE)
    ( h+ t8 U. o7 m' j
61.     {
    + h6 `) f8 m1 o
62.         return MB_ENOREG;
    . m+ N9 _/ y! A  C3 V
63.     }
    
64. 
    
65.         // 写寄存器
    
66.     if(eMode == MB_REG_WRITE)
    5 \0 I; h* [, k! g# v! L1 \
67.     {
    
68.         while( usNRegs > 0 )
    
69.         {
    ( G& g( _' h& [+ k$ j. ~
70.                         REG_HOLD_BUF[usRegIndex] = (pucRegBuffer[0] << 8) | pucRegBuffer[1];
    2 @4 m% n) i$ d# w! W
71.                         pucRegBuffer += 2;
    ' I, ]# r8 q- {7 K
72.             usRegIndex++;
    " q' X# \& q& F. f7 ~' P
73.             usNRegs--;
    ' M/ M- k4 ~8 v% z' F7 j& K
74.         }
    4 q( H+ P0 i$ S" W) G
75.     }
    ; p# k' T9 t" N" ~2 C% B: j2 h
76.         
    
77.         // 读寄存器
    $ I% D0 u* A5 o7 t$ a& B
78.     else
    / q* D  d) G4 x( U
79.     {
    
80.         while( usNRegs > 0 )
    
81.         {
    
82.             *pucRegBuffer++ = ( unsigned char )( REG_HOLD_BUF[usRegIndex] >> 8 );
    6 ^7 Y5 a( V. g( J, y
83.             *pucRegBuffer++ = ( unsigned char )( REG_HOLD_BUF[usRegIndex] & 0xFF );
    : n, E! k. K6 M! |+ E
84.             usRegIndex++;
    
85.             usNRegs--;
    # I+ ^2 M8 a  k
86.         }
    9 T" o; D$ Y' n
87.     }
    0 x% e' V1 h* V% W& A
88. 
    
89.     return MB_ENOERR;
    / i2 H# }, g3 r9 `5 c. ^
90. }
    
91. 
    
92. /// CMD1、5、15
    ) N0 a8 M6 c% t
93. eMBErrorCode eMBRegCoilsCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNCoils, eMBRegisterMode eMode )
    
94. {
      }+ e, E) G- X4 n
95.     USHORT usRegIndex   = usAddress - 1;
    , X$ Y# X0 d* a( F) x5 C3 d
96.     USHORT usCoilGroups = ((usNCoils - 1) / 8 + 1);
    4 ?% c2 r, D# s2 }* b
97.     UCHAR  ucStatus     = 0;
    % E# f! y) m# h7 F* m3 `5 c! \
98.     UCHAR  ucBits       = 0;
    
99.     UCHAR  ucDisp       = 0;
    1 w3 M( q: _, W. q
100. 
     ) u) E' @) _" X* F1 @" k' t
101.     // 非法检测
     ; \3 R1 T( M  {( m3 R& A  b4 Q
102.     if((usRegIndex + usNCoils) > REG_COILS_SIZE)
     1 k, D  [8 m5 i1 [5 n! g, [1 S: q% E2 G
103.     {
     / [7 V/ P7 x! h; w; a) O
104.         return MB_ENOREG;
     
105.     }
     
106. 
     # I9 ^+ {1 f2 t! m, i
107.     // 写线圈
     
108.     if(eMode == MB_REG_WRITE)
     ! A! a. }4 z' a/ x$ B
109.     {
     
110.         while(usCoilGroups--)
     
111.         {
     & B2 F; d. G/ g
112.             ucStatus = *pucRegBuffer++;
     
113.             ucBits   = 8;
     
114.             while((usNCoils--) != 0 && (ucBits--) != 0)
     
115.             {
     4 a7 w& G, V/ ~) K+ e2 L' J( D
116.                 REG_COILS_BUF[usRegIndex++] = ucStatus & 0X01;
     
117.                 ucStatus >>= 1;
     
118.             }
     
119.         }
     
120.     }
     ! q6 f& Z+ e6 V
121. 
     
122.     // 读线圈
     
123.     else
     6 g! h& [3 B/ K
124.     {
     . s& u0 x2 m0 b; {% p4 s2 N
125.         while(usCoilGroups--)
     
126.         {
     - ^6 r3 A4 Z" @8 V5 z: V
127.             ucDisp = 0;
     
128.             ucBits = 8;
     
129.             while((usNCoils--) != 0 && (ucBits--) != 0)
     
130.             {
     
131.                 ucStatus |= (REG_COILS_BUF[usRegIndex++] << (ucDisp++));
     
132.             }
     ( O2 x1 z1 H4 s7 F
133.             *pucRegBuffer++ = ucStatus;
     : w, U/ R+ a) L) I3 r1 E' |
134.         }
     
135.     }
     % ~* t0 T) p# h) d
136.     return MB_ENOERR;
     
137. }
     4 U) I5 a0 u: W, V% _9 d0 U2 ]% z! R
138. 
     ! Q* l2 ]; [. I9 X% p2 S5 [4 G
139. 
     2 q* G1 @1 K) X% R3 m
140. /// CMD4
     
141. eMBErrorCode eMBRegDiscreteCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNDiscrete )
     
142. {
     
143.     USHORT usRegIndex   = usAddress - 1;
     
144.     USHORT usCoilGroups = ((usNDiscrete - 1) / 8 + 1);
     
145.     UCHAR  ucStatus     = 0;
     
146.     UCHAR  ucBits       = 0;
     0 N6 p, V% `& M# W% ?# `! \
147.     UCHAR  ucDisp       = 0;
     
148. 
     
149.     // 非法检测
     2 i- n) L5 ]( V
150.     if((usRegIndex + usNDiscrete) > REG_DISC_SIZE)
     8 N  Z; d2 n" G* u1 F& o4 }; Y
151.     {
     
152.         return MB_ENOREG;
     
153.     }
     
154. 
     
155.         // 读离散输入
     
156.         while(usCoilGroups--)
     ; F! v' [% K- t
157.         {
     3 P  @4 R' `0 P% i
158.                 ucDisp = 0;
     9 s$ @7 y. k3 k' p
159.                 ucBits = 8;
     
160.                 while((usNDiscrete--) != 0 && (ucBits--) != 0)
     
161.                 {
     
162.                         if(REG_DISC_BUF[usRegIndex])
     ) G7 ?/ ?5 s+ c8 Q; T& d
163.                         {
     
164.                                 ucStatus |= (1 << ucDisp);
     
165.                         }
     ; o1 U7 t: c& |! t# x2 W
166.                         ucDisp++;
     ! `% |( c" X( U+ u4 M
167.                 }
     - o2 Z3 R# Z- w3 a+ T0 b" F* X& m
168.                 *pucRegBuffer++ = ucStatus;
     + [7 W5 |' V4 l) {4 A$ n' F! Q& B
169.         }
     , U+ `8 f+ c. c! E
170. 
     
171.     // 模拟改变
     4 m: B* [7 ]4 b' C7 b/ U- f7 D6 r
172.     for(usRegIndex = 0; usRegIndex < REG_DISC_SIZE; usRegIndex++)
     
173.     {
     $ E' a8 p: I. O6 f- U! S
174.         REG_DISC_BUF[usRegIndex] = !REG_DISC_BUF[usRegIndex];
     
175.     }
     0 ^- u, d  `0 }' Y
176. 
     - j3 a  [; C( T4 L( t0 U
177.     return MB_ENOERR;
     # E5 A: k7 Y6 J5 S+ e+ j( w, E
178. }

复制代码

主函数

1. int main(void)
   1 C- A* Q$ F6 J. Z
2. {
   $ ~8 e# E1 U/ o
3.     HAL_Init();
   . x: y1 T4 M0 O2 P
4.     SystemClock_Config();
   
5.     MX_GPIO_Init();
   , D# |3 ?4 T& Y1 {+ ^
6.     eMBInit(MB_RTU, 0x01, 0, 9600, MB_PAR_ODD);                // 初始化modbus为RTU方式，波特率9600，奇校验
   
7.     eMBEnable();                                                                        // 使能modbus协议栈
   
8. 
   
9.     for( ;; )
   
10.     {
    
11.         eMBPoll();                                                                        // 轮训查询
    
12.     }
    7 c6 c4 V9 x5 K' g& m( t- g  q
13. }

复制代码

移植测试

% O1 j' g+ J2 ~8 o7 x

ends…
2 Q$ z7 ^' P# u4 z

+ Q8 x5 F" ?1 L
/ k$ f' F6 w, U2 \& E  ~

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

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

<br /> <br />

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

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

} }

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