modbus命令码表：


8 j7 t2 K+ h$ s/ R& d2 o" z
FreeModbus文件说明
      解压freemodbus文件后打开，我们需要demo目录下的BARE，该目录下的代码是空的，STM32移植工作基本就是修改：portserial.c、porttimer.c、port.h这三个文件。
; l% W: x, Y" x, J3 ]

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



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

! C0 o' l: X% ~; X1 d

( y9 G! M4 \* z  GSTM32CUBEMX配置
时钟配置，设置主频工作在72MHz下：


2 g( c# v% k9 \
配置串口1，这里随便配置就行，在modbus移植过程中还会对串口重新初始化：
6 n! {' G, Y# w. o  `0 u# }
) e9 X4 D* z' H; e

/ r2 D( p, _/ z! e# G9 ?配置定时器4，用于3.5个字符的定时检测，这里随便配置就行，在modbus移植过程中还会对定时器重新初始化：



- }' h: G+ @5 W( j0 d中断配置，这里注意，串口的优先级是要比定时器优先高的：
. o7 ?1 j9 {2 j6 v4 W5 t  n

0 G' u* @$ I* [# O% ^取消掉自动生成中断服务程序，在移植过程中我们要自己编写串口和定时器的中断服务程序：

2 g" d# k) c8 Q  w& p' Q! F0 _
; n' V- T- E8 e# `
. d1 {) j8 [" F1 V移植代码修改
生成代码后将modbus放到工程目录下：
9 P9 U1 p' t% T% q3 w0 @


打开keil工程添加modbus源码：
' N8 G. n9 Z8 S

; P2 E3 r. D1 ~3 `) f8 z1 W/ m& R
添加包含头文件：

, r! J7 P9 l# g6 Z9 @# d. `( V. x! _

" `  D: {  }! G# E, ^修改modbus定时器初始化源代码porttimer.c文件
  W+ }; z. V. F( s, x8 R       定时器的修改比较容易，将定时器设置为每50us的时长记一个数，传入的usTim1Timerout50us变量给自动装载即可，prvvTIMERExpiredISR函数需要在定时器中断服务函数中调用，它的作用是用于通知modbus协议栈3.5个字符的等待时间已经到达；由于我们在STM32CUBEMX中取消掉了定时器和串口的中断服务函数程序，所以我们在该文件中添加定时器的中断服务程序，修改后的代码如下：
  q4 k# T, M! V' y" A

1. BOOL
   4 p# H2 C5 V/ f6 A
2. xMBPortTimersInit( USHORT usTim1Timerout50us )
   
3. {
   
4.     TIM_ClockConfigTypeDef sClockSourceConfig = {0};
   ! G- i6 J; H& p3 [: {* G
5.     TIM_MasterConfigTypeDef sMasterConfig = {0};
   
6. 
   
7.     htim4.Instance = TIM4;
   & E+ X' R8 J( R* E4 L
8.     htim4.Init.Prescaler = 3599;                                                                // 50us记一次数
   
9.     htim4.Init.CounterMode = TIM_COUNTERMODE_UP;
   $ {" |4 D6 A, p' _2 X
10.     htim4.Init.Period = usTim1Timerout50us - 1;                                        // usTim1Timerout50us * 50即为定时器溢出时间
    
11.     htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    
12.     htim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
    4 x' P6 i- }0 t! G0 u- M
13.     if (HAL_TIM_Base_Init(&htim4) != HAL_OK)
    " H# K5 ~, y: [# u
14.     {
    
15.         return FALSE;
    
16.     }
    / f7 k, M) o: ^0 z0 ^& h6 c5 W0 ~3 K
17.     sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
    9 C" L: b' Y2 M' }8 c6 N; ]) r
18.     if (HAL_TIM_ConfigClockSource(&htim4, &sClockSourceConfig) != HAL_OK)
    
19.     {
    0 I& }! Z$ t8 [* ?, _* |3 T- \( L
20.         return FALSE;
    
21.     }
    3 K/ G% Z4 Z7 Q" |: D
22.     sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
    
23.     sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
    : f. V/ c  s0 ^! [3 D
24.     if (HAL_TIMEx_MasterConfigSynchronization(&htim4, &sMasterConfig) != HAL_OK)
    * t+ K. Q# H% ^5 x
25.     {
    
26.         return FALSE;
    
27.     }
    " x9 @9 f( C( u  Z
28. 
    
29.     __HAL_TIM_ENABLE_IT(&htim4, TIM_IT_UPDATE);                                        // 使能定时器更新中断
    
30.     return TRUE;
    
31. }
    5 F, G( K/ s' i4 g( |
32. 
    / X7 c: c- T/ m8 [+ V0 U# Y; L
33. inline void
    
34. vMBPortTimersEnable(  )
    6 q2 c$ a" I6 `! v0 T& P
35. {
    
36.     __HAL_TIM_SET_COUNTER(&htim4, 0);                // 清空计数器
    
37.     __HAL_TIM_ENABLE(&htim4);                                // 使能定时器
    9 o) c/ w0 n! u% y( M
38. }
    ; \5 P+ \5 N$ ~0 ]7 \- \% ~
39. 
    ) G# x# i. z% t* u
40. inline void
    3 K# V. D) M# z/ s8 ?5 l2 ?4 _
41. vMBPortTimersDisable(  )
    
42. {
    4 v2 J4 x6 T( S0 f, M, v
43.     __HAL_TIM_DISABLE(&htim4);                                // 禁能定时器
    
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.
    
49. */
    
50. static void prvvTIMERExpiredISR( void )
    $ C7 H2 [- k: @5 y4 F$ F3 \
51. {
    ( x. Z( a: W9 }$ m: f5 N$ E2 B7 [
52.     ( void )pxMBPortCBTimerExpired(  );
    0 W) e, Q9 ~! T( y6 O
53. }
    9 K4 Q+ T: q6 I% @/ o3 p* ~, t! ?
54. 
    7 V  O8 S2 [+ Q9 g
55. /// 定时器4中断服务程序
    : G9 h( m/ b" {0 }$ s6 a0 b
56. void TIM4_IRQHandler(void)
    , z: m  v, F5 M2 |
57. {
    $ y3 Y2 d! m: d% l, I, {/ _
58.     if(__HAL_TIM_GET_FLAG(&htim4, TIM_FLAG_UPDATE))                        // 更新中断标记被置位
    " d5 U$ x0 R3 J# C5 v
59.     {
    9 j! p5 f6 z  C) Z$ o
60.         __HAL_TIM_CLEAR_FLAG(&htim4, TIM_FLAG_UPDATE);                // 清除中断标记
    
61.         prvvTIMERExpiredISR();                                                                // 通知modbus3.5个字符等待时间到
    * [9 k: j1 |5 O: I; T# o9 S
62.     }
    , G7 t9 i# A% B0 H- K" v
63. }
    5 G) l1 E$ ?6 y0 @" G4 K/ \+ i; T
64. 
    
65. 
    

复制代码

; `, O) ~4 U( u. \" ~7 |修改modbus串口初始化源代码portserial.c文件
1 D6 ?% z0 ?1 q5 k% W: s* b         ~~~~~~~~        在该文件中实现串口1的中断服务程序，prvvUARTTxReadyISR和prvvUARTRxISR函数需要填写进中断服务程序，前者得到作用为通知modbus协议栈串口已经空闲可以发送数据了，后者的作用为通知modbus串口1有数据到达，修改后的代码如下：
) h3 [2 O4 q  N6 M+ L( e
8 Q+ l& G5 d) F2 j5 [0 q& S! X; w

1. /*
   3 T/ r) Q0 Q7 [& U
2. * FreeModbus Libary: BARE Port
     {/ O6 |# e6 q" b* f
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
   
8. * version 2.1 of the License, or (at your option) any later version.
   7 Q) T* [- O  B$ F' a( w0 s! D+ ~
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
    
12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    1 ]6 o) g+ Z, g- Z/ ~$ \. V
13. * Lesser General Public License for more details.
    5 g- B, Z' G& v: u
14. *
    # P( Z0 O! d9 y0 d+ P9 q/ p
15. * You should have received a copy of the GNU Lesser General Public
    ! s) ^5 Q8 ]5 Q2 `/ @
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$
    
20. */
    ; x" k0 O$ K) \$ w' ]% ?  U
21. 
    - M3 h5 }' _4 P2 F
22. #include "port.h"
    3 N' v+ X/ ]7 R; K$ i8 J3 \- P
23. #include "usart.h"
    ) u) W6 k, t5 Z, p$ q% a
24. 
    # {" w& T# U: X" g5 Z& A! ^
25. /* ----------------------- Modbus includes ----------------------------------*/
    
26. #include "mb.h"
    
27. #include "mbport.h"
    
28. 
    
29. /* ----------------------- static functions ---------------------------------*/
    $ y5 K8 W" N; ?' K
30. static void prvvUARTTxReadyISR( void );
    + y: l; N- ~, Q" m+ h6 h+ u
31. static void prvvUARTRxISR( void );
    5 ]5 X) G0 X4 `3 w2 ]
32. 
    9 u! A4 E* e* x1 u! s5 {
33. /* ----------------------- Start implementation -----------------------------*/
    
34. void
    8 ~' k& P  |+ k7 a8 p" H/ G: ?
35. vMBPortSerialEnable( BOOL xRxEnable, BOOL xTxEnable )
    
36. {
    5 X& W3 `) {+ Q: t5 ^( O) _
37.     if(xRxEnable)
    ' }# o9 l. x" f8 ~
38.     {
    : L) ~. F/ {  B2 q6 b; A1 Q
39.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_RXNE);                // 使能接收非空中断
    
40.     }
    7 Y4 f6 l4 z; F" T; t* {+ q- q
41.     else
    $ E; J1 x) X, s( k  M, J
42.     {
    . k1 y9 o$ s3 B+ n) l
43.         __HAL_UART_DISABLE_IT(&huart1, UART_IT_RXNE);                // 禁能接收非空中断
    
44.     }
    # ]8 r" X9 `5 E: ?7 V& }
45. 
    : l5 S. Z( w  q  U
46.     if(xTxEnable)
    
47.     {
    
48.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_TXE);                        // 使能发送为空中断
    - d9 u& d  y, _7 b  {% ^' A
49.     }
    ) t$ s; z$ s' w/ Y) h3 F
50.     else
    
51.     {
    4 e6 l3 W; {5 Q' P& U' g% P- s) Z
52.         __HAL_UART_DISABLE_IT(&huart1, UART_IT_TXE);                // 禁能发送为空中断
    3 L  N: m& y$ B6 \( B8 B' K6 H0 G1 A3 E
53.     }
    
54. }
    ) p* i: a+ V; |/ \$ r9 K4 D' @
55. 
    
56. BOOL
    6 e( [' Q" s- J3 ^% I" X9 L
57. xMBPortSerialInit( UCHAR ucPORT, ULONG ulBaudRate, UCHAR ucDataBits, eMBParity eParity )
    
58. {
    
59.     huart1.Instance = USART1;
    
60.     huart1.Init.BaudRate = ulBaudRate;
    
61.     huart1.Init.StopBits = UART_STOPBITS_1;
    
62.     huart1.Init.Mode = UART_MODE_TX_RX;
    * P  f9 U9 Z' P, m$ U& ?
63.     huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    
64.     huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    ) D, c& v8 ~! z' Q! a
65. 
    $ ?7 ^: q- c$ F3 ^" g
66.     switch(eParity)
    9 w- A) ?1 |% W/ m; ~8 I  S+ U
67.     {
    
68.         // 奇校验
    ! M. X, P6 d) z% X: ~
69.     case MB_PAR_ODD:
    ( B3 T  r7 C3 f7 J9 }( G
70.         huart1.Init.Parity = UART_PARITY_ODD;
    
71.         huart1.Init.WordLength = UART_WORDLENGTH_9B;                        // 带奇偶校验数据位为9bits
    4 b) n; Q* l% k* E$ Q+ i# Z# {- v. y4 r
72.         break;
    
73.         
    8 C  p" f, `% n8 U% [) y
74.         // 偶校验
    
75.     case MB_PAR_EVEN:
    . j! X* U$ J3 _" @! w" H8 p6 ]0 O
76.         huart1.Init.Parity = UART_PARITY_EVEN;
    4 R1 N& x+ m- P
77.         huart1.Init.WordLength = UART_WORDLENGTH_9B;                        // 带奇偶校验数据位为9bits
    + S- f! X# j6 Q' B, C: [- U: k
78.         break;
    
79.         
    
80.         // 无校验
    # X5 {9 [* @( n8 m
81.     default:
    4 ]: s: |4 C, K, u! k- S3 `1 M9 O
82.         huart1.Init.Parity = UART_PARITY_NONE;
    * r; e' O5 X: X! v  e. U1 g
83.         huart1.Init.WordLength = UART_WORDLENGTH_8B;                        // 无奇偶校验数据位为8bits
    
84.         break;
    % C' @' c. j& E  Y7 v
85.     }
    . U6 Q6 l1 N# M4 R6 T
86.     return HAL_UART_Init(&huart1) == HAL_OK ? TRUE : FALSE;
    ; D3 D" _3 x% K) F
87. }
    ( d: J6 u' T0 R1 R) s: O
88. 
    . C$ k# U, X/ l& C1 S
89. BOOL
    
90. xMBPortSerialPutByte( CHAR ucByte )
    
91. {
    
92.     USART1->DR = ucByte;
    
93.     return TRUE;
    
94. }
    
95. 
    ) J# a9 Y0 ]: K3 [  w+ r/ q4 o1 G$ W
96. BOOL
    
97. xMBPortSerialGetByte( CHAR * pucByte )
    
98. {
    
99.     *pucByte = (USART1->DR & (uint16_t)0x00FF);
    
100.         return TRUE;
     
101. }
     3 c% ~) p/ d5 D1 |
102. 
     $ t: {7 R' I: P- s' f! C% r
103. /* Create an interrupt handler for the transmit buffer empty interrupt
     
104. * (or an equivalent) for your target processor. This function should then
     / m+ \3 G# q- {- z& g/ w
105. * call pxMBFrameCBTransmitterEmpty( ) which tells the protocol stack that
     # ^9 X. j* j2 t8 A. R  q3 p6 I  z
106. * a new character can be sent. The protocol stack will then call
     / I3 _6 U* o+ a: c
107. * xMBPortSerialPutByte( ) to send the character.
     9 o' L9 A, R6 y: t4 J3 P3 H& _
108. */
     - E+ E0 G& D' {+ o" [. T, J$ f+ N/ f+ [
109. static void prvvUARTTxReadyISR( void )
     
110. {
     / f" Y  g  W( n6 c
111.     pxMBFrameCBTransmitterEmpty(  );
     
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
     
117. * character.
     
118. */
     8 e0 G1 t) [- K
119. static void prvvUARTRxISR( void )
     
120. {
     
121.     pxMBFrameCBByteReceived(  );
     ' _  R7 h. B5 j$ E1 k( F8 u
122. }
     4 t9 n' H+ m% g% ]- u) J4 v4 A( k
123. 
     
124. void USART1_IRQHandler(void)
     
125. {
     * I' e: t8 p1 c2 {6 ]# x9 `  v$ g9 ^6 o
126.     if(__HAL_UART_GET_FLAG(&huart1, UART_FLAG_RXNE))                        // 接收非空中断标记被置位
       H6 W% e6 p, j1 G8 J9 a
127.     {
     ! t* S! {( i# W9 ]' \0 j9 P: J4 V' ]
128.         __HAL_UART_CLEAR_FLAG(&huart1, UART_FLAG_RXNE);                        // 清除中断标记
     7 N  e: p" F" j# k
129.         prvvUARTRxISR();                                                                                // 通知modbus有数据到达
     - e  N0 r0 `: l& H  `# E4 d6 D* a  r
130.     }
     
131. 
     
132.     if(__HAL_UART_GET_FLAG(&huart1, UART_FLAG_TXE))                                // 发送为空中断标记被置位
     
133.     {
     ' p9 D1 d9 c7 s* o) K! u, s
134.         __HAL_UART_CLEAR_FLAG(&huart1, UART_FLAG_TXE);                        // 清除中断标记
     6 I& b4 R* T1 [, V! H  q/ b% \
135.         prvvUARTTxReadyISR();                                                                        // 通知modbus数据可以发松
     
136.     }
     
137. }

复制代码

/ {# I$ Q& r+ a+ ]6 p* o注意一点，一般如果使用了485芯片的话，那么同一时刻只能接收或者发送，可以将函数vMBPortSerialEnable修改成这样：

  b. E. [3 v3 M% O1 k: I

1. void
   - Y0 x$ i" C! V/ ~1 r
2. vMBPortSerialEnable( BOOL xRxEnable, BOOL xTxEnable )
   
3. {
   
4.     if(xRxEnable)
   
5.     {
   
6.             //
   / |/ J  i( o( M; P/ t  r( v* K
7.         // 在此处将485芯片设置为接收模式
   * Q) D4 @: I3 x! x7 t
8.         //
   4 j+ ?3 W  T- m/ r- x& X$ k+ J
9.                 /* do something */
   
10.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_RXNE);                // 使能接收非空中断
    
11.     }
      Y4 I) U& Y  J& U% ~: M8 z+ _
12.     else
    
13.     {
    9 C$ |! l+ q' A  c
14.         __HAL_UART_DISABLE_IT(&huart1, UART_IT_RXNE);                // 禁能接收非空中断
    & t: j6 S: j2 e: o( a" }
15.     }
    
16. 
    - V" i, w' G/ c. Y9 x$ h
17.     if(xTxEnable)
    
18.     {
    ) t, J' d$ H. h/ b, G+ A
19.             //
    
20.         // 在此处将485芯片设置为发送模式
    # E' t5 S" v' \2 `
21.         //
    : B# D2 u5 _* Z+ w
22.         /* do something */
    
23.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_TXE);                        // 使能发送为空中断
    
24.     }
    
25.     else
    ) {; G, y0 ?2 m4 L4 @1 v
26.     {
    
27.         __HAL_UART_DISABLE_IT(&huart1, UART_IT_TXE);                // 禁能发送为空中断
    % y5 w9 g; `1 K: F' h5 I/ d; p
28.     }
    
29. }

复制代码

. S8 K# c0 t8 g$ ]* O. F编写modbus命令处理回调函数port.c文件
. N: O( a7 O* F7 b6 ^6 |0 S本例程只实现了读取输入寄存器和保持寄存器的功能，详细代码如下：
) W5 f4 ^/ R8 v3 }

1. #include "mb.h"
   
2. #include "mbport.h"
   
3. 
   
4. 
   
5. // 十路输入寄存器
   3 f5 F$ u( A5 z$ t' h
6. #define REG_INPUT_SIZE  10
   4 T1 a* ?, p  {% ~. q( ~# `
7. uint16_t REG_INPUT_BUF[REG_INPUT_SIZE];
   
8. 
   
9. 
   ; k. C; ?( R  k& o( k9 c
10. // 十路保持寄存器
    ' E& e. A5 J9 h4 z5 C8 D2 a
11. #define REG_HOLD_SIZE   10
    
12. uint16_t REG_HOLD_BUF[REG_HOLD_SIZE];
    - v5 p6 M& o% g! a
13. 
    5 e& U# ~4 D3 ^1 T
14. 
    " q/ k- O. V; T$ O& N: `0 c6 v
15. // 十路线圈
    ; U; h$ i- R1 @) N
16. #define REG_COILS_SIZE 10
    " O8 Y& E; E0 w5 X7 c  |- S/ z
17. uint8_t REG_COILS_BUF[REG_COILS_SIZE];
    % V2 x+ i# @9 r1 G1 ?8 |: v
18. 
    ! ]% R2 i9 s& o! j
19. 
    
20. // 十路离散量
    
21. #define REG_DISC_SIZE  10
    
22. uint8_t REG_DISC_BUF[10];
    
23. 
    
24. 
    / S; E( C2 l  X8 B# d* H
25. /// CMD4
    ; \) G( c8 E- R' u2 O6 J, a
26. eMBErrorCode eMBRegInputCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs )
    ' ]1 c8 [/ Q1 M5 G! A: K
27. {
    
28.     USHORT usRegIndex = usAddress - 1;
    2 ~/ ^, Y3 T6 ~* b- E
29. 
    
30.     // 非法检测
    
31.     if((usRegIndex + usNRegs) > REG_INPUT_SIZE)
    9 a! |+ o5 n0 D
32.     {
    & y( M7 C9 X2 ?! U' _
33.         return MB_ENOREG;
    
34.     }
    $ F3 G2 A* C$ T, q" f" k
35. 
    # N. _  p: S+ {) l5 k
36.     // 循环读取
    
37.     while( usNRegs > 0 )
    
38.     {
    
39.         *pucRegBuffer++ = ( unsigned char )( REG_INPUT_BUF[usRegIndex] >> 8 );
    
40.         *pucRegBuffer++ = ( unsigned char )( REG_INPUT_BUF[usRegIndex] & 0xFF );
    6 ^8 r+ ^$ G  H
41.         usRegIndex++;
    
42.         usNRegs--;
    
43.     }
    
44. 
    ' ?& P' K$ z5 y* R
45.     // 模拟输入寄存器被改变
    
46.     for(usRegIndex = 0; usRegIndex < REG_INPUT_SIZE; usRegIndex++)
    
47.     {
    4 n+ p/ n3 M. Z7 r( d1 ^! H
48.         REG_INPUT_BUF[usRegIndex]++;
    % T9 Y2 ?' I9 I- r# X
49.     }
    
50. 
    
51.     return MB_ENOERR;
    
52. }
    ! F- O9 p2 W. N4 J4 Z( Z- K" }
53. 
    & P1 S  Y/ |4 M( f
54. /// CMD6、3、16
    / e( ^/ @' ?4 Y9 v+ Z( [
55. eMBErrorCode eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs, eMBRegisterMode eMode )
    5 |) p! E+ x6 F1 y# m3 @
56. {
    - t- I; {5 Z  @( U. ^" q. t
57.     USHORT usRegIndex = usAddress - 1;  
    
58. 
    
59.     // 非法检测
    + z. {* b0 {% m# W
60.     if((usRegIndex + usNRegs) > REG_HOLD_SIZE)
    
61.     {
    + F+ S& U7 G; l2 X. [
62.         return MB_ENOREG;
    
63.     }
    
64. 
    
65.         // 写寄存器
      z; b+ G) I$ e! x" N% @
66.     if(eMode == MB_REG_WRITE)
    4 n* T% A2 y3 N" ~7 L2 Q4 Z: B. f
67.     {
    
68.         while( usNRegs > 0 )
    . h2 Q+ l5 R" Y. V  H  S) _* _
69.         {
    7 e4 \5 s9 U5 x6 g
70.                         REG_HOLD_BUF[usRegIndex] = (pucRegBuffer[0] << 8) | pucRegBuffer[1];
    ! [- u1 U2 q1 C6 N( H" k% S
71.                         pucRegBuffer += 2;
    
72.             usRegIndex++;
    9 o& P3 v, X  q* I, V. s2 x$ b
73.             usNRegs--;
    
74.         }
    
75.     }
    3 e  T0 y' E& x5 Z  W
76.         
    ' H$ s2 J7 m, D2 P
77.         // 读寄存器
    
78.     else
    7 q# e6 Z. t$ b3 ?9 M
79.     {
    * @0 q: [$ K- N# B* ?0 j
80.         while( usNRegs > 0 )
    2 E8 {% b: A$ v- _. G, m
81.         {
    - m9 X9 t" m2 L* C: c
82.             *pucRegBuffer++ = ( unsigned char )( REG_HOLD_BUF[usRegIndex] >> 8 );
    / k3 m, v' Z& u; h
83.             *pucRegBuffer++ = ( unsigned char )( REG_HOLD_BUF[usRegIndex] & 0xFF );
    4 K' N3 \; g( c7 l  W
84.             usRegIndex++;
    
85.             usNRegs--;
    
86.         }
    
87.     }
    ! A9 U& ^; Z$ P; i: f/ o
88. 
    ' q: ^6 W, G. k
89.     return MB_ENOERR;
    
90. }
    
91. 
    1 p% m2 J5 A2 V* \" U
92. /// CMD1、5、15
    
93. eMBErrorCode eMBRegCoilsCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNCoils, eMBRegisterMode eMode )
    
94. {
    0 L2 ^6 {; d+ [2 a, o
95.     USHORT usRegIndex   = usAddress - 1;
    : h+ |9 f+ H2 _; b/ n7 i/ M0 |
96.     USHORT usCoilGroups = ((usNCoils - 1) / 8 + 1);
    
97.     UCHAR  ucStatus     = 0;
    
98.     UCHAR  ucBits       = 0;
      z1 h8 Y# S. L8 J* @" b% g) G
99.     UCHAR  ucDisp       = 0;
    
100. 
     9 {- r5 H( g+ \2 k: a3 c; o; y5 G
101.     // 非法检测
     , `) l+ \2 D0 J: ?
102.     if((usRegIndex + usNCoils) > REG_COILS_SIZE)
     9 y8 {) I  K: ^/ z! U
103.     {
     
104.         return MB_ENOREG;
     $ D/ I% `2 C% O0 r
105.     }
     
106. 
     & L3 k- n# q  @5 ~( B
107.     // 写线圈
     + V# ^# B7 e6 \- r3 k% O- s3 ?
108.     if(eMode == MB_REG_WRITE)
     
109.     {
       h5 `0 L1 V9 x4 Y! s9 }
110.         while(usCoilGroups--)
     
111.         {
     
112.             ucStatus = *pucRegBuffer++;
     ' L* F9 c1 a' c' C' A2 b+ b0 V
113.             ucBits   = 8;
     
114.             while((usNCoils--) != 0 && (ucBits--) != 0)
     * c; S2 {/ O( I% D3 V1 v
115.             {
     
116.                 REG_COILS_BUF[usRegIndex++] = ucStatus & 0X01;
     : V# `" M" A! _: C1 N
117.                 ucStatus >>= 1;
     
118.             }
     
119.         }
     
120.     }
     8 N$ E8 i: B! o$ }* J
121. 
     - f2 n& E: c: _" W
122.     // 读线圈
     7 N6 m1 Q' _' O% `
123.     else
     , p; G3 _. z; [% n# _
124.     {
     ( H. T9 P- I: G5 v- s4 U: }
125.         while(usCoilGroups--)
     & a/ M8 L' U1 X, _$ s
126.         {
     * p  l2 b( A% `9 V% @& G5 s# D) ^' K
127.             ucDisp = 0;
     
128.             ucBits = 8;
     ' m3 C7 ~8 ~7 v3 n7 M0 K8 U; E4 M
129.             while((usNCoils--) != 0 && (ucBits--) != 0)
     0 P7 r) f1 P9 E& m. P/ u2 O1 |
130.             {
     - K5 q. S( z/ F$ [" V" l  e% h( @
131.                 ucStatus |= (REG_COILS_BUF[usRegIndex++] << (ucDisp++));
     
132.             }
     5 Q) j, a0 `, m7 ]/ @# v7 s
133.             *pucRegBuffer++ = ucStatus;
     
134.         }
     3 u; b% P+ ]" C8 B
135.     }
     
136.     return MB_ENOERR;
     
137. }
     
138. 
     # p5 D+ C. B, g+ v# Z8 ]; [
139. 
     
140. /// CMD4
     & O) s0 P* w2 J/ u
141. eMBErrorCode eMBRegDiscreteCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNDiscrete )
     ; v7 [4 m$ O$ |: K0 y& B
142. {
     
143.     USHORT usRegIndex   = usAddress - 1;
     
144.     USHORT usCoilGroups = ((usNDiscrete - 1) / 8 + 1);
     
145.     UCHAR  ucStatus     = 0;
     
146.     UCHAR  ucBits       = 0;
     
147.     UCHAR  ucDisp       = 0;
     ! Q2 y7 {0 a# C2 C4 C) x8 K2 h+ Y0 Y
148. 
     " B* Q0 B' l7 s
149.     // 非法检测
     $ b( [' Z# O/ N9 D. t
150.     if((usRegIndex + usNDiscrete) > REG_DISC_SIZE)
     
151.     {
     0 w& p- o" `/ ^8 c% L. ?
152.         return MB_ENOREG;
     / @) {% X, A2 \( R
153.     }
     1 a3 L  V" ]2 a! {1 _
154. 
     
155.         // 读离散输入
     
156.         while(usCoilGroups--)
     ! Y! S' T1 c; I, ^( @
157.         {
     2 {6 _* j' D2 j9 E
158.                 ucDisp = 0;
     
159.                 ucBits = 8;
     4 S  y/ m: O7 V- [# B/ B4 j* O$ b0 @
160.                 while((usNDiscrete--) != 0 && (ucBits--) != 0)
     
161.                 {
     
162.                         if(REG_DISC_BUF[usRegIndex])
     
163.                         {
     $ p* d9 T! b( X+ Y2 y
164.                                 ucStatus |= (1 << ucDisp);
     1 h1 E0 p7 q  `2 J  T
165.                         }
     
166.                         ucDisp++;
     - s0 S4 O# X% P1 w
167.                 }
     # i9 h! {6 F7 E# l$ c' n
168.                 *pucRegBuffer++ = ucStatus;
     9 ~1 z% e& R8 C% H$ F
169.         }
     
170. 
     
171.     // 模拟改变
     
172.     for(usRegIndex = 0; usRegIndex < REG_DISC_SIZE; usRegIndex++)
     
173.     {
     
174.         REG_DISC_BUF[usRegIndex] = !REG_DISC_BUF[usRegIndex];
     
175.     }
     $ L8 N& L; b  R& k! x
176. 
     / h- h1 P1 Z1 r1 I. @1 |. l9 \
177.     return MB_ENOERR;
     * @9 J! \( r9 M5 b
178. }

复制代码

) Y$ U. m. E; N; O- U5 l主函数

1. int main(void)
   
2. {
   
3.     HAL_Init();
   
4.     SystemClock_Config();
   
5.     MX_GPIO_Init();
   - H1 u$ o  @4 {9 v4 E
6.     eMBInit(MB_RTU, 0x01, 0, 9600, MB_PAR_ODD);                // 初始化modbus为RTU方式，波特率9600，奇校验
   . n; _+ A" x7 \6 \
7.     eMBEnable();                                                                        // 使能modbus协议栈
   8 b6 G2 |# s( i& D3 F8 n2 \
8. 
   
9.     for( ;; )
   / ?% x, G5 g3 X  o
10.     {
    - v9 {6 s# M5 p
11.         eMBPoll();                                                                        // 轮训查询
    , G. }; }, C# b" Y( p0 [
12.     }
    
13. }

复制代码

" q9 z1 @  v  M2 G' n; Y6 j移植测试


( w: @+ q* [) ?0 s
  j  K, b& ?# k3 k' D9 Zends…
9 @+ h3 ^/ T% O. B8 V$ w3 ]

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