modbus命令码表：


% [" k  h5 w( S3 k+ x9 m
FreeModbus文件说明
      解压freemodbus文件后打开，我们需要demo目录下的BARE，该目录下的代码是空的，STM32移植工作基本就是修改：portserial.c、porttimer.c、port.h这三个文件。


      mobus文件夹就是完整的源码，包含rtu、ascii、tcp：
$ Y  G1 l( R6 R/ G0 ]0 N
% M% {' ]0 {6 I$ E4 X" D3 L
5 w. H4 G. _) M) ?& q
      我为了移植时在keil添加源文件和头文件方便，就把modbus所有的头文件和源文件放到了一个文件夹下，并创建了一个port.c文件，用于编写modbus所必需的回调处理函数：
) Y; P  ~) k  @8 r% P

% `3 P( Q! [  I2 p" {+ G
4 P- @2 J1 r5 _6 b: r' z+ @STM32CUBEMX配置
时钟配置，设置主频工作在72MHz下：
6 E0 b& R7 k: c; I0 H- R$ A: Y( j' F
* w: q; |9 U; M
# s* p1 S7 S- u) T& {! x& A& R
配置串口1，这里随便配置就行，在modbus移植过程中还会对串口重新初始化：
# P" {1 |" ]& Z: `' l
3 Q1 P4 Z" g& i/ `3 }& v8 N4 W
! J. T) @3 i( f6 `! S% P( `" _" W
配置定时器4，用于3.5个字符的定时检测，这里随便配置就行，在modbus移植过程中还会对定时器重新初始化：
6 D# F- s: k  M7 P: ^


& x) a( v; w1 S中断配置，这里注意，串口的优先级是要比定时器优先高的：
4 h1 w7 g  x- {; U9 \+ ?' D
9 @+ }' j4 U. G4 \
* p8 M( _$ p; y5 r& Z5 w0 q2 q取消掉自动生成中断服务程序，在移植过程中我们要自己编写串口和定时器的中断服务程序：

( t: o" f- \: `( k, g; ]1 V2 M

移植代码修改
, b9 S& X) D  A% f2 a- L; J/ [生成代码后将modbus放到工程目录下：



打开keil工程添加modbus源码：
4 G" C" c: |( P  Q- M8 o' y
3 o7 v5 C: x, @. w7 j% b

; a2 S. i6 b8 E# S; F添加包含头文件：
- V% f! Z! K& `; K/ t


修改modbus定时器初始化源代码porttimer.c文件
       定时器的修改比较容易，将定时器设置为每50us的时长记一个数，传入的usTim1Timerout50us变量给自动装载即可，prvvTIMERExpiredISR函数需要在定时器中断服务函数中调用，它的作用是用于通知modbus协议栈3.5个字符的等待时间已经到达；由于我们在STM32CUBEMX中取消掉了定时器和串口的中断服务函数程序，所以我们在该文件中添加定时器的中断服务程序，修改后的代码如下：
; K5 Y! ]% A3 w6 T+ F) H
( C1 d/ g9 R# a# A; A$ L& I" S

1. BOOL
   % K+ Z( M# p/ Y
2. xMBPortTimersInit( USHORT usTim1Timerout50us )
   
3. {
   
4.     TIM_ClockConfigTypeDef sClockSourceConfig = {0};
   
5.     TIM_MasterConfigTypeDef sMasterConfig = {0};
   
6. 
   + B+ B2 b$ T: O4 k+ j" _7 T
7.     htim4.Instance = TIM4;
   
8.     htim4.Init.Prescaler = 3599;                                                                // 50us记一次数
   % x& \4 s( r0 {7 T1 _. M3 ~; z
9.     htim4.Init.CounterMode = TIM_COUNTERMODE_UP;
   
10.     htim4.Init.Period = usTim1Timerout50us - 1;                                        // usTim1Timerout50us * 50即为定时器溢出时间
    
11.     htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    " C# T. d% X( |) w  W2 I
12.     htim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
    9 ]$ c0 m& u, k4 a- w( M
13.     if (HAL_TIM_Base_Init(&htim4) != HAL_OK)
    
14.     {
    
15.         return FALSE;
    ; ~  z0 A5 n' u4 s0 D/ m
16.     }
    9 Q) }9 Q; F, ]$ L
17.     sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
    ! O) _# Z# Q, U" J7 d, f
18.     if (HAL_TIM_ConfigClockSource(&htim4, &sClockSourceConfig) != HAL_OK)
    9 F, a) `6 S% g+ B/ d$ R
19.     {
    2 e- e5 m; O" i0 n9 k
20.         return FALSE;
    
21.     }
    ( G' L: H9 i) @$ y$ F4 @
22.     sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
    
23.     sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
    ; d9 u$ v" [" J4 y( M. b. }
24.     if (HAL_TIMEx_MasterConfigSynchronization(&htim4, &sMasterConfig) != HAL_OK)
    
25.     {
    6 h5 J) M* _! x: e, L: l' Z% l( g
26.         return FALSE;
    
27.     }
    & I! L+ w2 N% S  I+ O2 g! t
28. 
    ! N( b9 b- L3 n1 R7 u+ _/ ^
29.     __HAL_TIM_ENABLE_IT(&htim4, TIM_IT_UPDATE);                                        // 使能定时器更新中断
    
30.     return TRUE;
    2 J; m$ i- x$ N% w* s
31. }
    5 k  W( h, n! Y- V% K. H
32. 
    : [4 Z# p# o5 p2 @
33. inline void
    
34. vMBPortTimersEnable(  )
    
35. {
    
36.     __HAL_TIM_SET_COUNTER(&htim4, 0);                // 清空计数器
    
37.     __HAL_TIM_ENABLE(&htim4);                                // 使能定时器
    
38. }
    4 p: D9 w, I5 x2 f
39. 
    / x0 u) }% W$ J+ C% r7 J/ G
40. inline void
    : V; f( ~. m: P9 a) \
41. vMBPortTimersDisable(  )
    8 Q" q6 X  I6 h  T' W/ @$ ~: Z
42. {
    
43.     __HAL_TIM_DISABLE(&htim4);                                // 禁能定时器
    
44. }
    
45. 
    0 U0 j5 [4 v) E3 z9 ~. ]" v
46. /* Create an ISR which is called whenever the timer has expired. This function
    5 Y( c4 E. Z! f! `
47. * must then call pxMBPortCBTimerExpired( ) to notify the protocol stack that
    
48. * the timer has expired.
    3 s" a( h! P* R0 N' A
49. */
    7 V5 F0 R, W8 S
50. static void prvvTIMERExpiredISR( void )
    
51. {
    ' Y+ [' p+ x) y2 v/ I2 g
52.     ( void )pxMBPortCBTimerExpired(  );
    
53. }
    5 U1 a' |) g3 c) s2 e
54. 
    
55. /// 定时器4中断服务程序
    
56. void TIM4_IRQHandler(void)
    
57. {
    4 o9 f! b' S4 w, I
58.     if(__HAL_TIM_GET_FLAG(&htim4, TIM_FLAG_UPDATE))                        // 更新中断标记被置位
    
59.     {
    : g3 G. ^1 Y& [  P, X( L, O
60.         __HAL_TIM_CLEAR_FLAG(&htim4, TIM_FLAG_UPDATE);                // 清除中断标记
    
61.         prvvTIMERExpiredISR();                                                                // 通知modbus3.5个字符等待时间到
    
62.     }
    % K" n! G5 `0 y3 @: P! O3 M  r- A
63. }
    
64. 
    
65. 
    , p0 l9 c6 p( X* i) m( `( N

复制代码

修改modbus串口初始化源代码portserial.c文件
0 u) Z5 ]$ F$ J! ]9 H, G  l: j' \         ~~~~~~~~        在该文件中实现串口1的中断服务程序，prvvUARTTxReadyISR和prvvUARTRxISR函数需要填写进中断服务程序，前者得到作用为通知modbus协议栈串口已经空闲可以发送数据了，后者的作用为通知modbus串口1有数据到达，修改后的代码如下：
9 `  ~6 `  v. ^, p9 W8 b

1. /*
   / w, g1 l8 _3 `9 Y
2. * FreeModbus Libary: BARE Port
   1 E* T1 C. [! M) j0 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
   1 z) B- y8 |3 G; g' {6 p" _
7. * License as published by the Free Software Foundation; either
   
8. * version 2.1 of the License, or (at your option) any later version.
   ) d6 T; R: G% I) e$ E+ j
9. *
   3 K; ?3 f8 X* S6 P2 \, O: s
10. * This library is distributed in the hope that it will be useful,
    5 L1 z4 m0 s3 }3 i1 A" x3 I  K
