官方下载freemodbus-v1.6.zip源码，然后把源码中的modbus文件夹、demo\BARE\port文件夹导入工程。
1 k9 v3 x$ E' S
先是一波无脑导，把文件夹里所有文件导入。
+ Q1 ?' B! O$ i  e- P
; N5 ?  ~, U8 a' X0 }9 V: w存储区配置，单片机上定义的起始地址要比实际通信过程中读写的地址+1。

1. #include "mb.h"
   
2. #include "mbport.h"
   
3. #include "mbutils.h"
   
4. //输入寄存器
   
5. #define REG_INPUT_START 1001
   & C9 l+ u2 @- Y0 [8 W
6. #define REG_INPUT_NREGS 2
   / Q$ g) g8 [8 m  p! D: |5 j' J% F
7. 
   
8. static USHORT   usRegInputStart = REG_INPUT_START;
   
9. static USHORT   usRegInputBuf[REG_INPUT_NREGS];
   
10. 
    3 o# X5 N! \' C- B; d
11. //保持寄存器
    
12. #define REG_HOLDING_START 2001
    , `( @6 |* y, l& `  Q6 V( }
13. #define REG_HOLDING_NREGS 1
    4 k1 O$ e. G0 m! P. P
14. 
    $ J% o6 J5 F! @5 K/ [& n- j
15. static USHORT   usRegHoldingStart = REG_HOLDING_START;
    
16. static USHORT   usRegHoldingBuf[REG_HOLDING_NREGS];
    
17. 
    
18. //输出线圈点
    
19. #define REG_COILS_START 3001
    
20. #define REG_COILS_SIZE 4
    
21. 
    % D; i: c+ T9 T
22. static USHORT   usRegCoilsStart = REG_COILS_START;
    * B5 g! o) J' q- @
23. static UCHAR           ucRegCoilsBuf[REG_COILS_SIZE/8+(REG_COILS_SIZE%8?1:0)];
    
24. 
    
25. //离散输入点
    
26. #define REG_DISCRETE_START 4001
    8 k( \: E) [: T
27. #define REG_DISCRETE_SIZE 8
    2 ~. h3 b8 N2 G! y4 u3 ~* x0 q
28. 
    : x* _" W( F3 B2 J  J& ]3 |+ i
29. static USHORT   usRegDiscreteStart = REG_DISCRETE_START;
    
30. static UCHAR           ucRegDiscreteBuf[REG_DISCRETE_SIZE/8+(REG_DISCRETE_SIZE%8?1:0)];
    ; J/ y; e9 [* T# G" ^
31. 
    3 E4 ]% k( Y& l4 q" \9 q

复制代码

. A) {9 F: p6 l! d主程序就是标准的运行三连+IO读写。

1. eStatus = eMBInit( MB_RTU, addr, 0, 9600, MB_PAR_EVEN );
   9 T) V+ E2 _" w" ]. s1 @
2. 
   
3.     /* Enable the Modbus Protocol Stack. */
   
4.     eStatus = eMBEnable(  );
   # e; g% d  G' B7 Q' \9 D3 H
5. 
   
6.     for( ;; )
   
7.     {
   * p" ?% X1 o: S4 l) K
8.         ( void )eMBPoll(  );
   3 z" F" k3 U0 E# G2 M$ G5 \+ v) o
9.         usRegInputBuf[0]=Get_Adc_Average(8,10);
   0 y$ e. c5 h# V. i2 G
10.         usRegInputBuf[1]=Get_Adc_Average(9,10);
      u! \) d1 H4 a+ l: l
11.                        
    
12.         ucRegDiscreteBuf[0]=(GPIOB->IDR&0xFFFFFF00)>>8;
    1 S; y6 I2 K' ]0 @/ v5 M
13.         GPIOB->ODR=GPIOB->ODR&0xFFFFFF0F;
    
14.         GPIOB->ODR=GPIOB->ODR|ucRegCoilsBuf[0]<<4;
    
15.     }
    

复制代码

