modbus命令码表：


! P0 d  [: P! X( X; I/ L5 }) f
( d. {9 E* L0 n% F9 k( mFreeModbus文件说明
      解压freemodbus文件后打开，我们需要demo目录下的BARE，该目录下的代码是空的，STM32移植工作基本就是修改：portserial.c、porttimer.c、port.h这三个文件。

" |8 L' U/ _) Y- ?8 y2 x; N
6 T+ c" g: [4 S      mobus文件夹就是完整的源码，包含rtu、ascii、tcp：


  L( g! d7 Q% Y) a* J$ K
+ u1 ?6 x. Q/ E# d8 E% K' S      我为了移植时在keil添加源文件和头文件方便，就把modbus所有的头文件和源文件放到了一个文件夹下，并创建了一个port.c文件，用于编写modbus所必需的回调处理函数：
: R  U8 [! b9 [0 r; k8 e


STM32CUBEMX配置
7 ?. g+ n7 p8 ?% D: [时钟配置，设置主频工作在72MHz下：
. k! b# c0 D, Q/ A# B9 `
/ ?% r, S  h4 n* K) t9 m9 D
6 |. I! ]- W: v% R; A
! b+ j. y4 Y4 }配置串口1，这里随便配置就行，在modbus移植过程中还会对串口重新初始化：

$ o: f  D4 r  j/ v) {$ E& o3 R

, ~' ?7 E* W; p9 f7 c3 A配置定时器4，用于3.5个字符的定时检测，这里随便配置就行，在modbus移植过程中还会对定时器重新初始化：
# h& I, Z. `# Y' i6 o# I
5 i+ Z2 Q* T0 b- Y0 t9 D
# J7 T5 L6 c' @5 `  L, M5 C* m
& o+ k$ N: t9 |" k4 r5 K1 q中断配置，这里注意，串口的优先级是要比定时器优先高的：
8 s, B% Y2 v0 X+ y% d( ]

取消掉自动生成中断服务程序，在移植过程中我们要自己编写串口和定时器的中断服务程序：



移植代码修改
1 L; G+ p. b7 p. f生成代码后将modbus放到工程目录下：

. W2 j; g; y9 N, s# s9 q

打开keil工程添加modbus源码：



4 o9 p% t' ~% j2 `添加包含头文件：

2 e  \" X# I' z8 Y
$ ]- @9 x+ U/ v* N2 B6 ^
修改modbus定时器初始化源代码porttimer.c文件
2 w. u# j2 u2 L; T, s  `- h       定时器的修改比较容易，将定时器设置为每50us的时长记一个数，传入的usTim1Timerout50us变量给自动装载即可，prvvTIMERExpiredISR函数需要在定时器中断服务函数中调用，它的作用是用于通知modbus协议栈3.5个字符的等待时间已经到达；由于我们在STM32CUBEMX中取消掉了定时器和串口的中断服务函数程序，所以我们在该文件中添加定时器的中断服务程序，修改后的代码如下：

1. BOOL
   * q6 V8 B* L6 U& T9 Y- [/ P
2. xMBPortTimersInit( USHORT usTim1Timerout50us )
   & [1 m/ @' Q" k& x
3. {
   / ~  U$ q! V* c2 k$ e" S
4.     TIM_ClockConfigTypeDef sClockSourceConfig = {0};
   6 r; K/ a8 _' O3 n
5.     TIM_MasterConfigTypeDef sMasterConfig = {0};
   3 K7 M+ X7 R1 v' u
6. 
   
7.     htim4.Instance = TIM4;
   8 p, A5 h, G: u  I) l5 h* q4 g
8.     htim4.Init.Prescaler = 3599;                                                                // 50us记一次数
   
9.     htim4.Init.CounterMode = TIM_COUNTERMODE_UP;
   - A1 J7 y5 R. \
10.     htim4.Init.Period = usTim1Timerout50us - 1;                                        // usTim1Timerout50us * 50即为定时器溢出时间
    # L" H3 v5 z+ A0 @# _4 n
11.     htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    
12.     htim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
    , G3 Y( w  y( ]6 `1 E6 R1 _
13.     if (HAL_TIM_Base_Init(&htim4) != HAL_OK)
    : p# M  _8 R5 u) v2 I+ l
14.     {
    - v1 x) b5 C0 x( U
15.         return FALSE;
    
16.     }
    
17.     sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
    ( N5 K- ]) C, ~, w. s5 p  a- `
18.     if (HAL_TIM_ConfigClockSource(&htim4, &sClockSourceConfig) != HAL_OK)
    + F7 d9 v6 x! _4 i7 D
19.     {
    
20.         return FALSE;
    
21.     }
    $ T! v7 k2 a8 b4 f. d" c: i0 T. y
22.     sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
    ; \0 M2 |. \% d" N. F! l
23.     sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
    2 U# x6 {8 h! |3 @8 ^
24.     if (HAL_TIMEx_MasterConfigSynchronization(&htim4, &sMasterConfig) != HAL_OK)
    
25.     {
    
26.         return FALSE;
    
27.     }
    " U) i' C. H  f
28. 
    . M  [% w8 w6 Z. I5 t- s
29.     __HAL_TIM_ENABLE_IT(&htim4, TIM_IT_UPDATE);                                        // 使能定时器更新中断
    . G$ v( g5 Y2 C1 h- R  R  x
30.     return TRUE;
    / i* ~& `( T2 P% N$ \
31. }
    
32. 
    ; C) D8 B3 m( |
33. inline void
    
34. vMBPortTimersEnable(  )
    
35. {
    
36.     __HAL_TIM_SET_COUNTER(&htim4, 0);                // 清空计数器
    
37.     __HAL_TIM_ENABLE(&htim4);                                // 使能定时器
      m6 D$ x$ i, E  L; u# Y
38. }
    
39. 
    / u+ C% _( L) _& M2 W1 j
40. inline void
    
41. vMBPortTimersDisable(  )
    4 n7 |  v: w. R; n
42. {
    
43.     __HAL_TIM_DISABLE(&htim4);                                // 禁能定时器
    ; p3 a+ ?! C9 {0 a/ T) o
44. }
    
45. 
    
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.
    7 K3 t+ f- p) B+ E1 j- W8 p
49. */
    
50. static void prvvTIMERExpiredISR( void )
    
51. {
    
52.     ( void )pxMBPortCBTimerExpired(  );
    
53. }
    
54. 
    
55. /// 定时器4中断服务程序
    - |9 G8 n+ R' X5 @9 j9 v
56. void TIM4_IRQHandler(void)
    " N5 E* ?& ~( ^* P- S: i
57. {
    , G1 b, m5 _( d6 u6 E* m
58.     if(__HAL_TIM_GET_FLAG(&htim4, TIM_FLAG_UPDATE))                        // 更新中断标记被置位
    7 n4 G( w+ `* F/ {0 |  r3 |
59.     {
    
60.         __HAL_TIM_CLEAR_FLAG(&htim4, TIM_FLAG_UPDATE);                // 清除中断标记
    # @" P: Y9 ]. o! d- J
61.         prvvTIMERExpiredISR();                                                                // 通知modbus3.5个字符等待时间到
    9 `" G" W- p, {
62.     }
    . V. Q: S4 p+ H5 @, C* J$ e! c
63. }
    
64. 
    ( N, _" W3 J& R/ I' N+ S0 I) x* o
65. 
    

复制代码

修改modbus串口初始化源代码portserial.c文件
% f9 g3 d* p8 M5 p, q         ~~~~~~~~        在该文件中实现串口1的中断服务程序，prvvUARTTxReadyISR和prvvUARTRxISR函数需要填写进中断服务程序，前者得到作用为通知modbus协议栈串口已经空闲可以发送数据了，后者的作用为通知modbus串口1有数据到达，修改后的代码如下：

1. /*
   
2. * FreeModbus Libary: BARE Port
   * Y2 _( w9 G# ^* h3 W( q$ M
3. * Copyright (C) 2006 Christian Walter <<a href="mailto:wolti@sil.at">wolti@sil.at</a>>
   : n) f$ m6 w9 Q& z4 V7 x
4. *
   8 d; V- q# n, c
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
   % y5 u1 v, n/ l) I( y$ V3 s
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,
    
11. * but WITHOUT ANY WARRANTY; without even the implied warranty of
    0 G+ e1 K9 k/ e% M! z) Q) A; d
12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    9 K! S( C5 L6 T0 h/ D
13. * Lesser General Public License for more details.
    
14. *
    
15. * You should have received a copy of the GNU Lesser General Public
    
16. * License along with this library; if not, write to the Free Software
    
17. * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
    / o! N; f& b; Q1 Z* |/ P
18. *
    
19. * File: $Id$
    0 Y1 U/ Q0 b. ~
20. */
      o, Q" h2 z! `9 _5 x9 K7 y
21. 
    
22. #include "port.h"
    
23. #include "usart.h"
    
24. 
    * _8 P% ]0 G' o$ o# \
25. /* ----------------------- Modbus includes ----------------------------------*/
    
26. #include "mb.h"
    
27. #include "mbport.h"
    
28. 
    
29. /* ----------------------- static functions ---------------------------------*/
    + U3 T. o1 D9 I; o5 U
30. static void prvvUARTTxReadyISR( void );
    % N- L) D- }1 N3 d0 F2 i" d, e
31. static void prvvUARTRxISR( void );
    
32. 
    : o0 e0 _" c( m
33. /* ----------------------- Start implementation -----------------------------*/
    % w0 j+ w& K/ x0 U, X0 i, [
34. void
    
35. vMBPortSerialEnable( BOOL xRxEnable, BOOL xTxEnable )
    
36. {
    8 _7 a# G  Y! d- d
37.     if(xRxEnable)
    1 {+ Z- z, n4 d' w7 H+ M' c
38.     {
    
39.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_RXNE);                // 使能接收非空中断
    
40.     }
      K9 z8 F; D# p  ^& F7 w( d% V; R
41.     else
    ) l1 V  t1 [* o" V/ j: N4 d
42.     {
    9 V' t& N  V$ \6 L
43.         __HAL_UART_DISABLE_IT(&huart1, UART_IT_RXNE);                // 禁能接收非空中断
    ' l) y9 t! J' w, E5 }- `1 u. [3 D
44.     }
    
45. 
    / E$ L; c9 l8 K9 C: D  e
46.     if(xTxEnable)
    / Y$ w1 C% ?: a/ J7 V9 k4 `6 Y
47.     {
    
48.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_TXE);                        // 使能发送为空中断
    . U: o, t) |/ C0 _1 R+ K% X" u9 _/ Y
49.     }
    " y2 b( a$ k0 {& l0 n1 Q8 K
50.     else
    ' I, i8 N2 S, V! Y8 {' O/ p2 ?
51.     {
    * K" k0 S6 T" E! P
52.         __HAL_UART_DISABLE_IT(&huart1, UART_IT_TXE);                // 禁能发送为空中断
    $ S5 _2 R4 \# f  Z
53.     }
    , j9 B  n0 g8 V, _6 v0 L) X# i+ @
54. }
    
55. 
    & |2 Q3 g5 A, B2 l
56. BOOL
    
57. xMBPortSerialInit( UCHAR ucPORT, ULONG ulBaudRate, UCHAR ucDataBits, eMBParity eParity )
    
58. {
    * @! D2 B7 x) C, ]/ g
59.     huart1.Instance = USART1;
    ( D; _* M* H0 {! F
60.     huart1.Init.BaudRate = ulBaudRate;
    
61.     huart1.Init.StopBits = UART_STOPBITS_1;
    * M; o) ]* Z) {" f: m
62.     huart1.Init.Mode = UART_MODE_TX_RX;
    5 e# _) g; r; _' s. o( l) o$ l/ P
63.     huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    4 K. x8 U5 C8 l
64.     huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    , ~- S$ E$ Y$ V
65. 
    
66.     switch(eParity)
    5 t6 G4 u8 N- `: P
67.     {
    4 ^9 _: K6 J  b( P3 P, Q. @: E
68.         // 奇校验
    * ?' o( [4 ?- j4 C
69.     case MB_PAR_ODD:
    
70.         huart1.Init.Parity = UART_PARITY_ODD;
    0 t$ V9 i0 M( ]9 d* Q3 z; ]. M" }/ d& l
71.         huart1.Init.WordLength = UART_WORDLENGTH_9B;                        // 带奇偶校验数据位为9bits
    # d0 X3 A( m2 n  e
72.         break;
    
73.         
    
74.         // 偶校验
    ) M+ z: B' V# I) j) T& T4 K/ E
75.     case MB_PAR_EVEN:
    
76.         huart1.Init.Parity = UART_PARITY_EVEN;
    
77.         huart1.Init.WordLength = UART_WORDLENGTH_9B;                        // 带奇偶校验数据位为9bits
    ; g+ c! d3 M3 @6 H# I) |
78.         break;
    & W! {9 q3 z# |4 i) w7 c: j
79.         
    
80.         // 无校验
    " d' J+ L# H: r" K, ~
81.     default:
    ) n1 s* n% ^" D3 P4 `
82.         huart1.Init.Parity = UART_PARITY_NONE;
    - q9 b1 n! ]4 D! T
83.         huart1.Init.WordLength = UART_WORDLENGTH_8B;                        // 无奇偶校验数据位为8bits
    ' y3 [/ }3 e, c" `4 ]% k
84.         break;
    
85.     }
    
86.     return HAL_UART_Init(&huart1) == HAL_OK ? TRUE : FALSE;
    
87. }
    