11. * but WITHOUT ANY WARRANTY; without even the implied warranty of
    1 M; Q- P1 G- a: B7 ]
12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    - F8 y' J) d3 m5 l9 S. U
13. * Lesser General Public License for more details.
    1 \* _1 E1 i/ Z" j+ f' y& G& \
14. *
    ( T0 @; E3 t- p5 X3 F% h6 ], L" u) O
15. * You should have received a copy of the GNU Lesser General Public
    $ r" q' g8 O3 ~
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
    ) f& @2 V, y$ h, k
18. *
    
19. * File: $Id$
    - R  v7 d$ ?/ z' a, a
20. */
    
21. 
    9 s* d# p- Q% V" `& i9 Y  E+ |. z
22. #include "port.h"
    0 n. l+ X; _9 K
23. #include "usart.h"
    2 Q) j6 N6 d' j- ~- E
24. 
    - i6 e4 E. B! W3 J
25. /* ----------------------- Modbus includes ----------------------------------*/
    ; o0 |, l% }* ?) D: T. W* P0 x/ K* M
26. #include "mb.h"
    ; X+ |6 A; j) ]( y
27. #include "mbport.h"
    
28. 
    0 M0 E. n  s' ?) F- ]" p7 I
29. /* ----------------------- static functions ---------------------------------*/
    - B: s7 }) h: j7 N% |- c