7 Z  D( ?( m* a& b支持的4种读写function扔在主函数后面就行了。

1. /**
   
2. * @brief 输入寄存器处理函数，输入寄存器可读，但不可写。
   ; u: }  d  j, J' n6 F* e/ ?* ?
3. * @param pucRegBuffer 返回数据指针
     I3 m* V5 w: b7 B- }& ~
4. * usAddress 寄存器起始地址
   
5. * usNRegs 寄存器长度
   
6. * @retval eStatus 寄存器状态
   # e5 e2 I0 S0 \* Y- T4 Q5 m% \
7. */
   
8. eMBErrorCode
   
9. eMBRegInputCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs )
   
10. {
    
11.     eMBErrorCode eStatus = MB_ENOERR;
    $ D$ i" m; o" H% `
12.     int16_t iRegIndex;
    5 b5 z4 u" J0 K' g7 |" b! l" n
13. 
    
14.     //查询是否在寄存器范围内
    / p  a) ~9 l6 O  H) N& o, w- m
15.     //为了避免警告，修改为有符号整数
    
16.     if( ( (int16_t)usAddress >= REG_INPUT_START ) \
    
17.             && ( usAddress + usNRegs <= REG_INPUT_START + REG_INPUT_NREGS ) )
    
18.     {
    
19.         //获得操作偏移量，本次操作起始地址-输入寄存器的初始地址
    
20.         iRegIndex = ( int16_t )( usAddress - REG_INPUT_START );
    7 ?$ w2 @# N! t" A
21.         //逐个赋值
    
22.         while( usNRegs > 0 )
    
23.         {
    , V3 `0 r2 Y( d6 W4 \+ q6 z
24.             //赋值高字节
    
25.             *pucRegBuffer++ = ( uint8_t )( usRegInputBuf[iRegIndex] >> 8 );
    0 X: I2 ?8 N, x6 R
26.             //赋值低字节
      M9 i* l; r8 t0 J, @
27.             *pucRegBuffer++ = ( uint8_t )( usRegInputBuf[iRegIndex] & 0xFF );
    
28.             //偏移量增加
    : V. U. p8 O) ~) L4 e
29.             iRegIndex++;
    + V% W1 x, y: D! V" o+ {4 o, A
30.             //被操作寄存器数量递减
    . c$ S# Z- g0 E3 h
31.             usNRegs--;
    
32.         }
    5 [' f' k3 a3 @# w4 M, a% v. @: u1 Q
33.     }
    
34.     else
    * O$ j8 M1 E1 m+ i4 H1 P8 d% |
35.     {
    + h' C$ s& h3 x2 G" F5 ~
36.         //返回错误状态，无寄存器
    & U% w. z0 z2 c1 F* E* c/ w3 j
37.         eStatus = MB_ENOREG;
    % W( K( h6 K& R, v& F; x/ ^
38.     }
    
39. 
    
40.     return eStatus;
    
41. }
    
42. 
    
43. /**
    
44. * @brief 保持寄存器处理函数，保持寄存器可读，可读可写
    
45. * @param pucRegBuffer 读操作时--返回数据指针，写操作时--输入数据指针
    # M& X9 `) r& a$ L- A
46. * usAddress 寄存器起始地址
    + `3 J4 b+ R+ d
47. * usNRegs 寄存器长度
    $ o( z2 j4 A. O: p/ M
48. * eMode 操作方式，读或者写
    
49. * @retval eStatus 寄存器状态
    
50. */
    
51. eMBErrorCode
    
52. eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs,
    
53.                  eMBRegisterMode eMode )
    8 Y& i$ C- L( q4 h) B9 p6 q7 A8 O+ S