88. 
    5 X9 b9 t# n' y" k
89. BOOL
    1 d" {5 z: L0 W& ?
90. xMBPortSerialPutByte( CHAR ucByte )
    / K4 i* D0 ^! I0 }% p4 E
91. {
    
92.     USART1->DR = ucByte;
    1 P5 _4 x+ E- n* k# ^8 P
93.     return TRUE;
    + O0 n5 B& s8 A$ @( n9 i# m
94. }
    
95. 
    ( Y1 b# `/ _# [6 t5 i! k, k
96. BOOL
    
97. xMBPortSerialGetByte( CHAR * pucByte )
    
98. {
    - B* t' V3 V$ Q3 [  e( @* A
99.     *pucByte = (USART1->DR & (uint16_t)0x00FF);
    
100.         return TRUE;
     ! `2 z0 b+ a5 f4 a
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
     ' ~5 e. \( K3 D! r
107. * xMBPortSerialPutByte( ) to send the character.
     $ P: K3 V6 p# p+ {
108. */
     9 S% X; n/ G+ f7 h# K
109. static void prvvUARTTxReadyISR( void )
     9 R+ P/ h( @0 u6 |: J8 g; v6 k& h
110. {
     
111.     pxMBFrameCBTransmitterEmpty(  );
     
112. }
     
113. 
     
114. /* Create an interrupt handler for the receive interrupt for your target
     $ G* |3 {2 c8 X& |1 c% N7 a
115. * processor. This function should then call pxMBFrameCBByteReceived( ). The
     
116. * protocol stack will then call xMBPortSerialGetByte( ) to retrieve the
     1 H/ W5 {' U# ~5 `' M  [
117. * character.
     . V  y0 @6 A  @6 g+ v  m! [) T
118. */
     4 \2 l+ G' Y- q& l$ x# v1 X7 E
119. static void prvvUARTRxISR( void )
     
120. {
     & q+ ]& ^# F( o8 `1 m
121.     pxMBFrameCBByteReceived(  );
     & d* p3 a. J/ b0 g' C6 z; K
122. }
     
123. 
     
124. void USART1_IRQHandler(void)
     
125. {
     ! i' m( \4 m0 n7 @6 E' ?6 {
126.     if(__HAL_UART_GET_FLAG(&huart1, UART_FLAG_RXNE))                        // 接收非空中断标记被置位
     
127.     {
     
128.         __HAL_UART_CLEAR_FLAG(&huart1, UART_FLAG_RXNE);                        // 清除中断标记
     5 Z1 |3 u0 N/ W+ P5 ~3 v
129.         prvvUARTRxISR();                                                                                // 通知modbus有数据到达
     ( O8 X8 R* ^% ~( r* D1 v4 H* a
130.     }
     
131. 
     2 [* z- V* }: \0 n0 z; h
132.     if(__HAL_UART_GET_FLAG(&huart1, UART_FLAG_TXE))                                // 发送为空中断标记被置位
     
133.     {
     % @5 z9 `  L3 d9 ~( M( w, Z# O
134.         __HAL_UART_CLEAR_FLAG(&huart1, UART_FLAG_TXE);                        // 清除中断标记
     ; y! a  |5 }, R2 c4 S" W" K
135.         prvvUARTTxReadyISR();                                                                        // 通知modbus数据可以发松
     " Q8 w4 Z' L* t# s$ u
136.     }
     
137. }

复制代码

注意一点，一般如果使用了485芯片的话，那么同一时刻只能接收或者发送，可以将函数vMBPortSerialEnable修改成这样：
+ l. s$ F. j2 ?4 ]
2 Y5 e* a9 e) v  Q1 l- A" V2 q2 M

1. void
   $ u+ G- i6 z. e4 e. R& c
2. vMBPortSerialEnable( BOOL xRxEnable, BOOL xTxEnable )
   
3. {
   3 s) u# M  ~/ i& G' S* u& _0 V
4.     if(xRxEnable)
   
5.     {
   & f; o1 B1 r3 m: a+ M
6.             //
   6 p  Z+ e0 l; V
7.         // 在此处将485芯片设置为接收模式
   7 u& g: N  u6 r+ W, w. o' J/ Z
8.         //
   0 y/ L' N) Z3 L6 ~
9.                 /* do something */
   
10.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_RXNE);                // 使能接收非空中断
    
11.     }
    
12.     else
    
13.     {
    ; u/ b- B0 P) S0 S  A. l/ R, @
14.         __HAL_UART_DISABLE_IT(&huart1, UART_IT_RXNE);                // 禁能接收非空中断
    
15.     }
    
16. 
    
17.     if(xTxEnable)
    
18.     {
    ' |- ?5 x4 G" q
19.             //
    
20.         // 在此处将485芯片设置为发送模式
    2 D& D6 N# T6 i# Z# m
21.         //
    - z0 J" B" G9 a- J
22.         /* do something */
    & [1 O: G0 G; @1 L" D9 m
23.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_TXE);                        // 使能发送为空中断
    + d" l$ D* P- i
24.     }
    
25.     else
    / \! y( f* b* {+ Q2 L+ z
26.     {
    # k% |  A; A2 M; @! G
27.         __HAL_UART_DISABLE_IT(&huart1, UART_IT_TXE);                // 禁能发送为空中断
    
28.     }
    9 U+ ]( G& X* s- y9 ~7 b: ?8 O
29. }

复制代码

编写modbus命令处理回调函数port.c文件
本例程只实现了读取输入寄存器和保持寄存器的功能，详细代码如下：
* `. S! m' k" \. p/ ~. L: t
5 L8 d* D7 M9 j: f+ j; `

1. #include "mb.h"
   ' B5 J4 j! A. z! C/ f7 w! V
2. #include "mbport.h"
   
3. 
   % L$ C7 B! F' t- w1 ?* y. [0 ~
4. 
   
5. // 十路输入寄存器
   
6. #define REG_INPUT_SIZE  10
   0 V- d* s" y; w1 p- u
7. uint16_t REG_INPUT_BUF[REG_INPUT_SIZE];
   
8. 
   9 `' v2 \1 y: ^" m- p/ _
9. 
   ' r* U0 i9 p: |
10. // 十路保持寄存器
    8 i( H2 N- W2 A; S
11. #define REG_HOLD_SIZE   10
    & m& ~3 `0 E1 s" K$ m! |% J
12. uint16_t REG_HOLD_BUF[REG_HOLD_SIZE];
    
13. 
    
14. 
    
15. // 十路线圈
    " V4 A1 @9 r6 {
16. #define REG_COILS_SIZE 10
      O5 I+ K' N/ y* R
17. uint8_t REG_COILS_BUF[REG_COILS_SIZE];
    
18. 
    
19. 
    
20. // 十路离散量
    
21. #define REG_DISC_SIZE  10
    / W& Q' ]9 B& c& w  W
22. uint8_t REG_DISC_BUF[10];
    $ z3 |- e) o* e
23. 
    
24. 
    - R* S% _5 p4 K1 X; {& d% B8 H
25. /// CMD4
    2 \/ V/ q7 _( F2 i
26. eMBErrorCode eMBRegInputCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs )
    8 X1 U) x- X' ~/ J! T  U6 M
27. {
    : y8 j  r- t' M; y5 Q7 R% d' q
28.     USHORT usRegIndex = usAddress - 1;
    
29. 
    7 a% s0 T# ]! L$ }( K
30.     // 非法检测
    
31.     if((usRegIndex + usNRegs) > REG_INPUT_SIZE)
    
32.     {
    8 n# i; d. X$ n" u" t
33.         return MB_ENOREG;
    
34.     }
    
35. 
    6 D' c/ t$ ^9 c/ I1 r: r
36.     // 循环读取
    
37.     while( usNRegs > 0 )
    , M6 _& @6 d; N
38.     {
    
39.         *pucRegBuffer++ = ( unsigned char )( REG_INPUT_BUF[usRegIndex] >> 8 );
    2 `! g; v7 A% v# s. \) X9 t* o& x
40.         *pucRegBuffer++ = ( unsigned char )( REG_INPUT_BUF[usRegIndex] & 0xFF );
    
41.         usRegIndex++;
    
42.         usNRegs--;
    : x! S  f8 T* l8 |# ]' k% r, {
43.     }
    
44. 
    
45.     // 模拟输入寄存器被改变
    & ]3 C, Y$ K4 B. X* o$ g
46.     for(usRegIndex = 0; usRegIndex < REG_INPUT_SIZE; usRegIndex++)
    1 O/ C" o, R, }+ t
47.     {
    * n8 @: K0 A( J7 e' @
48.         REG_INPUT_BUF[usRegIndex]++;
    
49.     }
    
50. 
    
51.     return MB_ENOERR;
      v8 {5 |- R" l& G
52. }
    
53. 
    ) B; _0 u% J/ j( L6 R
54. /// CMD6、3、16
    6 n- _/ t, O2 v
55. eMBErrorCode eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs, eMBRegisterMode eMode )
    
56. {
    6 v  K# d1 ^- F) U  u
57.     USHORT usRegIndex = usAddress - 1;  
    
58. 
    ) L5 ]( V, m: W5 b" ]& D
59.     // 非法检测
    ! V5 o7 d: O. h+ h/ y; j; I. s
60.     if((usRegIndex + usNRegs) > REG_HOLD_SIZE)
    ; D( S* j0 M. W
61.     {
    . \' [- F6 p: u' F1 {# n
62.         return MB_ENOREG;
    4 u; l9 G8 F% r1 L  H" W# b
63.     }
    / w. k+ E' m, o, q
64. 
    ! n  C6 y! o" m
65.         // 写寄存器
    7 j  V) |8 R& Y5 ?0 T
66.     if(eMode == MB_REG_WRITE)
    
67.     {
    
68.         while( usNRegs > 0 )
    - P& _* G, u3 J0 C. i6 i3 k1 S6 V
69.         {
    * S) n5 {2 x5 O- u
70.                         REG_HOLD_BUF[usRegIndex] = (pucRegBuffer[0] << 8) | pucRegBuffer[1];
    ) Y( e  l( O$ e7 \% Q
71.                         pucRegBuffer += 2;
    1 {" O  ?4 d& r
72.             usRegIndex++;
    
73.             usNRegs--;
    
74.         }
    
75.     }
    0 f* D$ e1 v$ t& M9 ^% y
76.         
    4 m9 l. Q0 G  a6 U
77.         // 读寄存器
    . r' Y  h4 b. v; Y' f# n8 v0 Q
78.     else
    
79.     {
    ( Q3 M& J, T- V
80.         while( usNRegs > 0 )
    9 |+ X9 D1 K8 D! r% [7 p, @
81.         {
    2 L( o& H' O' M
82.             *pucRegBuffer++ = ( unsigned char )( REG_HOLD_BUF[usRegIndex] >> 8 );
    ! G- b/ U5 c, I5 p, r6 A! w0 x5 B) g
83.             *pucRegBuffer++ = ( unsigned char )( REG_HOLD_BUF[usRegIndex] & 0xFF );
    $ a- t& I9 t% B  }2 j: C
84.             usRegIndex++;
    6 {* T( f1 `1 t( R+ w- D9 y  d
85.             usNRegs--;
    ; F/ B4 p6 _" E8 C
86.         }
    
87.     }
    
88. 
    
89.     return MB_ENOERR;
    
90. }
    
91. 
    # _7 d5 j9 Q0 d2 |6 B  u# U
92. /// CMD1、5、15
    + F! i: z7 |) h+ P) E. d# w9 z
93. eMBErrorCode eMBRegCoilsCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNCoils, eMBRegisterMode eMode )
    % M2 f3 i6 e$ N  y4 M  G5 k: ~6 g
94. {
    
95.     USHORT usRegIndex   = usAddress - 1;
    
96.     USHORT usCoilGroups = ((usNCoils - 1) / 8 + 1);
    
97.     UCHAR  ucStatus     = 0;
    6 |+ y2 C* _: @- @6 F  Y1 O: l
98.     UCHAR  ucBits       = 0;
    2 F$ @7 f! j9 Z6 c
99.     UCHAR  ucDisp       = 0;
    
100. 
     ; \. [8 f3 }0 V& @1 s
101.     // 非法检测
     * a/ d: o5 \0 X- }. M2 t" T. J% R( U4 `9 `
102.     if((usRegIndex + usNCoils) > REG_COILS_SIZE)
     
103.     {
     ; m. a' V4 F/ l: j1 V8 ?
104.         return MB_ENOREG;
     
105.     }
     
106. 
     
107.     // 写线圈
     7 u9 o1 L; r: F! s. K7 e- _8 X8 K
108.     if(eMode == MB_REG_WRITE)
     
109.     {
     & d. J0 C8 `4 l7 ?( w5 m
110.         while(usCoilGroups--)
     ; a; [: c4 F3 O2 [% E' n0 Z# V# T* V
111.         {
     
112.             ucStatus = *pucRegBuffer++;
     
113.             ucBits   = 8;
     
114.             while((usNCoils--) != 0 && (ucBits--) != 0)
     
115.             {
     
116.                 REG_COILS_BUF[usRegIndex++] = ucStatus & 0X01;
     ( ~1 e: v* F6 x* G, j* K8 Z4 ^
117.                 ucStatus >>= 1;
     
118.             }
     
119.         }
     9 o! [' M+ D/ T$ D2 D) Q% A
120.     }
     5 w8 Z6 }2 g8 m5 m4 }
121. 
     
122.     // 读线圈
     
123.     else
     ' Q1 [6 [0 ^/ q) c! S
124.     {
     
125.         while(usCoilGroups--)
     
126.         {
     
127.             ucDisp = 0;
     
128.             ucBits = 8;
     0 x  k% z* [4 {0 }3 q
129.             while((usNCoils--) != 0 && (ucBits--) != 0)
     0 V' O0 K$ t( b
130.             {
     ! G7 d1 K5 P) G5 o3 _2 M
131.                 ucStatus |= (REG_COILS_BUF[usRegIndex++] << (ucDisp++));
     
132.             }
     + k# w6 R4 |% c- h& o
133.             *pucRegBuffer++ = ucStatus;
     " X7 q$ i" g: a/ x! F# h
134.         }
     - z' I7 e6 e) M1 ~
135.     }
     
136.     return MB_ENOERR;
     # i1 {4 f5 J/ r
137. }
     * f" t+ K  H6 B
138. 
     
139. 
     
140. /// CMD4
     % a3 U$ }, l# K
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;
     % P3 v: [4 q6 ~9 {: V$ d2 u
147.     UCHAR  ucDisp       = 0;
     
148. 
     
149.     // 非法检测
     
150.     if((usRegIndex + usNDiscrete) > REG_DISC_SIZE)
     / a7 {" G/ _1 C
151.     {
     
152.         return MB_ENOREG;
     8 Z2 r  [  ]9 Y
153.     }
     
154. 
     
155.         // 读离散输入
     . j7 {& g+ E  U/ R( u1 \: n
156.         while(usCoilGroups--)
     
157.         {
     5 U7 x9 k. [/ f; d, ~
158.                 ucDisp = 0;
     
159.                 ucBits = 8;
     
160.                 while((usNDiscrete--) != 0 && (ucBits--) != 0)
     + u( p5 I8 R* y, e6 A* W, ^
161.                 {
     4 J7 [5 a; n3 t; R" A
162.                         if(REG_DISC_BUF[usRegIndex])
       s* M) m4 ]# P% K  ?# o
163.                         {
     
164.                                 ucStatus |= (1 << ucDisp);
     : M1 A! E9 V, n4 s' p
165.                         }
     " t, J- n7 ?& p, a3 a& [; |( d: g
166.                         ucDisp++;
     / ?  c8 ]/ N- F0 A% I/ p- H* l
167.                 }
     , S" G) ^& S. L; D2 P6 q* J
168.                 *pucRegBuffer++ = ucStatus;
     2 s4 d4 A8 r, w, N
169.         }
     " `! T2 W# [  b# M" V
170. 
     ( D( ~5 h) `& d2 C" P
171.     // 模拟改变
     1 }( X; Z$ `/ p+ a
172.     for(usRegIndex = 0; usRegIndex < REG_DISC_SIZE; usRegIndex++)
     : ?7 J- L0 R6 E/ v# @
173.     {
     ( A5 O8 o3 h3 y2 F9 x
174.         REG_DISC_BUF[usRegIndex] = !REG_DISC_BUF[usRegIndex];
     ) b: k! x( ^+ v- g
175.     }
     
176. 
     
177.     return MB_ENOERR;
     3 Y3 \! s/ B/ s" p
178. }

复制代码

1 m8 P( t: c  z% i  j2 i主函数

1. int main(void)
   , h, q) ?& ?" l/ Z8 Q6 c
2. {
   . j# F5 L; t7 G% w# ]# l
3.     HAL_Init();
   
4.     SystemClock_Config();
   5 |% w/ [' r' ?' O! b/ V  i8 ^% ?
5.     MX_GPIO_Init();
   9 }2 J" g% E1 h" N6 t' _, L
6.     eMBInit(MB_RTU, 0x01, 0, 9600, MB_PAR_ODD);                // 初始化modbus为RTU方式，波特率9600，奇校验
   
7.     eMBEnable();                                                                        // 使能modbus协议栈
   
8. 
   
9.     for( ;; )
   
10.     {
    ( m# }  ]2 Y* }6 |+ t
11.         eMBPoll();                                                                        // 轮训查询
    5 `# V3 s3 \3 b/ X* U6 P& R
12.     }
    " ]' ]) J4 F' g  c6 g: w
13. }

复制代码

! d7 a6 ?- o5 n* t2 b. N移植测试
  d. T, G% x2 d& m

  ~' s  C8 v: A4 T7 H
( ~+ J+ ]- E2 J5 P8 V5 H/ V! M$ }* bends…

' }. H" q6 k% n+ g5 n1 y# E
7 w2 d" S2 g0 c& C# E. Q4 ~

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