30. static void prvvUARTTxReadyISR( void );
    0 M, t# X$ e0 u
31. static void prvvUARTRxISR( void );
    
32. 
    
33. /* ----------------------- Start implementation -----------------------------*/
    / H9 H7 o5 N0 P0 g+ Z
34. void
    
35. vMBPortSerialEnable( BOOL xRxEnable, BOOL xTxEnable )
    
36. {
    
37.     if(xRxEnable)
    
38.     {
    4 Z& o& X$ w* \* |
39.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_RXNE);                // 使能接收非空中断
    
40.     }
    # O* N8 ~2 G( p, L9 I# x
41.     else
    
42.     {
    
43.         __HAL_UART_DISABLE_IT(&huart1, UART_IT_RXNE);                // 禁能接收非空中断
    
44.     }
    
45. 
    
46.     if(xTxEnable)
    ' D& I4 }( [. B
47.     {
    ) @% R! D" n( {% @- x3 T
48.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_TXE);                        // 使能发送为空中断
    
49.     }
    8 Y  }! k9 u7 P! i4 S+ ]
50.     else
    
51.     {
    - O$ e2 ^! U# R8 n& H
52.         __HAL_UART_DISABLE_IT(&huart1, UART_IT_TXE);                // 禁能发送为空中断
    
53.     }
    
54. }
    3 r5 x) F0 l/ s0 D: F
55. 
    
56. BOOL
    " v0 \. b8 M0 D& c- F% e$ Y; Y6 d
57. xMBPortSerialInit( UCHAR ucPORT, ULONG ulBaudRate, UCHAR ucDataBits, eMBParity eParity )
    * w: b( }* a- R) v! R