54. {
    2 Z" I, s/ Y4 o3 U
55.     //错误状态
    & C: n; w% j: s$ h  l1 e
56.     eMBErrorCode eStatus = MB_ENOERR;
    9 E! U; o" S- o) ^
57.     //偏移量
    & P* ^" V! H) G7 ~
58.     int16_t iRegIndex;
    
59. 
    
60.     //判断寄存器是不是在范围内
    
61.     if( ( (int16_t)usAddress >= REG_HOLDING_START ) \
    
62.             && ( usAddress + usNRegs <= REG_HOLDING_START + REG_HOLDING_NREGS ) )
    0 {' p' g6 E, }1 O7 F% E6 d
63.     {
    / e$ G0 n! U. w& j
64.         //计算偏移量
    
65.         iRegIndex = ( int16_t )( usAddress - REG_HOLDING_START );
    
66. 
    
67.         switch ( eMode )
    5 J. N' y% `5 j  y& r. z' w
68.         {
    % a9 K' N, ]; D/ `$ {
69.         //读处理函数
    
70.         case MB_REG_READ:
    
71.             while( usNRegs > 0 )
    : q, o7 X+ S9 E, c% l; n; j! k
72.             {
    
73.                 *pucRegBuffer++ = ( uint8_t )( usRegHoldingBuf[iRegIndex] >> 8 );
    . V; o$ N3 E& H! b& m6 K2 x
74.                 *pucRegBuffer++ = ( uint8_t )( usRegHoldingBuf[iRegIndex] & 0xFF );
    8 O7 y, I. M. {$ |4 P! O' i
75.                 iRegIndex++;
    ' q7 \! G/ e) Z8 E, D
76.                 usNRegs--;
    
77.             }
    - [; K6 x6 J5 C! N7 I
78.             break;
      F% j* g' v. h5 d: r0 j! S
79. 
    
80.         //写处理函数
    
81.         case MB_REG_WRITE:
    
82.             while( usNRegs > 0 )
    
83.             {
    5 ?1 g+ K. G4 d
84.                 usRegHoldingBuf[iRegIndex] = *pucRegBuffer++ << 8;
    
85.                 usRegHoldingBuf[iRegIndex] |= *pucRegBuffer++;
    
86.                 iRegIndex++;
    , y4 w3 }# }2 u- n, A3 c! O! L
87.                 usNRegs--;
    + r$ F' s5 ?# I  G& U4 v
88.             }
    
89.             break;
    / t  i3 D) v5 Q/ b
90.         }
    
91.     }
    8 [) S+ M4 x9 G" [8 q
92.     else
    
93.     {
    
94.         //返回错误状态
    
95.         eStatus = MB_ENOREG;
    
96.     }
    
97. 
    
98.     return eStatus;
    . t8 p- N0 Y0 `# `
99. }
    
100. 
     ) A- F: y( j, O: j! ^! N
101. 
     
102. 
     
103. 
     + f* j+ O# C/ P2 f) J8 \
104. /**
     * T6 Q& R3 Q, \: Q
105. * @brief 线圈寄存器处理函数，线圈寄存器可读，可读可写
     
106. * @param pucRegBuffer 读操作---返回数据指针，写操作--返回数据指针
     : r1 j2 [& U1 g. t
107. * usAddress 寄存器起始地址
     
108. * usNRegs 寄存器长度
     * G1 U6 I3 i+ J' `& ~; [
109. * eMode 操作方式，读或者写
     
110. * @retval eStatus 寄存器状态
     - E9 ~4 J6 k) E* [  }
111. */
     
112. eMBErrorCode
     
113. eMBRegCoilsCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNCoils,
     3 x; D; K. M7 z5 W
114.                eMBRegisterMode eMode )
     
115. {
     5 M$ d# y1 H7 m% d# \% r
116.     //错误状态
     
117.     eMBErrorCode eStatus = MB_ENOERR;
       }3 a8 a! |6 c7 c% ?5 s
118.     //寄存器个数
     
119.     int16_t iNCoils = ( int16_t )usNCoils;
     $ B( x# k5 y" `) f
120.     //寄存器偏移量
     
121.     int16_t usBitOffset;
     
122. 
     % r+ p/ v; N# ]0 ?
123.     //检查寄存器是否在指定范围内
     2 F% r  R- m) F' z, P6 V
124.     if( ( (int16_t)usAddress >= REG_COILS_START ) &&
     9 g  Y$ w* L% ^3 U) C
125.             ( usAddress + usNCoils <= REG_COILS_START + REG_COILS_SIZE ) )
     
126.     {
     
127.         //计算寄存器偏移量
     / S; }  K8 }* @  m. g# j" \
128.         usBitOffset = ( int16_t )( usAddress - REG_COILS_START );
       I" F: i5 U; u
129.         switch ( eMode )
     ' G' _  c3 \/ \5 p# F8 g5 ]7 z5 t