58. {
    ! E7 w% l$ a5 I7 g9 {& M0 v2 ]
59.     huart1.Instance = USART1;
    
60.     huart1.Init.BaudRate = ulBaudRate;
    3 ^9 D3 ?# c, S
61.     huart1.Init.StopBits = UART_STOPBITS_1;
    " P1 u7 p0 o. P! b" U$ y: a
62.     huart1.Init.Mode = UART_MODE_TX_RX;
    
63.     huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    " Q/ p5 G& Q4 z
64.     huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    , d5 g8 T  w& }- M* B
65. 
    5 e$ L& Q4 J8 b( O3 R+ H
66.     switch(eParity)
    
67.     {
    
68.         // 奇校验
    / Q! `9 m/ K7 B/ G
69.     case MB_PAR_ODD:
    
70.         huart1.Init.Parity = UART_PARITY_ODD;
    6 |: _  e7 s% h& K$ I7 B( J
71.         huart1.Init.WordLength = UART_WORDLENGTH_9B;                        // 带奇偶校验数据位为9bits
    
72.         break;
    
73.         
    5 f. Y9 Q6 n+ R" f+ u/ d7 j
74.         // 偶校验
    
75.     case MB_PAR_EVEN:
    0 X  w  t. V& h" p8 ]& H
76.         huart1.Init.Parity = UART_PARITY_EVEN;
    
77.         huart1.Init.WordLength = UART_WORDLENGTH_9B;                        // 带奇偶校验数据位为9bits
    
78.         break;
    3 X+ a) e( }! O7 M3 y
79.         
    1 L* l* s! O1 n# Z: r& M" N
80.         // 无校验
    
81.     default:
    - E  ?6 b, x- t5 M5 o- o
82.         huart1.Init.Parity = UART_PARITY_NONE;
    8 m$ C" y6 ]# H/ M
83.         huart1.Init.WordLength = UART_WORDLENGTH_8B;                        // 无奇偶校验数据位为8bits
    
84.         break;
    $ E" h4 G% y# q# ^% j
85.     }
    ) N/ v* k; }) y  r1 w
86.     return HAL_UART_Init(&huart1) == HAL_OK ? TRUE : FALSE;
    
87. }
    
88. 
    
89. BOOL
    1 V! L# K' h& Z
90. xMBPortSerialPutByte( CHAR ucByte )
    0 j4 C# v# x4 O2 X3 D
91. {
    
92.     USART1->DR = ucByte;
    - W/ D2 `; b( B/ i0 x2 d9 z
93.     return TRUE;
    
94. }
    
95. 
    * w( p( m/ L4 {8 y7 u
96. BOOL
    
97. xMBPortSerialGetByte( CHAR * pucByte )
    4 S5 q5 B, G1 {' H% A, l9 ~
98. {
    " D4 g) Q& q7 \, B; J
99.     *pucByte = (USART1->DR & (uint16_t)0x00FF);
    
100.         return TRUE;
     
101. }
     
102. 
     ; G3 t; W2 G; i& t2 Y8 l( J4 a! ^; e- x
103. /* Create an interrupt handler for the transmit buffer empty interrupt
     3 a+ I. t8 J! F& K
104. * (or an equivalent) for your target processor. This function should then
     5 ~5 s; x" D7 n' x! w& O
105. * call pxMBFrameCBTransmitterEmpty( ) which tells the protocol stack that
     7 O4 s1 H4 G- Y3 Y- d
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 )
     / O$ A5 e4 c7 C* Y6 M+ G/ _9 O
110. {
     0 @: V3 P' x, l' K' i
111.     pxMBFrameCBTransmitterEmpty(  );
     ' e$ I$ R2 k( R/ G) T  C8 l
112. }
     
113. 
     
114. /* Create an interrupt handler for the receive interrupt for your target
     
115. * processor. This function should then call pxMBFrameCBByteReceived( ). The
     
116. * protocol stack will then call xMBPortSerialGetByte( ) to retrieve the
     5 X" l, Z0 Z5 t3 t6 B3 H
117. * character.
     , R# \- p, Y7 M! i% s
118. */
     
119. static void prvvUARTRxISR( void )
     
120. {
     
121.     pxMBFrameCBByteReceived(  );
     
122. }
     
123. 
     $ }1 B7 O6 Y# ~- j0 F
124. void USART1_IRQHandler(void)
     
125. {
     . P1 M0 _, F5 Q, k8 o9 @9 I1 ^2 n
126.     if(__HAL_UART_GET_FLAG(&huart1, UART_FLAG_RXNE))                        // 接收非空中断标记被置位
       i1 K  E, @: [* O* p7 n1 S) [
127.     {
     
128.         __HAL_UART_CLEAR_FLAG(&huart1, UART_FLAG_RXNE);                        // 清除中断标记
     
129.         prvvUARTRxISR();                                                                                // 通知modbus有数据到达
     
130.     }
     
131. 
     
132.     if(__HAL_UART_GET_FLAG(&huart1, UART_FLAG_TXE))                                // 发送为空中断标记被置位
     
133.     {
     
134.         __HAL_UART_CLEAR_FLAG(&huart1, UART_FLAG_TXE);                        // 清除中断标记
     8 N. w4 s1 d. O1 U- `9 k
135.         prvvUARTTxReadyISR();                                                                        // 通知modbus数据可以发松
     
136.     }
     
137. }

复制代码

注意一点，一般如果使用了485芯片的话，那么同一时刻只能接收或者发送，可以将函数vMBPortSerialEnable修改成这样：

8 d* O5 o; @" b9 _6 H

1. void
   
2. vMBPortSerialEnable( BOOL xRxEnable, BOOL xTxEnable )
   3 _) ^  h$ @. s" p
3. {
   ' z* G& m  ^: A/ w  o# l
4.     if(xRxEnable)
   1 G8 N, @+ u& B
5.     {
   * q& w! c; i# ~3 p( K+ w8 w1 K
6.             //
   % p  P( h; i7 `5 c/ v: o
7.         // 在此处将485芯片设置为接收模式
   
8.         //
   
9.                 /* do something */
   
10.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_RXNE);                // 使能接收非空中断
    
11.     }
    
12.     else
    5 v, f3 `; n8 b6 g5 X
13.     {
    
14.         __HAL_UART_DISABLE_IT(&huart1, UART_IT_RXNE);                // 禁能接收非空中断
    
15.     }
    7 c/ ]. Z! b* W
16. 
    5 ^! I5 z6 G+ ~3 H, @
17.     if(xTxEnable)
    # ]# O9 [: b+ D0 d  t% p8 v
18.     {
    * w% v. K* n5 ^6 i# s
19.             //
    & A9 r8 m+ S/ B- k' e) l) ?$ j
20.         // 在此处将485芯片设置为发送模式
    
21.         //
    # M& G; {! Z" ~6 B4 p/ c" z9 M
22.         /* do something */
    ( G) j4 j( W0 M/ Z; J3 h
23.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_TXE);                        // 使能发送为空中断
    ! D$ g! T7 N3 H
24.     }
    
25.     else
    
26.     {
    
27.         __HAL_UART_DISABLE_IT(&huart1, UART_IT_TXE);                // 禁能发送为空中断
    # J9 U; s& {2 ?) B4 Y8 |& ^: W4 C6 K
28.     }
    
29. }

复制代码

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

1. #include "mb.h"
   ! m3 t! q" f' C- x* M& u
2. #include "mbport.h"
   
3. 
   1 D6 Y% ^3 I$ g% a. g; `
4. 
   0 y/ C) C% r1 g2 N" b6 T$ _
5. // 十路输入寄存器
   
6. #define REG_INPUT_SIZE  10
   " k$ U: _! Z; b/ o/ r# _3 [$ ~
7. uint16_t REG_INPUT_BUF[REG_INPUT_SIZE];
   
8. 
   : l9 D! ]" i: r" q6 S
9. 
   
10. // 十路保持寄存器
    
11. #define REG_HOLD_SIZE   10
    & H. x3 f. V; r
12. uint16_t REG_HOLD_BUF[REG_HOLD_SIZE];
    2 @* g( ^0 G7 R! t' O
13. 
    
14. 
    
15. // 十路线圈
    * M) H) M% z% T1 v/ i7 v  W- a$ ?
16. #define REG_COILS_SIZE 10
    , X# j# {) t, T% h
17. uint8_t REG_COILS_BUF[REG_COILS_SIZE];
    # I; b  H/ O7 z
18. 
    8 j/ C& y6 w' T, e
19. 
    , V, r" Z6 V: o2 k0 Q3 k+ J
20. // 十路离散量
    
21. #define REG_DISC_SIZE  10
    : L1 @, Y  O2 ^
22. uint8_t REG_DISC_BUF[10];
    
23. 
    
24. 
    ( L5 R# V% ?+ A: s' c
25. /// CMD4
    . a4 S  g9 l  ]% J/ \
26. eMBErrorCode eMBRegInputCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs )
      w( c& E1 M" `* J# g/ l& Y# f+ R1 b# Z
27. {
    2 g- |5 n7 S( h6 k' A3 [
28.     USHORT usRegIndex = usAddress - 1;
    
29. 
    
30.     // 非法检测
    - g9 X; E$ {$ X
31.     if((usRegIndex + usNRegs) > REG_INPUT_SIZE)
    
32.     {
    ) d- @& j/ a" \" y! k" F6 G/ A
33.         return MB_ENOREG;
    
34.     }
    
35. 
    
36.     // 循环读取
    . r4 }9 B2 R9 h& Y) \, M% A
37.     while( usNRegs > 0 )
    ' ~' a2 Y3 h: e0 S' X
38.     {
    - B( `4 }6 t- b% @
39.         *pucRegBuffer++ = ( unsigned char )( REG_INPUT_BUF[usRegIndex] >> 8 );
    
40.         *pucRegBuffer++ = ( unsigned char )( REG_INPUT_BUF[usRegIndex] & 0xFF );
    $ K0 M) `$ F8 s4 ]1 Q
41.         usRegIndex++;
    1 I& t- A7 ^* i( ?/ x# R) l
42.         usNRegs--;
    
43.     }
    
44. 
    ) \8 V8 L+ [- \/ B/ e8 G, ~
45.     // 模拟输入寄存器被改变
    : s0 C" _( W5 X! Y# M% _2 Y3 I% u
46.     for(usRegIndex = 0; usRegIndex < REG_INPUT_SIZE; usRegIndex++)
    4 I7 N5 f7 I+ E  s0 O/ J
47.     {
    
48.         REG_INPUT_BUF[usRegIndex]++;
    # |% M# `! N) q2 K& b, ?
49.     }
    
50. 
    
51.     return MB_ENOERR;
    ( R5 ]$ a) H7 `) k$ W( w; @
52. }
    & }/ l; q" t2 V, X3 t7 H
53. 
    
54. /// CMD6、3、16
    6 [: R$ h/ y! R" s" _. d. q; ]. J
55. eMBErrorCode eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs, eMBRegisterMode eMode )
    
56. {
    # D$ Y3 q. _6 Z# E/ e
57.     USHORT usRegIndex = usAddress - 1;  
    
58. 
    / r3 ?  J% ^1 P/ p( j' {
59.     // 非法检测
    
60.     if((usRegIndex + usNRegs) > REG_HOLD_SIZE)
    
61.     {
    
62.         return MB_ENOREG;
    
63.     }
    
64. 
    
65.         // 写寄存器
    ; J( B( n" S* l
66.     if(eMode == MB_REG_WRITE)
    5 i8 W/ z3 ~! I
67.     {
    
68.         while( usNRegs > 0 )
    
69.         {
      n% ~, B' m" A5 S7 ]6 x! G  e: ?
70.                         REG_HOLD_BUF[usRegIndex] = (pucRegBuffer[0] << 8) | pucRegBuffer[1];
    / [, l8 r: b  z: F5 d% [
71.                         pucRegBuffer += 2;
    : T" Z3 Z" {7 t' V) \& [
72.             usRegIndex++;
    * n% Q# J1 h) _% g( J
73.             usNRegs--;
    
74.         }
    
75.     }
    
76.         
    
77.         // 读寄存器
    ' F6 ^, s7 y3 {  G
78.     else
    6 r9 X. S7 H- l6 y" h) G
79.     {
    ) \  z) S. k7 W; k
80.         while( usNRegs > 0 )
    
81.         {
    
82.             *pucRegBuffer++ = ( unsigned char )( REG_HOLD_BUF[usRegIndex] >> 8 );
    ) W1 S: L. o; d$ k* G1 f: F. `
83.             *pucRegBuffer++ = ( unsigned char )( REG_HOLD_BUF[usRegIndex] & 0xFF );
    , p' X, n1 b8 m, \' G+ |
84.             usRegIndex++;
    
85.             usNRegs--;
    
86.         }
    
87.     }
    9 l+ T+ b* Y- e
88. 
    " h4 I. e. R5 M8 ^$ e
89.     return MB_ENOERR;
    8 s+ i: p0 s+ c' L" t6 w3 {- ~+ B: o
90. }
    ! v1 J* q1 t5 \8 G
91. 
    : e9 l" W' Q$ H, U' h7 B% n3 h
92. /// CMD1、5、15
    
93. eMBErrorCode eMBRegCoilsCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNCoils, eMBRegisterMode eMode )
    
94. {
    
95.     USHORT usRegIndex   = usAddress - 1;
    5 }6 M7 s- F2 l& S
96.     USHORT usCoilGroups = ((usNCoils - 1) / 8 + 1);
    
97.     UCHAR  ucStatus     = 0;
    # a. T, }& x7 B; ^
98.     UCHAR  ucBits       = 0;
    / p" k# q+ P5 U9 a. l
99.     UCHAR  ucDisp       = 0;
    
100. 
     : W+ u! }0 B0 y5 T  m/ e, t
101.     // 非法检测
     & B+ n) G$ Y  K0 m, F9 A
102.     if((usRegIndex + usNCoils) > REG_COILS_SIZE)
     
103.     {
     " W! }3 W# I/ G' P; [3 \
104.         return MB_ENOREG;
     
105.     }
     
106. 
     ! n% J- w- c: A5 _/ Y
107.     // 写线圈
     
108.     if(eMode == MB_REG_WRITE)
     
109.     {
     
110.         while(usCoilGroups--)
     6 q& K% P* J% k' I; ?
111.         {
     - t6 a: {( z; @4 _' y
112.             ucStatus = *pucRegBuffer++;
     
113.             ucBits   = 8;
     
114.             while((usNCoils--) != 0 && (ucBits--) != 0)
     
115.             {
     ( f. C5 \4 K1 `$ d
116.                 REG_COILS_BUF[usRegIndex++] = ucStatus & 0X01;
     . f; s9 |- L! w4 `4 n& Z% t
117.                 ucStatus >>= 1;
     9 h$ p0 c. U2 V% e
118.             }
     
119.         }
     
120.     }
     + S) k# \! F0 H- r$ z; w/ a
121. 
     
122.     // 读线圈
     
123.     else
     5 p6 X; z, V" k* y# d6 |0 R
124.     {
     # c" \% }# H! h! s; j
125.         while(usCoilGroups--)
     ( A) T1 `% f6 M) v! {; b
126.         {
     * x4 ]0 Y2 d: f1 F
127.             ucDisp = 0;
     
128.             ucBits = 8;
     
129.             while((usNCoils--) != 0 && (ucBits--) != 0)
     
130.             {
     * \- g/ U8 s- [) ^9 p
131.                 ucStatus |= (REG_COILS_BUF[usRegIndex++] << (ucDisp++));
     
132.             }
     
133.             *pucRegBuffer++ = ucStatus;
     " T, f! t9 U! O& l
134.         }
     
135.     }
     
136.     return MB_ENOERR;
     
137. }
     
138. 
     - v3 V$ a5 m% }6 E
139. 
     4 X* W2 Q1 ?! {9 r  ^
140. /// CMD4
     
141. eMBErrorCode eMBRegDiscreteCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNDiscrete )
     7 A# k' r3 |( |4 @1 [1 z
142. {
     
143.     USHORT usRegIndex   = usAddress - 1;
       k9 J  W6 P0 U' l4 ?
144.     USHORT usCoilGroups = ((usNDiscrete - 1) / 8 + 1);
     ( y% C% X& [) R+ k! M
145.     UCHAR  ucStatus     = 0;
     
146.     UCHAR  ucBits       = 0;
     9 G! F. `4 y/ N+ q4 }4 A
147.     UCHAR  ucDisp       = 0;
     4 G" h. X1 Q! o
148. 
     6 Y- E# R; {$ n3 v1 y
149.     // 非法检测
     
150.     if((usRegIndex + usNDiscrete) > REG_DISC_SIZE)
     & F  m6 a. P8 a+ \
151.     {
     
152.         return MB_ENOREG;
     
153.     }
     # p3 b. o+ P( E0 o" _( _' H
154. 
     . t) {" z3 _, T5 M
155.         // 读离散输入
     
156.         while(usCoilGroups--)
     + V1 @. ]9 D# y% F% ?
157.         {
     4 H8 A4 J7 m+ _" N: f. y, Y) f
158.                 ucDisp = 0;
     
159.                 ucBits = 8;
     
160.                 while((usNDiscrete--) != 0 && (ucBits--) != 0)
     
161.                 {
     
162.                         if(REG_DISC_BUF[usRegIndex])
     
163.                         {
     4 }% X& w( ?& ]8 `
164.                                 ucStatus |= (1 << ucDisp);
     
165.                         }
     
166.                         ucDisp++;
     
167.                 }
     
168.                 *pucRegBuffer++ = ucStatus;
     ; r9 P# o" Y- K5 E, a; }
169.         }
     
170. 
     8 ]% q0 Y& U! O" _& L
171.     // 模拟改变
     2 [) [( B0 r5 |: H3 k0 M
172.     for(usRegIndex = 0; usRegIndex < REG_DISC_SIZE; usRegIndex++)
     & F% \$ K. S# Y2 `- Z! I- O/ U, D; J
173.     {
     2 _7 }; Y# B- M$ x- s3 K
174.         REG_DISC_BUF[usRegIndex] = !REG_DISC_BUF[usRegIndex];
     $ l( y- u* A7 m
175.     }
     # ~9 W& s4 h) s" r& W
176. 
     : a5 g% }8 B! }3 X6 c
177.     return MB_ENOERR;
     
178. }