130.         {
     
131.         //读操作
     
132.         case MB_REG_READ:
     
133.             while( iNCoils > 0 )
     1 w2 C% m  J  N2 l& b7 M+ q
134.             {
     
135.                 *pucRegBuffer++ = xMBUtilGetBits( ucRegCoilsBuf, usBitOffset,
     , j+ {0 I1 M1 `! O. }# S, @7 @
136.                                                   ( uint8_t )( iNCoils > 8 ? 8 : iNCoils ) );
     5 d- u/ F2 }8 z8 G" e" `! i; I
137.                 iNCoils -= 8;
     ' ?8 a$ K3 \$ V* T, a
138.                 usBitOffset += 8;
     
139.             }
     
140.             break;
     
141. 
     
142.         //写操作
     
143.         case MB_REG_WRITE:
     
144.             while( iNCoils > 0 )
     
145.             {
     
146.                 xMBUtilSetBits( ucRegCoilsBuf, usBitOffset,
     
147.                                 ( uint8_t )( iNCoils > 8 ? 8 : iNCoils ),
     % |: H7 ^4 E$ m3 M% z- c. b1 t
148.                                 *pucRegBuffer++ );
     ' P6 p& X6 Y& E% W
149.                 iNCoils -= 8;
     / ^/ y! k& c' S% Q, Z  W) o
150.                 usBitOffset += 8;
     3 O% r! a/ V9 r8 s& m( T
151.             }
     1 k' |* i0 n8 p$ @5 I
152.             break;
     5 e& @. S: \/ u2 p5 ]7 H8 s# M
153.         }
     . T/ @" @2 n% r4 Y' w2 {3 G, {
154. 
     
155.     }
     
156.     else
     
157.     {
     5 b% p- \- g" |( x: |, k4 X* l
158.         eStatus = MB_ENOREG;
     + M  b) S. W, h6 L9 m( h
159.     }
     
160.     return eStatus;
     8 d3 v& I9 y# Y# n9 Q" \: K+ f
161. }
     9 @: J- l, F5 [, s) {* |( X1 _- s
162. 
     7 f7 L4 s- Q+ f3 u3 t! B
163. 
     / c; a. J6 t" g8 r- |9 e1 |% J
164. 
     
165. 
     
166. /**
     
167. * @brief 开关输入寄存器处理函数，开关输入寄存器，可读
     * E, Q2 D! J3 V* T
168. * @param pucRegBuffer 读操作---返回数据指针，写操作--返回数据指针
     
169. * usAddress 寄存器起始地址
     
170. * usNRegs 寄存器长度
     
171. * eMode 操作方式，读或者写
     
172. * @retval eStatus 寄存器状态
     
173. */
     8 [# m  Y$ n* H! k2 E$ s# o& k# b; L
174. eMBErrorCode
     
175. eMBRegDiscreteCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNDiscrete )
     
176. {
     
177.     //错误状态
     
178.     eMBErrorCode eStatus = MB_ENOERR;
     3 C) y1 N, [1 T4 D3 _( {
179.     //操作寄存器个数
     
180.     int16_t iNDiscrete = ( int16_t )usNDiscrete;
     : S, Z- y. J1 S1 Z
181.     //偏移量
     $ y# c7 o' p. H
182.     uint16_t usBitOffset;
     ) O7 F" ~: M  o& E
183. 
     
184.     //判断寄存器时候再指定范围内
     
185.     if( ( (int16_t)usAddress >= REG_DISCRETE_START ) &&
     3 r1 i& m- x! I- t
186.             ( usAddress + usNDiscrete <= REG_DISCRETE_START + REG_DISCRETE_SIZE ) )
     8 N& y( O0 D' A" [  a
187.     {
     
188.         //获得偏移量
     
189.         usBitOffset = ( uint16_t )( usAddress - REG_DISCRETE_START );
     " t$ m2 L4 y9 h' p7 L, ^% y6 U
190. 
     
191.         while( iNDiscrete > 0 )
     
192.         {
     + Z$ W, {- A  ]
193.             *pucRegBuffer++ = xMBUtilGetBits( ucRegDiscreteBuf, usBitOffset,
     
194.                                               ( uint8_t)( iNDiscrete > 8 ? 8 : iNDiscrete ) );
     
195.             iNDiscrete -= 8;
     
196.             usBitOffset += 8;
     
197.         }
     5 C& [6 n( @1 p* b! u+ t
198. 
     
199.     }
     
200.     else
     
201.     {
     % X6 ?& x; P$ F; M
202.         eStatus = MB_ENOREG;
     ' ^5 W  E; G6 P, u
203.     }
     
204.     return eStatus;
     
205. }
     
206. 
     4 l. U6 h" i2 z$ q
207. 
     

复制代码

: n0 R, `$ u+ ~& `porttimer.c是和定时器相关的实现接口，计算好预分频与装载值之后，可以直接调用原子例程。

1. /*
   / j! j1 g6 g) H% H( A
2. * FreeModbus Libary: BARE Port
   0 ]* J( ~3 l+ L$ V0 V- @
3. * Copyright (C) 2006 Christian Walter <wolti@sil.at>
   
4. *
   + f9 E' t  W5 |: T, F
5. * This library is free software; you can redistribute it and/or
   
6. * modify it under the terms of the GNU Lesser General Public
   ' m' o% ?! y2 p" f1 U
7. * License as published by the Free Software Foundation; either
   ; G: G; b9 |! G
8. * version 2.1 of the License, or (at your option) any later version.
   
9. *
   ( ^; h) m9 }) j5 S+ c2 k. n
10. * This library is distributed in the hope that it will be useful,
    ) i3 R. J6 Y2 B- Y% S
11. * but WITHOUT ANY WARRANTY; without even the implied warranty of
    ) `' m: w2 `& N( v; h  o
12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    3 i( z; }: r# {9 O, m- F6 ^
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
    - w0 R8 B9 d# x5 C8 l. f3 ^
17. * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
    
18. *
    
19. * File: $Id$
    0 Y# ^. y  q/ u, q1 z* A
20. */
    / B* u# L& @- y  C
21. 
    
22. #include "port.h"
    ! M+ u5 X) x# O( S, d7 N& k6 A/ L
23. 
    
24. /* ----------------------- Modbus includes ----------------------------------*/
    / u' P- \) b) P) |: ?) \5 ^
25. #include "mb.h"
    ! T8 N: ]4 v6 p- u
26. #include "mbport.h"
    5 k4 ^, G# {" z: e8 u# g# U( Z
27. 
    + ~! c$ a" p  Q& L# a# v
28. #include "rs485.h"
    
29. 
    
30. /* ----------------------- static functions ---------------------------------*/
    9 I- m) {  x' Q! P9 I
31. static void prvvUARTTxReadyISR( void );
    
32. static void prvvUARTRxISR( void );
    
33. 
    
34. /* ----------------------- Start implementation -----------------------------*/
    % y7 U( p/ j- c9 S" A& `+ \( |
35. void
    ( @7 C" J: P. G! H  M
36. vMBPortSerialEnable( BOOL xRxEnable, BOOL xTxEnable )
    + c, W: g  i  d/ x
37. {
    2 `' g; o# I0 V  e6 I7 C6 \  E
38.     /* If xRXEnable enable serial receive interrupts. If xTxENable enable
    
39.      * transmitter empty interrupts.
    5 S8 [% m7 F$ O1 B) _; @6 A
40.      */
    
41.     if(xRxEnable)
      |4 B9 K3 @. [- F# Q7 f
42.     {
    9 C, l1 M- R7 K, N; N3 Q
43.         //使能接收和接收中断
    
44.         USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
    + h1 Q0 `) E( a+ _2 f/ P. N9 D( m2 U
45.         //MAX485操作 低电平为接收模式
    1 m9 U, ]6 V; y9 I5 {+ Z
46.         //GPIO_ResetBits(GPIOD,GPIO_Pin_8);
    , d9 V: D' x3 O: r
47.         RS485_TX_EN=0;
    
48.     }
    
49.     else
    
50.     {
    
51.         USART_ITConfig(USART2, USART_IT_RXNE, DISABLE);
    4 s3 d& Y; Y& B
52.         //MAX485操作 高电平为发送模式
    
53.         //GPIO_SetBits(GPIOD,GPIO_Pin_8);
      S( p( y% N" K* Q2 `4 J' k; o
54.         RS485_TX_EN=1;
    / _3 O6 K1 l2 o) U/ i% W
55.     }
    ' ^3 F) P& ^6 @0 M  }/ P
56. 
    
57.     if(xTxEnable)
    
58.     {
    6 M0 d* m& L  R/ U& T: \3 \8 @
59.         //使能发送完成中断
    8 ~4 }5 @' ]" ?$ u" d
60.         USART_ITConfig(USART2, USART_IT_TC, ENABLE);
    5 o; I: k' K0 t. P8 N* l+ z9 Q
61.     }
    
62.     else
    2 q! ~0 N2 l6 s0 t) P3 h4 n) U$ _
63.     {
    ' U* i) F& p' Z# ?( R' |( v! _) `
64.         //禁止发送完成中断
    0 C' J# c& v" X6 c; D  |
65.         USART_ITConfig(USART2, USART_IT_TC, DISABLE);
    , u8 F# i$ B: f: F5 A8 d. ], ]( \! ]$ S
66.     }
    : a  r( N+ \9 _, {$ z6 c/ D3 e
67. 
    
68. 
    * F* H  c# q- Y% z: O
69. }
      r; \( O" R' F8 b; @/ `
70. 
    
71. BOOL
    
72. xMBPortSerialInit( UCHAR ucPORT, ULONG ulBaudRate, UCHAR ucDataBits, eMBParity eParity )
    
73. {
    0 o" b2 @5 A1 T+ Q" Y5 {: q
74.     RS485_Init(9600);        //初始化RS485
    
75.     return TRUE;
    
76.     //return FALSE;
    / o- n5 Q) q5 {: _; _
77. }
    " r7 g5 I* d9 W. T6 @, R& N
78. 
    5 l8 W) @1 V" b: }& q
79. BOOL
    
80. xMBPortSerialPutByte( CHAR ucByte )
    
81. {
    
82.     /* Put a byte in the UARTs transmit buffer. This function is called
    $ s' c5 f6 J% L1 S7 B  O0 |0 \  \
83.      * by the protocol stack if pxMBFrameCBTransmitterEmpty( ) has been
    
84.      * called. */
    * m( H8 D1 J0 Z0 T% t
85.     //发送数据
    
86.     USART_SendData(USART2, ucByte);
    1 K7 E9 X- T' Y5 F# O
87.     return TRUE;
    
88. }
    
89. 
    0 P. H2 A0 f8 K) I
90. 
    
91. BOOL
    
92. xMBPortSerialGetByte( CHAR * pucByte )
    ' f+ |2 {. F7 [* h' Y
93. {
    
94.     /* Return the byte in the UARTs receive buffer. This function is called
    $ J+ L% ]- Y7 Y& v' A
95.      * by the protocol stack after pxMBFrameCBByteReceived( ) has been called.
    6 Q# g0 o) `4 _  Z
96.      */
    
97.     //接收数据
    
98.     *pucByte = USART_ReceiveData(USART2);
    
99.     return TRUE;
    
100. 
     + m9 s8 b; t+ |4 N. y$ Z
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
     . n4 D2 f+ K7 C; |& e( C1 G: o
105. * call pxMBFrameCBTransmitterEmpty( ) which tells the protocol stack that
     ) y6 Z2 u9 M3 U, ^1 C' t- k6 U
106. * a new character can be sent. The protocol stack will then call
     
107. * xMBPortSerialPutByte( ) to send the character.
     
108. */
     4 R# b* Z. c( Q& m; m' T7 ~  \
109. static void prvvUARTTxReadyISR( void )
     + W. {* z. c& i" \' S2 r
110. {
     $ F' P. d' G8 O: v
111.     pxMBFrameCBTransmitterEmpty(  );
     % _. x) i- {6 Y, ~% m
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.
     ! J9 ?, y0 Q7 [' V4 m% H1 _/ i" _
118. */
     ! ?! n9 t% u) G' t: ?
119. static void prvvUARTRxISR( void )
     
120. {
     2 h8 j- a& ^1 F- S: M, M; W5 `$ W) m
121.     pxMBFrameCBByteReceived(  );
     & Z6 g1 B% D1 f# T$ F4 Y
122. }
     ' C4 M5 {/ Y0 R% c; u& c  D
123. 
     ; i& L6 g6 x: I6 A9 S" N; A
124. void USART2_IRQHandler(void)
     
125. {
     $ D+ ]: l/ U  T: E9 ?2 K
126.     if(USART_GetITStatus(USART2, USART_IT_RXNE) == SET)
     
127.     {
     
128.         prvvUARTRxISR();
     ( t. B/ g( t/ O! }! U! g( A
129.         //清除中断标志位
     3 [$ Y, `+ m3 o/ Z( o9 L; [" y
130.         USART_ClearITPendingBit(USART2, USART_IT_RXNE);
     
131.     }
     4 [  ^2 K0 a1 {: s% O# H9 D. r" F
132. 
     
133.     //发生完成中断
     
134.     if(USART_GetITStatus(USART2, USART_IT_TC) == SET)
     
135.     {
     $ ^: J/ s3 Q' t) p
136.         prvvUARTTxReadyISR();
     
137.         //清除中断标志
     " a2 x6 B6 U& N) F
138.         USART_ClearITPendingBit(USART2, USART_IT_TC);
     
139.     }
     5 }, b- _" Z! p
140. 
     5 U) X& {" Z( l% [0 J  i* t
141. }
     0 @& D4 }) D2 l) p! z: l4 @
142. 
     - @0 v7 @5 G) ?! S9 e

复制代码

4 B: J9 g+ R) k4 ]! lmodbus移植过程基本就完成了。
" T3 B5 R1 \5 ]9 P: K3 E4 l7 B————————————————
版权声明：小盼你最萌哒
. d2 g! i2 y0 i: \- j如有侵权请联系删除


4 v' ^  ]( \( }7 d8 H0 Z' N6 j' X