复制代码

主函数
/ L$ u, K" K, B3 @. w" ~, P) D+ v

1. int main(void)
   & r4 V' t; Q2 g# I: F3 t
2. {
   ; @- r$ m/ c9 _% j
3.     HAL_Init();
   
4.     SystemClock_Config();
   6 D& _$ S( Z. D$ {* Y! ~5 v
5.     MX_GPIO_Init();
   
6.     eMBInit(MB_RTU, 0x01, 0, 9600, MB_PAR_ODD);                // 初始化modbus为RTU方式，波特率9600，奇校验
   & |" \: y2 u4 W4 F& [. X/ o
7.     eMBEnable();                                                                        // 使能modbus协议栈
   * x9 D- H! Q5 ~) N" g
8. 
   9 R: B) W, ]# X! `+ g1 u5 ^# x
9.     for( ;; )
   8 [3 G* z9 y" Y( R. B9 u
10.     {
    / [! I( z. x6 [% F+ u
11.         eMBPoll();                                                                        // 轮训查询
    
12.     }
    * [  R" u+ S% f1 j
13. }

复制代码

移植测试

( ?* e; S8 ^6 A$ n
! i5 S/ P; v) Z1 ^
3 J3 b0 g+ u( v0 W# j# G3 lends…

1 T; E/ V3 ]5 k- H
3 x) \& ~5 b; \/ Q8 t

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